32.3 Elements of free modules

Module: sage.modules.free_module_element

File: sage/modules/free_module_element.pyx (starting at line 1)

Elements of free modules

Author Log:

William Stein
Josh Kantor

TODO: Change to use a get_unsafe / set_unsafe, etc., structure exactly like with matrices, since we'll have to define a bunch of special purpose implementations of vectors easily and systematically.

We create a vector space over $\mathbf{Q}$ and a subspace of this space.

sage: V = QQ^5
sage: W = V.span([V.1, V.2])

Arithmetic operations always return something in the ambient space, since there is a canonical map from to but not from to .

sage: parent(W.0 + V.1)
Vector space of dimension 5 over Rational Field
sage: parent(V.1 + W.0)
Vector space of dimension 5 over Rational Field
sage: W.0 + V.1
(0, 2, 0, 0, 0)
sage: W.0 - V.0
(-1, 1, 0, 0, 0)

Next we define modules over $\mathbf{Z}$ and a finite field.

sage: K = ZZ^5
sage: M = GF(7)^5

Arithmetic between the $\mathbf{Q}$ and $\mathbf{Z}$ modules is defined, and the result is always over $\mathbf{Q}$ , since there is a canonical coercion map to $\mathbf{Q}$ .

sage: K.0 + V.1
(1, 1, 0, 0, 0)
sage: parent(K.0 + V.1)
Vector space of dimension 5 over Rational Field

Since there is no canonical coercion map to the finite field from $\mathbf{Q}$ the following arithmetic is not defined:

sage: V.0 + M.0
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for '+': 'Vector space of
dimension 5 over Rational Field' and 'Vector space of dimension 5 over
Finite Field of size 7'

However, there is a map from $\mathbf{Z}$ to the finite field, so the following is defined, and the result is in the finite field.

sage: w = K.0 + M.0; w
(2, 0, 0, 0, 0)
sage: parent(w)
Vector space of dimension 5 over Finite Field of size 7
sage: parent(M.0 + K.0)
Vector space of dimension 5 over Finite Field of size 7

Matrix vector multiply:

sage: MS = MatrixSpace(QQ,3)
sage: A = MS([0,1,0,1,0,0,0,0,1])
sage: V = QQ^3
sage: v = V([1,2,3])
sage: v * A
(2, 1, 3)

TESTS:

sage: D = 46341
sage: u = 7
sage: R = Integers(D)
sage: p = matrix(R,[[84, 97, 55, 58, 51]])
sage: 2*p.row(0)
(168, 194, 110, 116, 102)

Module-level Functions

free_module_element( )

Return a vector over R with given entries.

CALL FORMATS: 1. vector(object) 2. vector(ring, object) 3. vector(object, ring) 4. vector(numpy_array)

In each case, give sparse=[True|False] as an option.

INPUT:
    elts -- entries of a vector (either a list or dict).
    R -- ring
    sparse -- optional
    
OUTPUT:
    An element of the free module over R of rank len(elts).

sage: v = vector([1,2,3]); v
(1, 2, 3)
sage: v.parent()
Ambient free module of rank 3 over the principal ideal domain Integer Ring
sage: v = vector([1,2,3/5]); v
(1, 2, 3/5)
sage: v.parent()
Vector space of dimension 3 over Rational Field

All entries must canonically coerce to some common ring:

sage: v = vector([17, GF(11)(5), 19/3]); v
Traceback (most recent call last):
...
TypeError: unable to find a common ring for all elements

sage: v = vector([17, GF(11)(5), 19]); v
(6, 5, 8)
sage: v.parent()
Vector space of dimension 3 over Finite Field of size 11
sage: v = vector([17, GF(11)(5), 19], QQ); v
(17, 5, 19)
sage: v.parent()
Vector space of dimension 3 over Rational Field
sage: v = vector((1,2,3), QQ); v
(1, 2, 3)
sage: v.parent()
Vector space of dimension 3 over Rational Field
sage: v = vector(QQ, (1,2,3)); v
(1, 2, 3)
sage: v.parent()
Vector space of dimension 3 over Rational Field
sage: v = vector(vector([1,2,3])); v
(1, 2, 3)
sage: v.parent()
Ambient free module of rank 3 over the principal ideal domain Integer Ring

You can also use free_module_element, which is the same as vector.

sage: free_module_element([1/3, -4/5])
(1/3, -4/5)

Make a vector mod 3 out of a vector over ZZ:

sage: vector(vector([1,2,3]), GF(3))
(1, 2, 0)

Any 1 dimensional numpy array of type float or complex may be passed to vector. The result will vector in the appropriate dimensional vector space over the real double field or the complex double field. The data in the array must be contiguous so columnwise slices of numpy matrices will rase an exception.

sage: import numpy
sage: x=numpy.random.randn(10)
sage: y=vector(x)
sage: v=numpy.random.randn(10)*numpy.complex(0,1)
sage: w=vector(v)

is_FreeModuleElement( )

make_FreeModuleElement_generic_dense( )

make_FreeModuleElement_generic_sparse( )

prepare( )

prepare_dict( )

vector( )

Class: FreeModuleElement

class FreeModuleElement: File: sage/modules/free_module_element.pyx (starting at line 258)
An element of a generic free module.

Functions: additive_order, change_ring, cross_product, degree, denominator, dense_vector, dict, dot_product, element, get, inner_product, is_dense, is_sparse, is_vector, iteritems, lift, list, list_from_positions, Mod, nonzero_positions, normalize, pairwise_product, plot, set, sparse_vector, support

additive_order( )

cross_product( )

dot_product( )

get( )

inner_product( )

lift( )

Mod( )

nonzero_positions( )

normalize( )

pairwise_product( )

plot( )

set( )

support( )

Special Functions: __abs__, __delitem__, __delslice__, __eq__, __ge__, __getitem__, __getslice__, __gt__, __invert__, __le__, __len__, __lt__, __mod__, __ne__, __pos__, __pow__, __rmod__, __rpow__, __setitem__, __setslice__, _hash, _latex_, _repr_, _vector_

_hash( )

_latex_( )

_repr_( )

_vector_( )

Class: FreeModuleElement_generic_dense

class FreeModuleElement_generic_dense: File: sage/modules/free_module_element.pyx (starting at line 863)
A generic dense element of a free module. a

Functions: list
Special Functions: __copy__, __delitem__, __delslice__, __getitem__, __reduce__, __setitem__, __setslice__, _hash

__copy__( )

__reduce__( )

_hash( )

Class: FreeModuleElement_generic_sparse

class FreeModuleElement_generic_sparse
File: sage/modules/free_module_element.pyx (starting at line 1101)

A generic sparse free module element is a dictionary with keys ints i and entries in the base ring.

Pickling works:

sage: v = FreeModule(ZZ, 3, sparse=True).0
sage: loads(dumps(v)) == v
True
sage: v = FreeModule(Integers(8)['x,y'], 5, sparse=True).1
sage: loads(dumps(v)) - v
(0, 0, 0, 0, 0)

sage: a = vector([-1,0,1/1],sparse=True); b = vector([-1/1,0,0],sparse=True)
sage: a.parent()
Sparse vector space of dimension 3 over Rational Field
sage: b - a
(0, 0, -1)

Functions: denominator, dict, get, iteritems, list, nonzero_positions, set

get( )

nonzero_positions( )

set( )

Special Functions: __copy__, __delitem__, __getitem__, __reduce__, __setitem__

__copy__( )

__reduce__( )

SAGE Reference Manual

Previous: 32.2 Free modules Up: 32. Modules Next: 32.4 Complex double vectors

Release 2007.10.28, documentation updated on October 28, 2007.

See About this document... for information on suggesting changes.