Elements of free modules
AUTHORS:
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.
EXAMPLES: We create a vector space over 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 and a finite
field.
sage: K = ZZ^5
sage: M = GF(7)^5
Arithmetic between the and
modules is defined, and the result is always
over
, since there is a canonical coercion map
to
.
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
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 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)
Bases: sage.structure.element.Vector
An element of a generic free module.
EXAMPLES:
sage: V = vector(ZZ, [5, 9, 13, 15])
sage: V.Mod(7)
(5, 2, 6, 1)
sage: parent(V.Mod(7))
Vector space of dimension 4 over Ring of integers modulo 7
Return the additive order of self.
EXAMPLES:
sage: v = vector(Integers(4), [1,2])
sage: v.additive_order()
4
sage: v = vector([1,2,3])
sage: v.additive_order()
+Infinity
sage: v = vector(Integers(30), [6, 15]); v
(6, 15)
sage: v.additive_order()
10
sage: 10*v
(0, 0)
Apply the given map phi (an arbitrary Python function or callable object) to this free module element. If R is not given, automatically determine the base ring of the resulting element.
OUTPUT: a free module element over R
EXAMPLES:
sage: m = vector([1,x,sin(x+1)])
sage: m.apply_map(lambda x: x^2)
(1, x^2, sin(x + 1)^2)
sage: m.apply_map(sin)
(sin(1), sin(x), sin(sin(x + 1)))
sage: m = vector(ZZ, 9, range(9))
sage: k.<a> = GF(9)
sage: m.apply_map(k)
(0, 1, 2, 0, 1, 2, 0, 1, 2)
In this example, we explicitly specify the codomain.
sage: s = GF(3)
sage: f = lambda x: s(x)
sage: n = m.apply_map(f, k); n
(0, 1, 2, 0, 1, 2, 0, 1, 2)
sage: n.parent()
Vector space of dimension 9 over Finite Field in a of size 3^2
If your map sends 0 to a non-zero value, then your resulting vector is not mathematically sparse:
sage: v = vector([0] * 6 + [1], sparse=True); v
(0, 0, 0, 0, 0, 0, 1)
sage: v2 = v.apply_map(lambda x: x+1); v2
(1, 1, 1, 1, 1, 1, 2)
but it’s still represented with a sparse data type:
sage: parent(v2)
Ambient sparse free module of rank 7 over the principal ideal domain Integer Ring
This data type is inefficient for dense vectors, so you may want to specify sparse=False:
sage: v2 = v.apply_map(lambda x: x+1, sparse=False); v2
(1, 1, 1, 1, 1, 1, 2)
sage: parent(v2)
Ambient free module of rank 7 over the principal ideal domain Integer Ring
Or if you have a map that will result in mostly zeroes, you may want to specify sparse=True:
sage: v = vector(srange(10))
sage: v2 = v.apply_map(lambda x: 0 if x else 1, sparse=True); v2
(1, 0, 0, 0, 0, 0, 0, 0, 0, 0)
sage: parent(v2)
Ambient sparse free module of rank 10 over the principal ideal domain Integer Ring
TESTS:
sage: m = vector(SR,[])
sage: m.apply_map(lambda x: x*x) == m
True
Check that we don’t unnecessarily apply phi to 0 in the sparse case:
sage: m = vector(ZZ, range(1, 4), sparse=True)
sage: m.apply_map(lambda x: 1/x)
(1, 1/2, 1/3)
sage: parent(vector(RDF, (), sparse=True).apply_map(lambda x: x, sparse=True))
Sparse vector space of dimension 0 over Real Double Field
sage: parent(vector(RDF, (), sparse=True).apply_map(lambda x: x, sparse=False))
Vector space of dimension 0 over Real Double Field
sage: parent(vector(RDF, (), sparse=False).apply_map(lambda x: x, sparse=True))
Sparse vector space of dimension 0 over Real Double Field
sage: parent(vector(RDF, (), sparse=False).apply_map(lambda x: x, sparse=False))
Vector space of dimension 0 over Real Double Field
Check that the bug in trac ticket #14558 has been fixed:
sage: F.<a> = GF(9)
sage: v = vector([a, 0,0,0], sparse=True)
sage: f = F.hom([a**3])
sage: v.apply_map(f)
(2*a + 1, 0, 0, 0)
Change the base ring of this vector, by coercing each element of this vector into R.
EXAMPLES:
sage: v = vector(QQ['x,y'], [1..5]); v.change_ring(GF(3))
(1, 2, 0, 1, 2)
Return a matrix with a single column and the same entries as the vector self.
OUTPUT:
A matrix over the same ring as the vector (or free module element), with a single column. The entries of the column are identical to those of the vector, and in the same order.
EXAMPLES:
sage: v = vector(ZZ, [1,2,3])
sage: w = v.column(); w
[1]
[2]
[3]
sage: w.parent()
Full MatrixSpace of 3 by 1 dense matrices over Integer Ring
sage: x = vector(FiniteField(13), [2,4,8,16])
sage: x.column()
[2]
[4]
[8]
[3]
There is more than one way to get one-column matrix from a vector. The column method is about equally efficient to making a row and then taking a transpose. Notice that supplying a vector to the matrix constructor demonstrates Sage’s preference for rows.
sage: x = vector(RDF, [sin(i*pi/20) for i in range(10)])
sage: x.column() == matrix(x).transpose()
True
sage: x.column() == x.row().transpose()
True
Sparse or dense implementations are preserved.
sage: d = vector(RR, [1.0, 2.0, 3.0])
sage: s = vector(CDF, {2:5.0+6.0*I})
sage: dm = d.column()
sage: sm = s.column()
sage: all([d.is_dense(), dm.is_dense(), s.is_sparse(), sm.is_sparse()])
True
TESTS:
The column() method will return a specified column of a matrix as a vector. So here are a couple of round-trips.
sage: A = matrix(ZZ, [[1],[2],[3]])
sage: A == A.column(0).column()
True
sage: v = vector(ZZ, [4,5,6])
sage: v == v.column().column(0)
True
And a very small corner case.
sage: v = vector(ZZ, [])
sage: w = v.column()
sage: w.parent()
Full MatrixSpace of 0 by 1 dense matrices over Integer Ring
Returns a vector where every entry has been replaced by its complex conjugate.
OUTPUT:
A vector of the same length, over the same ring, but with each entry replaced by the complex conjugate, as implemented by the conjugate() method for elements of the base ring, which is presently always complex conjugation.
EXAMPLES:
sage: v = vector(CDF, [2.3 - 5.4*I, -1.7 + 3.6*I])
sage: w = v.conjugate(); w
(2.3 + 5.4*I, -1.7 - 3.6*I)
sage: w.parent()
Vector space of dimension 2 over Complex Double Field
Even if conjugation seems nonsensical over a certain ring, this method for vectors cooperates silently.
sage: u = vector(ZZ, range(6))
sage: u.conjugate()
(0, 1, 2, 3, 4, 5)
Sage implements a few specialized subfields of the complex numbers, such as the cyclotomic fields. This example uses such a field containing a primitive 7-th root of unity named a.
sage: F.<a> = CyclotomicField(7)
sage: v = vector(F, [a^i for i in range(7)])
sage: v
(1, a, a^2, a^3, a^4, a^5, -a^5 - a^4 - a^3 - a^2 - a - 1)
sage: v.conjugate()
(1, -a^5 - a^4 - a^3 - a^2 - a - 1, a^5, a^4, a^3, a^2, a)
Sparse vectors are returned as such.
sage: v = vector(CC, {1: 5 - 6*I, 3: -7*I}); v
(0.000000000000000, 5.00000000000000 - 6.00000000000000*I, 0.000000000000000, -7.00000000000000*I)
sage: v.is_sparse()
True
sage: vc = v.conjugate(); vc
(0.000000000000000, 5.00000000000000 + 6.00000000000000*I, 0.000000000000000, 7.00000000000000*I)
sage: vc.conjugate()
(0.000000000000000, 5.00000000000000 - 6.00000000000000*I, 0.000000000000000, -7.00000000000000*I)
TESTS:
sage: n = 15
sage: x = vector(CDF, [sin(i*pi/n)+cos(i*pi/n)*I for i in range(n)])
sage: x + x.conjugate() in RDF^n
True
sage: I*(x - x.conjugate()) in RDF^n
True
The parent of the conjugate is the same as that of the original vector. We test this by building a specialized vector space with a non-standard inner product, and constructing a test vector in this space.
sage: V = VectorSpace(CDF, 2, inner_product_matrix = [[2,1],[1,5]])
sage: v = vector(CDF, [2-3*I, 4+5*I])
sage: w = V(v)
sage: w.parent()
Ambient quadratic space of dimension 2 over Complex Double Field
Inner product matrix:
[2.0 1.0]
[1.0 5.0]
sage: w.conjugate().parent()
Ambient quadratic space of dimension 2 over Complex Double Field
Inner product matrix:
[2.0 1.0]
[1.0 5.0]
Return the cross product of self and right, which is only defined for vectors of length 3 or 7.
INPUT:
OUTPUT:
The cross product (vector product) of self and right, a vector of the same size of self and right.
This product is performed under the assumption that the basis vectors are orthonormal.
EXAMPLES:
sage: v = vector([1,2,3]); w = vector([0,5,-9])
sage: v.cross_product(v)
(0, 0, 0)
sage: u = v.cross_product(w); u
(-33, 9, 5)
sage: u.dot_product(v)
0
sage: u.dot_product(w)
0
The cross product is defined for degree seven vectors as well. [WIKIPEDIA:CROSSPRODUCT] The 3-D cross product is achieved using the quaternians, whereas the 7-D cross product is achieved using the octions.
sage: u = vector(QQ, [1, -1/3, 57, -9, 56/4, -4,1])
sage: v = vector(QQ, [37, 55, -99/57, 9, -12, 11/3, 4/98])
sage: u.cross_product(v)
(1394815/2793, -2808401/2793, 39492/49, -48737/399, -9151880/2793, 62513/2793, -326603/171)
The degree seven cross product is anticommutative.
sage: u.cross_product(v) + v.cross_product(u)
(0, 0, 0, 0, 0, 0, 0)
The degree seven cross product is distributive across addition.
sage: v = vector([-12, -8/9, 42, 89, -37, 60/99, 73])
sage: u = vector([31, -42/7, 97, 80, 30/55, -32, 64])
sage: w = vector([-25/4, 40, -89, -91, -72/7, 79, 58])
sage: v.cross_product(u + w) - (v.cross_product(u) + v.cross_product(w))
(0, 0, 0, 0, 0, 0, 0)
The degree seven cross product respects scalar multiplication.
sage: v = vector([2, 17, -11/5, 21, -6, 2/17, 16])
sage: u = vector([-8, 9, -21, -6, -5/3, 12, 99])
sage: (5*v).cross_product(u) - 5*(v.cross_product(u))
(0, 0, 0, 0, 0, 0, 0)
sage: v.cross_product(5*u) - 5*(v.cross_product(u))
(0, 0, 0, 0, 0, 0, 0)
sage: (5*v).cross_product(u) - (v.cross_product(5*u))
(0, 0, 0, 0, 0, 0, 0)
The degree seven cross product respects the scalar triple product.
sage: v = vector([2,6,-7/4,-9/12,-7,12,9])
sage: u = vector([22,-7,-9/11,12,15,15/7,11])
sage: w = vector([-11,17,19,-12/5,44,21/56,-8])
sage: v.dot_product(u.cross_product(w)) - w.dot_product(v.cross_product(u))
0
TESTS:
Both vectors need to be of length three or both vectors need to be of length seven.
sage: u = vector(range(7))
sage: v = vector(range(3))
sage: u.cross_product(v)
Traceback (most recent call last):
...
ArithmeticError: Cross product only defined for vectors of length three or seven, not (7 and 3)
REFERENCES:
[WIKIPEDIA:CROSSPRODUCT] | Algebraic Properties of the Cross Product http://en.wikipedia.org/wiki/Cross_product |
AUTHOR:
Billy Wonderly (2010-05-11), Added 7-D Cross Product
Return the degree of this vector, which is simply the number of entries.
EXAMPLES:
sage: sage.modules.free_module_element.FreeModuleElement(QQ^389).degree()
389
sage: vector([1,2/3,8]).degree()
3
Return the least common multiple of the denominators of the entries of self.
EXAMPLES:
sage: v = vector([1/2,2/5,3/14])
sage: v.denominator()
70
sage: 2*5*7
70
TESTS:
The following was fixed in trac ticket #8800:
sage: M = GF(5)^3
sage: v = M((4,0,2))
sage: v.denominator()
1
Return dense version of self. If self is dense, just return self; otherwise, create and return correspond dense vector.
EXAMPLES:
sage: vector([-1,0,3,0,0,0]).dense_vector().is_dense()
True
sage: vector([-1,0,3,0,0,0],sparse=True).dense_vector().is_dense()
True
sage: vector([-1,0,3,0,0,0],sparse=True).dense_vector()
(-1, 0, 3, 0, 0, 0)
Derivative with respect to variables supplied in args.
Multiple variables and iteration counts may be supplied; see documentation for the global derivative() function for more details.
diff() is an alias of this function.
EXAMPLES:
sage: v = vector([1,x,x^2])
sage: v.derivative(x)
(0, 1, 2*x)
sage: type(v.derivative(x)) == type(v)
True
sage: v = vector([1,x,x^2], sparse=True)
sage: v.derivative(x)
(0, 1, 2*x)
sage: type(v.derivative(x)) == type(v)
True
sage: v.derivative(x,x)
(0, 0, 2)
Return dictionary of nonzero entries of self.
INPUT:
- copy – bool (default: True)
OUTPUT:
- Python dictionary
EXAMPLES:
sage: v = vector([0,0,0,0,1/2,0,3/14])
sage: v.dict()
{4: 1/2, 6: 3/14}
In some cases when copy=False, we get back a dangerous reference:
sage: v = vector({0:5, 2:3/7}, sparse=True)
sage: v.dict(copy=False)
{0: 5, 2: 3/7}
sage: v.dict(copy=False)[0] = 18
sage: v
(18, 0, 3/7)
Derivative with respect to variables supplied in args.
Multiple variables and iteration counts may be supplied; see documentation for the global derivative() function for more details.
diff() is an alias of this function.
EXAMPLES:
sage: v = vector([1,x,x^2])
sage: v.derivative(x)
(0, 1, 2*x)
sage: type(v.derivative(x)) == type(v)
True
sage: v = vector([1,x,x^2], sparse=True)
sage: v.derivative(x)
(0, 1, 2*x)
sage: type(v.derivative(x)) == type(v)
True
sage: v.derivative(x,x)
(0, 0, 2)
Return the dot product of self and right, which is the sum of the product of the corresponding entries.
INPUT:
OUTPUT:
If self and right are the vectors and
,
of degree
, then this method returns
Note
The inner_product() is a more general version of this method, and the hermitian_inner_product() method may be more appropriate if your vectors have complex entries.
EXAMPLES:
sage: V = FreeModule(ZZ, 3)
sage: v = V([1,2,3])
sage: w = V([4,5,6])
sage: v.dot_product(w)
32
sage: R.<x> = QQ[]
sage: v = vector([x,x^2,3*x]); w = vector([2*x,x,3+x])
sage: v*w
x^3 + 5*x^2 + 9*x
sage: (x*2*x) + (x^2*x) + (3*x*(3+x))
x^3 + 5*x^2 + 9*x
sage: w*v
x^3 + 5*x^2 + 9*x
The vectors may be from different vector spaces, provided the necessary operations make sense. Notice that coercion will generate a result of the same type, even if the order of the arguments is reversed.:
sage: v = vector(ZZ, [1,2,3])
sage: w = vector(FiniteField(3), [0,1,2])
sage: ip = w.dot_product(v); ip
2
sage: ip.parent()
Finite Field of size 3
sage: ip = v.dot_product(w); ip
2
sage: ip.parent()
Finite Field of size 3
The dot product of a vector with itself is the 2-norm, squared.
sage: v = vector(QQ, [3, 4, 7])
sage: v.dot_product(v) - v.norm()^2
0
TESTS:
The second argument must be a free module element.
sage: v = vector(QQ, [1,2])
sage: v.dot_product('junk')
Traceback (most recent call last):
...
TypeError: Cannot convert str to sage.modules.free_module_element.FreeModuleElement
The degrees of the arguments must match.
sage: v = vector(QQ, [1,2])
sage: w = vector(QQ, [1,2,3])
sage: v.dot_product(w)
Traceback (most recent call last):
...
ArithmeticError: degrees (2 and 3) must be the same
Check that vectors with different base rings play out nicely (trac ticket #3103):
sage: vector(CDF, [2, 2]) * vector(ZZ, [1, 3])
8.0
Simply returns self. This is useful, since for many objects, self.element() returns a vector corresponding to self.
EXAMPLES:
sage: v = vector([1/2,2/5,0]); v
(1/2, 2/5, 0)
sage: v.element()
(1/2, 2/5, 0)
The get method is in some cases more efficient (and more dangerous) than __getitem__, because it is not guaranteed to do any error checking.
EXAMPLES:
sage: vector([1/2,2/5,0]).get(0)
1/2
sage: vector([1/2,2/5,0]).get(3)
Traceback (most recent call last):
...
IndexError: index out of range
Return the number of positions i such that self[i] != 0.
EXAMPLES:
sage: vector([-1,0,3,0,0,0,0.01]).hamming_weight()
3
Returns the dot product, but with the entries of the first vector conjugated beforehand.
INPUT:
OUTPUT:
If self and right are the vectors and
of degree
then this routine computes
where the bar indicates complex conjugation.
Note
If your vectors do not contain complex entries, then dot_product() will return the same result without the overhead of conjugating elements of self.
If you are not computing a weighted inner product, and your vectors do not have complex entries, then the dot_product() will return the same result.
EXAMPLES:
sage: v = vector(CDF, [2+3*I, 5-4*I])
sage: w = vector(CDF, [6-4*I, 2+3*I])
sage: v.hermitian_inner_product(w)
-2.0 - 3.0*I
Sage implements a few specialized fields over the complex numbers, such as cyclotomic fields and quadratic number fields. So long as the base rings have a conjugate method, then the Hermitian inner product will be available.
sage: Q.<a> = QuadraticField(-7)
sage: a^2
-7
sage: v = vector(Q, [3+a, 5-2*a])
sage: w = vector(Q, [6, 4+3*a])
sage: v.hermitian_inner_product(w)
17*a - 4
The Hermitian inner product should be additive in each argument (we only need to test one), linear in each argument (with conjugation on the first scalar), and anti-commutative.
sage: alpha = CDF(5.0 + 3.0*I)
sage: u = vector(CDF, [2+4*I, -3+5*I, 2-7*I])
sage: v = vector(CDF, [-1+3*I, 5+4*I, 9-2*I])
sage: w = vector(CDF, [8+3*I, -4+7*I, 3-6*I])
sage: (u+v).hermitian_inner_product(w) == u.hermitian_inner_product(w) + v.hermitian_inner_product(w)
True
sage: (alpha*u).hermitian_inner_product(w) == alpha.conjugate()*u.hermitian_inner_product(w)
True
sage: u.hermitian_inner_product(alpha*w) == alpha*u.hermitian_inner_product(w)
True
sage: u.hermitian_inner_product(v) == v.hermitian_inner_product(u).conjugate()
True
For vectors with complex entries, the Hermitian inner product has a more natural relationship with the 2-norm (which is the default for the norm() method). The norm squared equals the Hermitian inner product of the vector with itself.
sage: v = vector(CDF, [-0.66+0.47*I, -0.60+0.91*I, -0.62-0.87*I, 0.53+0.32*I])
sage: abs(v.norm()^2 - v.hermitian_inner_product(v)) < 1.0e-10
True
TESTS:
This method is built on the dot_product() method, which allows for a wide variety of inputs. Any error handling happens there.
sage: v = vector(CDF, [2+3*I])
sage: w = vector(CDF, [5+2*I, 3+9*I])
sage: v.hermitian_inner_product(w)
Traceback (most recent call last):
...
ArithmeticError: degrees (1 and 2) must be the same
Returns the inner product of self and right, possibly using an inner product matrix from the parent of self.
INPUT:
OUTPUT:
If the parent vector space does not have an inner product
matrix defined, then this is the usual dot product
(dot_product()). If self and right are
considered as single column matrices, and
,
and
is the inner product matrix, then this method computes
where indicates the transpose.
Note
If your vectors have complex entries, the hermitian_inner_product() may be more appropriate for your purposes.
EXAMPLES:
sage: v = vector(QQ, [1,2,3])
sage: w = vector(QQ, [-1,2,-3])
sage: v.inner_product(w)
-6
sage: v.inner_product(w) == v.dot_product(w)
True
The vector space or free module that is the parent to self can have an inner product matrix defined, which will be used by this method. This matrix will be passed through to subspaces.
sage: ipm = matrix(ZZ,[[2,0,-1], [0,2,0], [-1,0,6]])
sage: M = FreeModule(ZZ, 3, inner_product_matrix = ipm)
sage: v = M([1,0,0])
sage: v.inner_product(v)
2
sage: K = M.span_of_basis([[0/2,-1/2,-1/2], [0,1/2,-1/2],[2,0,0]])
sage: (K.0).inner_product(K.0)
2
sage: w = M([1,3,-1])
sage: v = M([2,-4,5])
sage: w.row()*ipm*v.column() == w.inner_product(v)
True
Note that the inner product matrix comes from the parent of self. So if a vector is not an element of the correct parent, the result could be a source of confusion.
sage: V = VectorSpace(QQ, 2, inner_product_matrix=[[1,2],[2,1]])
sage: v = V([12, -10])
sage: w = vector(QQ, [10,12])
sage: v.inner_product(w)
88
sage: w.inner_product(v)
0
sage: w = V(w)
sage: w.inner_product(v)
88
Note
The use of an inner product matrix makes no restrictions on the nature of the matrix. In particular, in this context it need not be Hermitian and positive-definite (as it is in the example above).
TESTS:
Most error handling occurs in the dot_product() method. But with an inner product defined, this method will check that the input is a vector or free module element.
sage: W = VectorSpace(RDF, 2, inner_product_matrix = matrix(RDF, 2, [1.0,2.0,3.0,4.0]))
sage: v = W([2.0, 4.0])
sage: v.inner_product(5)
Traceback (most recent call last):
...
TypeError: right must be a free module element
Returns a symbolic integral of the vector, component-wise.
integrate() is an alias of the function.
EXAMPLES:
sage: t=var('t')
sage: r=vector([t,t^2,sin(t)])
sage: r.integral(t)
(1/2*t^2, 1/3*t^3, -cos(t))
sage: integrate(r,t)
(1/2*t^2, 1/3*t^3, -cos(t))
sage: r.integrate(t,0,1)
(1/2, 1/3, -cos(1) + 1)
Returns a symbolic integral of the vector, component-wise.
integrate() is an alias of the function.
EXAMPLES:
sage: t=var('t')
sage: r=vector([t,t^2,sin(t)])
sage: r.integral(t)
(1/2*t^2, 1/3*t^3, -cos(t))
sage: integrate(r,t)
(1/2*t^2, 1/3*t^3, -cos(t))
sage: r.integrate(t,0,1)
(1/2, 1/3, -cos(1) + 1)
Return True if this is a dense vector, which is just a statement about the data structure, not the number of nonzero entries.
EXAMPLES:
sage: vector([1/2,2/5,0]).is_dense()
True
sage: vector([1/2,2/5,0],sparse=True).is_dense()
False
Return True if this vector is immutable, i.e., the entries cannot be changed.
EXAMPLES:
sage: v = vector(QQ['x,y'], [1..5]); v.is_immutable()
False
sage: v.set_immutable()
sage: v.is_immutable()
True
Return True if this vector is mutable, i.e., the entries can be changed.
EXAMPLES:
sage: v = vector(QQ['x,y'], [1..5]); v.is_mutable()
True
sage: v.set_immutable()
sage: v.is_mutable()
False
Return True if this is a sparse vector, which is just a statement about the data structure, not the number of nonzero entries.
EXAMPLES:
sage: vector([1/2,2/5,0]).is_sparse()
False
sage: vector([1/2,2/5,0],sparse=True).is_sparse()
True
Return True, since this is a vector.
EXAMPLES:
sage: vector([1/2,2/5,0]).is_vector()
True
Return iterator over self.
EXAMPLES:
sage: v = vector([1,2/3,pi])
sage: v.iteritems()
<dictionary-itemiterator object at ...>
sage: list(v.iteritems())
[(0, 1), (1, 2/3), (2, pi)]
EXAMPLES:
sage: V = vector(Integers(7), [5, 9, 13, 15]) ; V
(5, 2, 6, 1)
sage: V.lift()
(5, 2, 6, 1)
sage: parent(V.lift())
Ambient free module of rank 4 over the principal ideal domain Integer Ring
Return list of elements of self.
INPUT:
- copy – bool, whether returned list is a copy that is safe to change, is ignored.
EXAMPLES:
sage: P.<x,y,z> = QQ[]
sage: v = vector([x,y,z], sparse=True)
sage: type(v)
<type 'sage.modules.free_module_element.FreeModuleElement_generic_sparse'>
sage: a = v.list(); a
[x, y, z]
sage: a[0] = x*y; v
(x, y, z)
The optional argument copy is ignored:
sage: a = v.list(copy=False); a
[x, y, z]
sage: a[0] = x*y; v
(x, y, z)
Return list of elements chosen from this vector using the given positions of this vector.
INPUT:
- positions – iterable of ints
EXAMPLES:
sage: v = vector([1,2/3,pi])
sage: v.list_from_positions([0,0,0,2,1])
[1, 1, 1, pi, 2/3]
Return this vector divided through by the first nonzero entry of this vector.
EXAMPLES:
sage: v = vector(QQ, [0, 4/3, 5, 1, 2])
sage: v.monic()
(0, 1, 15/4, 3/4, 3/2)
sage: v = vector(QQ, [])
sage: v.monic()
()
Returns a numeric integral of the vector, component-wise, and the result of the nintegral command on each component of the input.
nintegrate() is an alias of the function.
EXAMPLES:
sage: t=var('t')
sage: r=vector([t,t^2,sin(t)])
sage: vec,answers=r.nintegral(t,0,1)
sage: vec
(0.5, 0.3333333333333334, 0.4596976941318602)
sage: type(vec)
<type 'sage.modules.vector_real_double_dense.Vector_real_double_dense'>
sage: answers
[(0.5, 5.551115123125784e-15, 21, 0), (0.3333333333333..., 3.70074341541719e-15, 21, 0), (0.45969769413186..., 5.103669643922841e-15, 21, 0)]
sage: r=vector([t,0,1], sparse=True)
sage: r.nintegral(t,0,1)
((0.5, 0.0, 1.0), {0: (0.5, 5.551115123125784e-15, 21, 0), 2: (1.0, 1.11022302462515...e-14, 21, 0)})
Returns a numeric integral of the vector, component-wise, and the result of the nintegral command on each component of the input.
nintegrate() is an alias of the function.
EXAMPLES:
sage: t=var('t')
sage: r=vector([t,t^2,sin(t)])
sage: vec,answers=r.nintegral(t,0,1)
sage: vec
(0.5, 0.3333333333333334, 0.4596976941318602)
sage: type(vec)
<type 'sage.modules.vector_real_double_dense.Vector_real_double_dense'>
sage: answers
[(0.5, 5.551115123125784e-15, 21, 0), (0.3333333333333..., 3.70074341541719e-15, 21, 0), (0.45969769413186..., 5.103669643922841e-15, 21, 0)]
sage: r=vector([t,0,1], sparse=True)
sage: r.nintegral(t,0,1)
((0.5, 0.0, 1.0), {0: (0.5, 5.551115123125784e-15, 21, 0), 2: (1.0, 1.11022302462515...e-14, 21, 0)})
Return the sorted list of integers i such that self[i] != 0.
EXAMPLES:
sage: vector([-1,0,3,0,0,0,0.01]).nonzero_positions()
[0, 2, 6]
Return the -norm of self.
INPUT:
p - default: 2 - p can be a real number greater than 1, infinity (oo or Infinity), or a symbolic expression.
: the taxicab (Manhattan) norm
: the usual Euclidean norm (the default)
: the maximum entry (in absolute value)
Note
See also sage.misc.functional.norm()
EXAMPLES:
sage: v = vector([1,2,-3])
sage: v.norm(5)
276^(1/5)
The default is the usual Euclidean norm.
sage: v.norm()
sqrt(14)
sage: v.norm(2)
sqrt(14)
The infinity norm is the maximum size (in absolute value) of the entries.
sage: v.norm(Infinity)
3
sage: v.norm(oo)
3
Real or symbolic values may be used for p.
sage: v=vector(RDF,[1,2,3])
sage: v.norm(5)
3.077384885394063
sage: v.norm(pi/2)
4.216595864704748
sage: _=var('a b c d p'); v=vector([a, b, c, d])
sage: v.norm(p)
(abs(a)^p + abs(b)^p + abs(c)^p + abs(d)^p)^(1/p)
Notice that the result may be a symbolic expression, owing to the necessity of taking a square root (in the default case). These results can be converted to numerical values if needed.
sage: v = vector(ZZ, [3,4])
sage: nrm = v.norm(); nrm
5
sage: nrm.parent()
Rational Field
sage: v = vector(QQ, [3, 5])
sage: nrm = v.norm(); nrm
sqrt(34)
sage: nrm.parent()
Symbolic Ring
sage: numeric = N(nrm); numeric
5.83095189484...
sage: numeric.parent()
Real Field with 53 bits of precision
TESTS:
The value of p must be greater than, or equal to, one.
sage: v = vector(QQ, [1,2])
sage: v.norm(0.99)
Traceback (most recent call last):
...
ValueError: 0.990000000000000 is not greater than or equal to 1
Norm works with Python integers (see trac ticket #13502).
sage: v = vector(QQ, [1,2])
sage: v.norm(int(2))
sqrt(5)
Return the input vector divided by the p-norm.
INPUT:
EXAMPLES:
sage: v = vector(QQ, [4, 1, 3, 2])
sage: v.normalized()
(2/15*sqrt(30), 1/30*sqrt(30), 1/10*sqrt(30), 1/15*sqrt(30))
sage: sum(v.normalized(1))
1
Note that normalizing the vector may change the base ring:
sage: v.base_ring() == v.normalized().base_ring()
False
sage: u = vector(RDF, [-3, 4, 6, 9])
sage: u.base_ring() == u.normalized().base_ring()
True
Returns a matrix, the outer product of two vectors self and right.
INPUT:
OUTPUT:
The outer product of two vectors and
(respectively
self and right) can be described several ways. If we
interpret
as a
matrix and interpret
as a
matrix, then the outer product is the
matrix from the usual matrix product
. Notice how this
is the “opposite” in some ways from an inner product (which
would require
).
If we just consider vectors, use each entry of to create
a scalar multiples of the vector
and use these vectors as
the rows of a matrix. Or use each entry of
to create a
scalar multiples of
and use these vectors as the columns
of a matrix.
EXAMPLES:
sage: u = vector(QQ, [1/2, 1/3, 1/4, 1/5])
sage: v = vector(ZZ, [60, 180, 600])
sage: u.outer_product(v)
[ 30 90 300]
[ 20 60 200]
[ 15 45 150]
[ 12 36 120]
sage: M = v.outer_product(u); M
[ 30 20 15 12]
[ 90 60 45 36]
[300 200 150 120]
sage: M.parent()
Full MatrixSpace of 3 by 4 dense matrices over Rational Field
The more general sage.matrix.matrix2.tensor_product() is an
operation on a pair of matrices. If we construe a pair of vectors
as a column vector and a row vector, then an outer product and a
tensor product are identical. Thus is a synonym
for this method.
sage: u = vector(QQ, [1/2, 1/3, 1/4, 1/5])
sage: v = vector(ZZ, [60, 180, 600])
sage: u.tensor_product(v) == (u.column()).tensor_product(v.row())
True
The result is always a dense matrix, no matter if the two vectors are, or are not, dense.
sage: d = vector(ZZ,[4,5], sparse=False)
sage: s = vector(ZZ, [1,2,3], sparse=True)
sage: dd = d.outer_product(d)
sage: ds = d.outer_product(s)
sage: sd = s.outer_product(d)
sage: ss = s.outer_product(s)
sage: all([dd.is_dense(), ds.is_dense(), sd.is_dense(), dd.is_dense()])
True
Vectors with no entries do the right thing.
sage: v = vector(ZZ, [])
sage: z = v.outer_product(v)
sage: z.parent()
Full MatrixSpace of 0 by 0 dense matrices over Integer Ring
There is a fair amount of latitude in the value of the right vector, and the matrix that results can have entries from a new ring large enough to contain the result. If you know better, you can sometimes bring the result down to a less general ring.
sage: R.<t> = ZZ[]
sage: v = vector(R, [12, 24*t])
sage: w = vector(QQ, [1/2, 1/3, 1/4])
sage: op = v.outer_product(w)
sage: op
[ 6 4 3]
[12*t 8*t 6*t]
sage: op.base_ring()
Univariate Polynomial Ring in t over Rational Field
sage: m = op.change_ring(R); m
[ 6 4 3]
[12*t 8*t 6*t]
sage: m.base_ring()
Univariate Polynomial Ring in t over Integer Ring
But some inputs are not compatible, even if vectors.
sage: w = vector(GF(5), [1,2])
sage: v = vector(GF(7), [1,2,3,4])
sage: z = w.outer_product(v)
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for '*': 'Full MatrixSpace of 2 by 1 dense matrices over Finite Field of size 5' and 'Full MatrixSpace of 1 by 4 dense matrices over Finite Field of size 7'
And some inputs don’t make any sense at all.
sage: w=vector(QQ, [5,10])
sage: z=w.outer_product(6)
Traceback (most recent call last):
...
TypeError: right operand in an outer product must be a vector, not an element of Integer Ring
Return the pairwise product of self and right, which is a vector of the products of the corresponding entries.
INPUT:
EXAMPLES:
sage: V = FreeModule(ZZ, 3)
sage: v = V([1,2,3])
sage: w = V([4,5,6])
sage: v.pairwise_product(w)
(4, 10, 18)
sage: sum(v.pairwise_product(w)) == v.dot_product(w)
True
sage: W = VectorSpace(GF(3),3)
sage: w = W([0,1,2])
sage: w.pairwise_product(v)
(0, 2, 0)
sage: w.pairwise_product(v).parent()
Vector space of dimension 3 over Finite Field of size 3
Implicit coercion is well defined (regardless of order), so we get 2 even if we do the dot product in the other order.
sage: v.pairwise_product(w).parent()
Vector space of dimension 3 over Finite Field of size 3
TESTS:
sage: x, y = var('x, y')
sage: parent(vector(ZZ,[1,2]).pairwise_product(vector(ZZ,[1,2])))
Ambient free module of rank 2 over the principal ideal domain Integer Ring
sage: parent(vector(ZZ,[1,2]).pairwise_product(vector(QQ,[1,2])))
Vector space of dimension 2 over Rational Field
sage: parent(vector(QQ,[1,2]).pairwise_product(vector(ZZ,[1,2])))
Vector space of dimension 2 over Rational Field
sage: parent(vector(QQ,[1,2]).pairwise_product(vector(QQ,[1,2])))
Vector space of dimension 2 over Rational Field
sage: parent(vector(QQ,[1,2,3,4]).pairwise_product(vector(ZZ['x'],[1,2,3,4])))
Ambient free module of rank 4 over the principal ideal domain Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(ZZ[x],[1,2,3,4]).pairwise_product(vector(QQ,[1,2,3,4])))
Ambient free module of rank 4 over the principal ideal domain Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(QQ,[1,2,3,4]).pairwise_product(vector(ZZ['x']['y'],[1,2,3,4])))
Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(ZZ[x][y],[1,2,3,4]).pairwise_product(vector(QQ,[1,2,3,4])))
Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(QQ['x'],[1,2,3,4]).pairwise_product(vector(ZZ['x']['y'],[1,2,3,4])))
Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(ZZ[x][y],[1,2,3,4]).pairwise_product(vector(QQ['x'],[1,2,3,4])))
Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(QQ['y'],[1,2,3,4]).pairwise_product(vector(ZZ['x']['y'],[1,2,3,4])))
Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(ZZ[x][y],[1,2,3,4]).pairwise_product(vector(QQ['y'],[1,2,3,4])))
Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Univariate Polynomial Ring in x over Rational Field
sage: parent(vector(ZZ['x'],[1,2,3,4]).pairwise_product(vector(ZZ['y'],[1,2,3,4])))
Traceback (most recent call last):
...
TypeError: no common canonical parent for objects with parents: 'Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in x over Integer Ring' and 'Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Integer Ring'
sage: parent(vector(ZZ['x'],[1,2,3,4]).pairwise_product(vector(QQ['y'],[1,2,3,4])))
Traceback (most recent call last):
...
TypeError: no common canonical parent for objects with parents: 'Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in x over Integer Ring' and 'Ambient free module of rank 4 over the principal ideal domain Univariate Polynomial Ring in y over Rational Field'
sage: parent(vector(QQ['x'],[1,2,3,4]).pairwise_product(vector(ZZ['y'],[1,2,3,4])))
Traceback (most recent call last):
...
TypeError: no common canonical parent for objects with parents: 'Ambient free module of rank 4 over the principal ideal domain Univariate Polynomial Ring in x over Rational Field' and 'Ambient free module of rank 4 over the integral domain Univariate Polynomial Ring in y over Integer Ring'
sage: parent(vector(QQ['x'],[1,2,3,4]).pairwise_product(vector(QQ['y'],[1,2,3,4])))
Traceback (most recent call last):
...
TypeError: no common canonical parent for objects with parents: 'Ambient free module of rank 4 over the principal ideal domain Univariate Polynomial Ring in x over Rational Field' and 'Ambient free module of rank 4 over the principal ideal domain Univariate Polynomial Ring in y over Rational Field'
sage: v = vector({1: 1, 3: 2}) # test sparse vectors
sage: w = vector({0: 6, 3: -4})
sage: v.pairwise_product(w)
(0, 0, 0, -8)
sage: w.pairwise_product(v) == v.pairwise_product(w)
True
INPUT:
otherwise ‘step’) type of plot. Options are:
Both ‘arrow’ and ‘point’ raise exceptions if the vector has more than 3 dimensions.
start - (default: origin in correct dimension) may be a tuple, list, or vector.
EXAMPLES:
The following both plot the given vector:
sage: v = vector(RDF, (1,2))
sage: A = plot(v)
sage: B = v.plot()
sage: A+B # should just show one vector
Graphics object consisting of 2 graphics primitives
Examples of the plot types:
sage: A = plot(v, plot_type='arrow')
sage: B = plot(v, plot_type='point', color='green', size=20)
sage: C = plot(v, plot_type='step') # calls v.plot_step()
sage: A+B+C
Graphics object consisting of 3 graphics primitives
You can use the optional arguments for plot_step():
sage: eps = 0.1
sage: plot(v, plot_type='step', eps=eps, xmax=5, hue=0)
Graphics object consisting of 1 graphics primitive
Three-dimensional examples:
sage: v = vector(RDF, (1,2,1))
sage: plot(v) # defaults to an arrow plot
Graphics3d Object
sage: plot(v, plot_type='arrow')
Graphics3d Object
sage: from sage.plot.plot3d.shapes2 import frame3d
sage: plot(v, plot_type='point')+frame3d((0,0,0), v.list())
Graphics3d Object
sage: plot(v, plot_type='step') # calls v.plot_step()
Graphics object consisting of 1 graphics primitive
sage: plot(v, plot_type='step', eps=eps, xmax=5, hue=0)
Graphics object consisting of 1 graphics primitive
With greater than three coordinates, it defaults to a step plot:
sage: v = vector(RDF, (1,2,3,4))
sage: plot(v)
Graphics object consisting of 1 graphics primitive
One dimensional vectors are plotted along the horizontal axis of the coordinate plane:
sage: plot(vector([1]))
Graphics object consisting of 1 graphics primitive
An optional start argument may also be specified by a tuple, list, or vector:
sage: u = vector([1,2]); v = vector([2,5])
sage: plot(u, start=v)
Graphics object consisting of 1 graphics primitive
TESTS:
sage: u = vector([1,1]); v = vector([2,2,2]); z=(3,3,3)
sage: plot(u) #test when start=None
Graphics object consisting of 1 graphics primitive
sage: plot(u, start=v) #test when coordinate dimension mismatch exists
Traceback (most recent call last):
...
ValueError: vector coordinates are not of the same dimension
sage: P = plot(v, start=z) #test when start coordinates are passed as a tuple
sage: P = plot(v, start=list(z)) #test when start coordinates are passed as a list
INPUT:
EXAMPLES:
sage: eps=0.1
sage: v = vector(RDF, [sin(n*eps) for n in range(100)])
sage: v.plot_step(eps=eps, xmax=5, hue=0)
Graphics object consisting of 1 graphics primitive
Return a matrix with a single row and the same entries as the vector self.
OUTPUT:
A matrix over the same ring as the vector (or free module element), with a single row. The entries of the row are identical to those of the vector, and in the same order.
EXAMPLES:
sage: v = vector(ZZ, [1,2,3])
sage: w = v.row(); w
[1 2 3]
sage: w.parent()
Full MatrixSpace of 1 by 3 dense matrices over Integer Ring
sage: x = vector(FiniteField(13), [2,4,8,16])
sage: x.row()
[2 4 8 3]
There is more than one way to get one-row matrix from a vector, but the row method is more efficient than making a column and then taking a transpose. Notice that supplying a vector to the matrix constructor demonstrates Sage’s preference for rows.
sage: x = vector(RDF, [sin(i*pi/20) for i in range(10)])
sage: x.row() == matrix(x)
True
sage: x.row() == x.column().transpose()
True
Sparse or dense implementations are preserved.
sage: d = vector(RR, [1.0, 2.0, 3.0])
sage: s = vector(CDF, {2:5.0+6.0*I})
sage: dm = d.row()
sage: sm = s.row()
sage: all([d.is_dense(), dm.is_dense(), s.is_sparse(), sm.is_sparse()])
True
TESTS:
The row() method will return a specified row of a matrix as a vector. So here are a couple of round-trips.
sage: A = matrix(ZZ, [[1,2,3]])
sage: A == A.row(0).row()
True
sage: v = vector(ZZ, [4,5,6])
sage: v == v.row().row(0)
True
And a very small corner case.
sage: v = vector(ZZ, [])
sage: w = v.row()
sage: w.parent()
Full MatrixSpace of 1 by 0 dense matrices over Integer Ring
The set method is meant to be more efficient than __setitem__, because it need not be guaranteed to do any error checking or coercion. Use with great, great care.
EXAMPLES:
sage: v = vector([1/2,2/5,0]); v
(1/2, 2/5, 0)
sage: v.set(2, -15/17); v
(1/2, 2/5, -15/17)
Make this vector immutable. This operation can’t be undone.
EXAMPLES:
sage: v = vector([1..5]); v
(1, 2, 3, 4, 5)
sage: v[1] = 10
sage: v.set_immutable()
sage: v[1] = 10
Traceback (most recent call last):
...
ValueError: vector is immutable; please change a copy instead (use copy())
Return sparse version of self. If self is sparse, just return self; otherwise, create and return correspond sparse vector.
EXAMPLES:
sage: vector([-1,0,3,0,0,0]).sparse_vector().is_sparse()
True
sage: vector([-1,0,3,0,0,0]).sparse_vector().is_sparse()
True
sage: vector([-1,0,3,0,0,0]).sparse_vector()
(-1, 0, 3, 0, 0, 0)
EXAMPLES:
sage: var('a,b,d,e')
(a, b, d, e)
sage: v = vector([a, b, d, e])
sage: v.substitute(a=1)
(1, b, d, e)
sage: v.subs(a=b, b=d)
(b, d, d, e)
Return the integers i such that self[i] != 0. This is the same as the nonzero_positions function.
EXAMPLES:
sage: vector([-1,0,3,0,0,0,0.01]).support()
[0, 2, 6]
Returns a matrix, the outer product of two vectors self and right.
INPUT:
OUTPUT:
The outer product of two vectors and
(respectively
self and right) can be described several ways. If we
interpret
as a
matrix and interpret
as a
matrix, then the outer product is the
matrix from the usual matrix product
. Notice how this
is the “opposite” in some ways from an inner product (which
would require
).
If we just consider vectors, use each entry of to create
a scalar multiples of the vector
and use these vectors as
the rows of a matrix. Or use each entry of
to create a
scalar multiples of
and use these vectors as the columns
of a matrix.
EXAMPLES:
sage: u = vector(QQ, [1/2, 1/3, 1/4, 1/5])
sage: v = vector(ZZ, [60, 180, 600])
sage: u.outer_product(v)
[ 30 90 300]
[ 20 60 200]
[ 15 45 150]
[ 12 36 120]
sage: M = v.outer_product(u); M
[ 30 20 15 12]
[ 90 60 45 36]
[300 200 150 120]
sage: M.parent()
Full MatrixSpace of 3 by 4 dense matrices over Rational Field
The more general sage.matrix.matrix2.tensor_product() is an
operation on a pair of matrices. If we construe a pair of vectors
as a column vector and a row vector, then an outer product and a
tensor product are identical. Thus is a synonym
for this method.
sage: u = vector(QQ, [1/2, 1/3, 1/4, 1/5])
sage: v = vector(ZZ, [60, 180, 600])
sage: u.tensor_product(v) == (u.column()).tensor_product(v.row())
True
The result is always a dense matrix, no matter if the two vectors are, or are not, dense.
sage: d = vector(ZZ,[4,5], sparse=False)
sage: s = vector(ZZ, [1,2,3], sparse=True)
sage: dd = d.outer_product(d)
sage: ds = d.outer_product(s)
sage: sd = s.outer_product(d)
sage: ss = s.outer_product(s)
sage: all([dd.is_dense(), ds.is_dense(), sd.is_dense(), dd.is_dense()])
True
Vectors with no entries do the right thing.
sage: v = vector(ZZ, [])
sage: z = v.outer_product(v)
sage: z.parent()
Full MatrixSpace of 0 by 0 dense matrices over Integer Ring
There is a fair amount of latitude in the value of the right vector, and the matrix that results can have entries from a new ring large enough to contain the result. If you know better, you can sometimes bring the result down to a less general ring.
sage: R.<t> = ZZ[]
sage: v = vector(R, [12, 24*t])
sage: w = vector(QQ, [1/2, 1/3, 1/4])
sage: op = v.outer_product(w)
sage: op
[ 6 4 3]
[12*t 8*t 6*t]
sage: op.base_ring()
Univariate Polynomial Ring in t over Rational Field
sage: m = op.change_ring(R); m
[ 6 4 3]
[12*t 8*t 6*t]
sage: m.base_ring()
Univariate Polynomial Ring in t over Integer Ring
But some inputs are not compatible, even if vectors.
sage: w = vector(GF(5), [1,2])
sage: v = vector(GF(7), [1,2,3,4])
sage: z = w.outer_product(v)
Traceback (most recent call last):
...
TypeError: unsupported operand parent(s) for '*': 'Full MatrixSpace of 2 by 1 dense matrices over Finite Field of size 5' and 'Full MatrixSpace of 1 by 4 dense matrices over Finite Field of size 7'
And some inputs don’t make any sense at all.
sage: w=vector(QQ, [5,10])
sage: z=w.outer_product(6)
Traceback (most recent call last):
...
TypeError: right operand in an outer product must be a vector, not an element of Integer Ring
Bases: sage.modules.free_module_element.FreeModuleElement
A generic dense element of a free module.
TESTS:
sage: V = ZZ^3
sage: loads(dumps(V)) == V
True
sage: v = V.0
sage: loads(dumps(v)) == v
True
sage: v = (QQ['x']^3).0
sage: loads(dumps(v)) == v
True
Returns a vector over a callable symbolic expression ring.
EXAMPLES:
sage: x,y=var('x,y')
sage: v=vector([x,y,x*sin(y)])
sage: w=v.function([x,y]); w
(x, y) |--> (x, y, x*sin(y))
sage: w.base_ring()
Callable function ring with arguments (x, y)
sage: w(1,2)
(1, 2, sin(2))
sage: w(2,1)
(2, 1, 2*sin(1))
sage: w(y=1,x=2)
(2, 1, 2*sin(1))
sage: x,y=var('x,y')
sage: v=vector([x,y,x*sin(y)])
sage: w=v.function([x]); w
x |--> (x, y, x*sin(y))
sage: w.base_ring()
Callable function ring with argument x
sage: w(4)
(4, y, 4*sin(y))
Return list of elements of self.
INPUT:
- copy – bool, return list of underlying entries
EXAMPLES:
sage: P.<x,y,z> = QQ[]
sage: v = vector([x,y,z])
sage: type(v)
<type 'sage.modules.free_module_element.FreeModuleElement_generic_dense'>
sage: a = v.list(); a
[x, y, z]
sage: a[0] = x*y; v
(x, y, z)
sage: a = v.list(copy=False); a
[x, y, z]
sage: a[0] = x*y; v
(x*y, y, z)
Bases: sage.modules.free_module_element.FreeModuleElement
A generic sparse free module element is a dictionary with keys ints i and entries in the base ring.
EXAMPLES:
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)
sage: (b-a).dict()
{2: -1}
Return the least common multiple of the denominators of the entries of self.
EXAMPLES:
sage: v = vector([1/2,2/5,3/14], sparse=True)
sage: v.denominator()
70
Return dictionary of nonzero entries of self.
INPUT:
- copy – bool (default: True)
OUTPUT:
- Python dictionary
EXAMPLES:
sage: v = vector([0,0,0,0,1/2,0,3/14], sparse=True)
sage: v.dict()
{4: 1/2, 6: 3/14}
Like __getitem__ but with no guaranteed type or bounds checking. Returns 0 if access is out of bounds.
EXAMPLES:
sage: v = vector([1,2/3,pi], sparse=True)
sage: v.get(1)
2/3
sage: v.get(10)
0
Returns the number of positions i such that self[i] != 0.
EXAMPLES:
sage: v = vector({1: 1, 3: -2})
sage: w = vector({1: 4, 3: 2})
sage: v+w
(0, 5, 0, 0)
sage: (v+w).hamming_weight()
1
Return iterator over the entries of self.
EXAMPLES:
sage: v = vector([1,2/3,pi], sparse=True)
sage: v.iteritems()
<dictionary-itemiterator object at ...>
sage: list(v.iteritems())
[(0, 1), (1, 2/3), (2, pi)]
Return list of elements of self.
INPUT:
- copy – bool, return list of underlying entries
EXAMPLES:
sage: v = vector([1,2/3,pi], sparse=True)
sage: type(v)
<type 'sage.modules.free_module_element.FreeModuleElement_generic_sparse'>
sage: a = v.list(); a
[1, 2/3, pi]
Returns the list of numbers i such that self[i] != 0.
EXAMPLES:
sage: v = vector({1: 1, 3: -2})
sage: w = vector({1: 4, 3: 2})
sage: v+w
(0, 5, 0, 0)
sage: (v+w).nonzero_positions()
[1]
Like __setitem__ but with no guaranteed type or bounds checking.
EXAMPLES:
sage: v = vector([1,2/3,pi], sparse=True)
sage: v.set(1, pi^3)
sage: v
(1, pi^3, pi)
No bounds checking:
sage: v.set(10, pi)
This lack of bounds checking causes trouble later:
sage: v
<repr(<sage.modules.free_module_element.FreeModuleElement_generic_sparse at 0x...>) failed: IndexError: list assignment index out of range>
Return a vector or free module element with specified entries.
CALL FORMATS:
This constructor can be called in several different ways. In each case, sparse=True or sparse=False can be supplied as an option. free_module_element() is an alias for vector().
- vector(object)
- vector(ring, object)
- vector(object, ring)
- vector(ring, degree, object)
- vector(ring, degree)
- vector(numpy_array)
INPUT:
In call format 4, an error is raised if the degree does not match the length of object so this call can provide some safeguards. Note however that using this format when object is a dictionary is unlikely to work properly.
OUTPUT:
An element of the vector space or free module with the given base ring and implied or specified dimension or rank, containing the specified entries and with correct degree.
In call format 5, no entries are specified, so the element is populated with all zeros.
If the sparse option is not supplied, the output will generally have a dense representation. The exception is if object is a dictionary, then the representation will be sparse.
EXAMPLES:
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)
We make a vector mod 3 out of a vector over .
sage: vector(vector([1,2,3]), GF(3))
(1, 2, 0)
The degree of a vector may be specified:
sage: vector(QQ, 4, [1,1/2,1/3,1/4])
(1, 1/2, 1/3, 1/4)
But it is an error if the degree and size of the list of entries are mismatched:
sage: vector(QQ, 5, [1,1/2,1/3,1/4])
Traceback (most recent call last):
...
ValueError: incompatible degrees in vector constructor
Providing no entries populates the vector with zeros, but of course, you must specify the degree since it is not implied. Here we use a finite field as the base ring.
sage: w = vector(FiniteField(7), 4); w
(0, 0, 0, 0)
sage: w.parent()
Vector space of dimension 4 over Finite Field of size 7
The fastest method to construct a zero vector is to call the zero_vector() method directly on a free module or vector space, since vector(...) must do a small amount of type checking. Almost as fast as the zero_vector() method is the zero_vector() constructor, which defaults to the integers.
sage: vector(ZZ, 5) # works fine
(0, 0, 0, 0, 0)
sage: (ZZ^5).zero_vector() # very tiny bit faster
(0, 0, 0, 0, 0)
sage: zero_vector(ZZ, 5) # similar speed to vector(...)
(0, 0, 0, 0, 0)
sage: z = zero_vector(5); z
(0, 0, 0, 0, 0)
sage: z.parent()
Ambient free module of rank 5 over
the principal ideal domain Integer Ring
Here we illustrate the creation of sparse vectors by using a dictionary.
sage: vector({1:1.1, 3:3.14})
(0.000000000000000, 1.10000000000000, 0.000000000000000, 3.14000000000000)
With no degree given, a dictionary of entries implicitly declares a degree by the largest index (key) present. So you can provide a terminal element (perhaps a zero?) to set the degree. But it is probably safer to just include a degree in your construction.
sage: v = vector(QQ, {0:1/2, 4:-6, 7:0}); v
(1/2, 0, 0, 0, -6, 0, 0, 0)
sage: v.degree()
8
sage: v.is_sparse()
True
sage: w = vector(QQ, 8, {0:1/2, 4:-6})
sage: w == v
True
It is an error to specify a negative degree.
sage: vector(RR, -4, [1.0, 2.0, 3.0, 4.0])
Traceback (most recent call last):
...
ValueError: cannot specify the degree of a vector as a negative integer (-4)
It is an error to create a zero vector but not provide a ring as the first argument.
sage: vector('junk', 20)
Traceback (most recent call last):
...
TypeError: first argument must be base ring of zero vector, not junk
And it is an error to specify an index in a dictionary that is greater than or equal to a requested degree.
sage: vector(ZZ, 10, {3:4, 7:-2, 10:637})
Traceback (most recent call last):
...
ValueError: dictionary of entries has a key (index) exceeding the requested degree
A 1-dimensional numpy array of type float or complex may be passed to vector. Unless an explicit ring is given, the result will be a 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 column-wise slices of numpy matrices will raise an exception.
sage: import numpy
sage: x = numpy.random.randn(10)
sage: y = vector(x)
sage: parent(y)
Vector space of dimension 10 over Real Double Field
sage: parent(vector(RDF, x))
Vector space of dimension 10 over Real Double Field
sage: parent(vector(CDF, x))
Vector space of dimension 10 over Complex Double Field
sage: parent(vector(RR, x))
Vector space of dimension 10 over Real Field with 53 bits of precision
sage: v = numpy.random.randn(10) * numpy.complex(0,1)
sage: w = vector(v)
sage: parent(w)
Vector space of dimension 10 over Complex Double Field
Multi-dimensional arrays are not supported:
sage: import numpy as np
sage: a = np.array([[1, 2, 3], [4, 5, 6]], np.float64)
sage: vector(a)
Traceback (most recent call last):
...
TypeError: cannot convert 2-dimensional array to a vector
If any of the arguments to vector have Python type int, long, real, or complex, they will first be coerced to the appropriate Sage objects. This fixes trac ticket #3847.
sage: v = vector([int(0)]); v
(0)
sage: v[0].parent()
Integer Ring
sage: v = vector(range(10)); v
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
sage: v[3].parent()
Integer Ring
sage: v = vector([float(23.4), int(2), complex(2+7*I), long(1)]); v
(23.4, 2.0, 2.0 + 7.0*I, 1.0)
sage: v[1].parent()
Complex Double Field
If the argument is a vector, it doesn’t change the base ring. This fixes trac ticket #6643.
sage: K.<sqrt3> = QuadraticField(3)
sage: u = vector(K, (1/2, sqrt3/2) )
sage: vector(u).base_ring()
Number Field in sqrt3 with defining polynomial x^2 - 3
sage: v = vector(K, (0, 1) )
sage: vector(v).base_ring()
Number Field in sqrt3 with defining polynomial x^2 - 3
Constructing a vector from a numpy array behaves as expected:
sage: import numpy
sage: a=numpy.array([1,2,3])
sage: v=vector(a); v
(1, 2, 3)
sage: parent(v)
Ambient free module of rank 3 over the principal ideal domain Integer Ring
Complex numbers can be converted naturally to a sequence of length 2. And then to a vector.
sage: c = CDF(2 + 3*I)
sage: v = vector(c); v
(2.0, 3.0)
A generator, or other iterable, may also be supplied as input. Anything that can be converted to a Sequence is a possible input.
sage: type(i^2 for i in range(3))
<type 'generator'>
sage: v = vector(i^2 for i in range(3)); v
(0, 1, 4)
An empty list, without a ring given, will default to the integers.
sage: x = vector([]); x
()
sage: x.parent()
Ambient free module of rank 0 over the principal ideal domain Integer Ring
EXAMPLES:
sage: sage.modules.free_module_element.is_FreeModuleElement(0)
False
sage: sage.modules.free_module_element.is_FreeModuleElement(vector([1,2,3]))
True
EXAMPLES:
sage: sage.modules.free_module_element.make_FreeModuleElement_generic_dense(QQ^3, [1,2,-3/7], 3)
(1, 2, -3/7)
EXAMPLES:
sage: v = sage.modules.free_module_element.make_FreeModuleElement_generic_dense_v1(QQ^3, [1,2,-3/7], 3, True); v
(1, 2, -3/7)
sage: v[0] = 10; v
(10, 2, -3/7)
sage: v = sage.modules.free_module_element.make_FreeModuleElement_generic_dense_v1(QQ^3, [1,2,-3/7], 3, False); v
(1, 2, -3/7)
sage: v[0] = 10
Traceback (most recent call last):
...
ValueError: vector is immutable; please change a copy instead (use copy())
EXAMPLES:
sage: v = sage.modules.free_module_element.make_FreeModuleElement_generic_sparse(QQ^3, {2:5/2}, 3); v
(0, 0, 5/2)
EXAMPLES:
sage: v = sage.modules.free_module_element.make_FreeModuleElement_generic_sparse_v1(QQ^3, {2:5/2}, 3, False); v
(0, 0, 5/2)
sage: v.is_mutable()
False
Converts an object describing elements of a vector into a list of entries in a common ring.
INPUT:
OUTPUT:
A pair.
The first item is a list of the values specified in the object v. If the object is a dictionary , entries are placed in the list according to the indices that were their keys in the dictionary, and the remainder of the entries are zero. The value of degree is assumed to be larger than any index provided in the dictionary and will be used as the number of entries in the returned list.
The second item returned is a ring that contains all of the entries in the list. If R is given, the entries are coerced in. Otherwise a common ring is found. For more details, see the Sequence object. When v has no elements and R is None, the ring returned is the integers.
EXAMPLES:
sage: from sage.modules.free_module_element import prepare
sage: prepare([1,2/3,5],None)
([1, 2/3, 5], Rational Field)
sage: prepare([1,2/3,5],RR)
([1.00000000000000, 0.666666666666667, 5.00000000000000], Real Field with 53 bits of precision)
sage: prepare({1:4, 3:-2}, ZZ, 6)
([0, 4, 0, -2, 0, 0], Integer Ring)
sage: prepare({3:1, 5:3}, QQ, 6)
([0, 0, 0, 1, 0, 3], Rational Field)
sage: prepare([1,2/3,'10',5],RR)
([1.00000000000000, 0.666666666666667, 10.0000000000000, 5.00000000000000], Real Field with 53 bits of precision)
sage: prepare({},QQ, 0)
([], Rational Field)
sage: prepare([1,2/3,'10',5],None)
Traceback (most recent call last):
...
TypeError: unable to find a common ring for all elements
Some objects can be converted to sequences even if they are not always thought of as sequences.
sage: c = CDF(2+3*I)
sage: prepare(c, None)
([2.0, 3.0], Real Double Field)
This checks a bug listed at Trac #10595. Without good evidence for a ring, the default is the integers.
sage: prepare([], None)
([], Integer Ring)
Returns a vector (or module element) with random entries.
INPUT:
OUTPUT:
A vector, or free module element, with degree elements from ring, chosen randomly from the ring according to the ring’s random_element() method.
Note
See below for examples of how random elements are generated by some common base rings.
EXAMPLES:
First, module elements over the integers. The default distribution is tightly clustered around -1, 0, 1. Uniform distributions can be specified by giving bounds, though the upper bound is never met. See sage.rings.integer_ring.IntegerRing_class.random_element() for several other variants.
sage: random_vector(10)
(-8, 2, 0, 0, 1, -1, 2, 1, -95, -1)
sage: sorted(random_vector(20))
[-12, -6, -4, -4, -2, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 1, 1, 1, 4, 5]
sage: random_vector(ZZ, 20, x=4)
(2, 0, 3, 0, 1, 0, 2, 0, 2, 3, 0, 3, 1, 2, 2, 2, 1, 3, 2, 3)
sage: random_vector(ZZ, 20, x=-20, y=100)
(43, 47, 89, 31, 56, -20, 23, 52, 13, 53, 49, -12, -2, 94, -1, 95, 60, 83, 28, 63)
sage: random_vector(ZZ, 20, distribution="1/n")
(0, -1, -2, 0, -1, -2, 0, 0, 27, -1, 1, 1, 0, 2, -1, 1, -1, -2, -1, 3)
If the ring is not specified, the default is the integers, and parameters for the random distribution may be passed without using keywords. This is a random vector with 20 entries uniformly distributed between -20 and 100.
sage: random_vector(20, -20, 100)
(70, 19, 98, 2, -18, 88, 36, 66, 76, 52, 82, 99, 55, -17, 82, -15, 36, 28, 79, 18)
Now over the rationals. Note that bounds on the numerator and denominator may be specified. See sage.rings.rational_field.RationalField.random_element() for documentation.
sage: random_vector(QQ, 10)
(0, -1, -4/3, 2, 0, -13, 2/3, 0, -4/5, -1)
sage: random_vector(QQ, 10, num_bound = 15, den_bound = 5)
(-12/5, 9/4, -13/3, -1/3, 1, 5/4, 4, 1, -15, 10/3)
Inexact rings may be used as well. The reals have
uniform distributions, with the range as
the default. More at:
sage.rings.real_mpfr.RealField_class.random_element()
sage: random_vector(RR, 5)
(0.248997268533725, -0.112200126330480, 0.776829203293064, -0.899146461031406, 0.534465018743125)
sage: random_vector(RR, 5, min = 8, max = 14)
(8.43260944052606, 8.34129413391087, 8.92391495103829, 11.5784799413416, 11.0973561568002)
Any ring with a random_element() method may be used.
sage: F = FiniteField(23)
sage: hasattr(F, 'random_element')
True
sage: random_vector(F, 10)
(21, 6, 5, 2, 6, 2, 18, 9, 9, 7)
The default implementation is a dense representation, equivalent to setting sparse=False.
sage: v = random_vector(10)
sage: v.is_sparse()
False
sage: w = random_vector(ZZ, 20, sparse=True)
sage: w.is_sparse()
True
Inputs get checked before constructing the vector.
sage: random_vector('junk')
Traceback (most recent call last):
...
TypeError: degree of a random vector must be an integer, not None
sage: random_vector('stuff', 5)
Traceback (most recent call last):
...
TypeError: elements of a vector, or module element, must come from a ring, not stuff
sage: random_vector(ZZ, -9)
Traceback (most recent call last):
...
ValueError: degree of a random vector must be non-negative, not -9
Return a vector or free module element with specified entries.
CALL FORMATS:
This constructor can be called in several different ways. In each case, sparse=True or sparse=False can be supplied as an option. free_module_element() is an alias for vector().
- vector(object)
- vector(ring, object)
- vector(object, ring)
- vector(ring, degree, object)
- vector(ring, degree)
- vector(numpy_array)
INPUT:
In call format 4, an error is raised if the degree does not match the length of object so this call can provide some safeguards. Note however that using this format when object is a dictionary is unlikely to work properly.
OUTPUT:
An element of the vector space or free module with the given base ring and implied or specified dimension or rank, containing the specified entries and with correct degree.
In call format 5, no entries are specified, so the element is populated with all zeros.
If the sparse option is not supplied, the output will generally have a dense representation. The exception is if object is a dictionary, then the representation will be sparse.
EXAMPLES:
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)
We make a vector mod 3 out of a vector over .
sage: vector(vector([1,2,3]), GF(3))
(1, 2, 0)
The degree of a vector may be specified:
sage: vector(QQ, 4, [1,1/2,1/3,1/4])
(1, 1/2, 1/3, 1/4)
But it is an error if the degree and size of the list of entries are mismatched:
sage: vector(QQ, 5, [1,1/2,1/3,1/4])
Traceback (most recent call last):
...
ValueError: incompatible degrees in vector constructor
Providing no entries populates the vector with zeros, but of course, you must specify the degree since it is not implied. Here we use a finite field as the base ring.
sage: w = vector(FiniteField(7), 4); w
(0, 0, 0, 0)
sage: w.parent()
Vector space of dimension 4 over Finite Field of size 7
The fastest method to construct a zero vector is to call the zero_vector() method directly on a free module or vector space, since vector(...) must do a small amount of type checking. Almost as fast as the zero_vector() method is the zero_vector() constructor, which defaults to the integers.
sage: vector(ZZ, 5) # works fine
(0, 0, 0, 0, 0)
sage: (ZZ^5).zero_vector() # very tiny bit faster
(0, 0, 0, 0, 0)
sage: zero_vector(ZZ, 5) # similar speed to vector(...)
(0, 0, 0, 0, 0)
sage: z = zero_vector(5); z
(0, 0, 0, 0, 0)
sage: z.parent()
Ambient free module of rank 5 over
the principal ideal domain Integer Ring
Here we illustrate the creation of sparse vectors by using a dictionary.
sage: vector({1:1.1, 3:3.14})
(0.000000000000000, 1.10000000000000, 0.000000000000000, 3.14000000000000)
With no degree given, a dictionary of entries implicitly declares a degree by the largest index (key) present. So you can provide a terminal element (perhaps a zero?) to set the degree. But it is probably safer to just include a degree in your construction.
sage: v = vector(QQ, {0:1/2, 4:-6, 7:0}); v
(1/2, 0, 0, 0, -6, 0, 0, 0)
sage: v.degree()
8
sage: v.is_sparse()
True
sage: w = vector(QQ, 8, {0:1/2, 4:-6})
sage: w == v
True
It is an error to specify a negative degree.
sage: vector(RR, -4, [1.0, 2.0, 3.0, 4.0])
Traceback (most recent call last):
...
ValueError: cannot specify the degree of a vector as a negative integer (-4)
It is an error to create a zero vector but not provide a ring as the first argument.
sage: vector('junk', 20)
Traceback (most recent call last):
...
TypeError: first argument must be base ring of zero vector, not junk
And it is an error to specify an index in a dictionary that is greater than or equal to a requested degree.
sage: vector(ZZ, 10, {3:4, 7:-2, 10:637})
Traceback (most recent call last):
...
ValueError: dictionary of entries has a key (index) exceeding the requested degree
A 1-dimensional numpy array of type float or complex may be passed to vector. Unless an explicit ring is given, the result will be a 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 column-wise slices of numpy matrices will raise an exception.
sage: import numpy
sage: x = numpy.random.randn(10)
sage: y = vector(x)
sage: parent(y)
Vector space of dimension 10 over Real Double Field
sage: parent(vector(RDF, x))
Vector space of dimension 10 over Real Double Field
sage: parent(vector(CDF, x))
Vector space of dimension 10 over Complex Double Field
sage: parent(vector(RR, x))
Vector space of dimension 10 over Real Field with 53 bits of precision
sage: v = numpy.random.randn(10) * numpy.complex(0,1)
sage: w = vector(v)
sage: parent(w)
Vector space of dimension 10 over Complex Double Field
Multi-dimensional arrays are not supported:
sage: import numpy as np
sage: a = np.array([[1, 2, 3], [4, 5, 6]], np.float64)
sage: vector(a)
Traceback (most recent call last):
...
TypeError: cannot convert 2-dimensional array to a vector
If any of the arguments to vector have Python type int, long, real, or complex, they will first be coerced to the appropriate Sage objects. This fixes trac ticket #3847.
sage: v = vector([int(0)]); v
(0)
sage: v[0].parent()
Integer Ring
sage: v = vector(range(10)); v
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
sage: v[3].parent()
Integer Ring
sage: v = vector([float(23.4), int(2), complex(2+7*I), long(1)]); v
(23.4, 2.0, 2.0 + 7.0*I, 1.0)
sage: v[1].parent()
Complex Double Field
If the argument is a vector, it doesn’t change the base ring. This fixes trac ticket #6643.
sage: K.<sqrt3> = QuadraticField(3)
sage: u = vector(K, (1/2, sqrt3/2) )
sage: vector(u).base_ring()
Number Field in sqrt3 with defining polynomial x^2 - 3
sage: v = vector(K, (0, 1) )
sage: vector(v).base_ring()
Number Field in sqrt3 with defining polynomial x^2 - 3
Constructing a vector from a numpy array behaves as expected:
sage: import numpy
sage: a=numpy.array([1,2,3])
sage: v=vector(a); v
(1, 2, 3)
sage: parent(v)
Ambient free module of rank 3 over the principal ideal domain Integer Ring
Complex numbers can be converted naturally to a sequence of length 2. And then to a vector.
sage: c = CDF(2 + 3*I)
sage: v = vector(c); v
(2.0, 3.0)
A generator, or other iterable, may also be supplied as input. Anything that can be converted to a Sequence is a possible input.
sage: type(i^2 for i in range(3))
<type 'generator'>
sage: v = vector(i^2 for i in range(3)); v
(0, 1, 4)
An empty list, without a ring given, will default to the integers.
sage: x = vector([]); x
()
sage: x.parent()
Ambient free module of rank 0 over the principal ideal domain Integer Ring
Returns a vector or free module element with a specified number of zeros.
CALL FORMATS:
- zero_vector(degree)
- zero_vector(ring, degree)
INPUT:
OUTPUT:
A vector or free module element with degree entries, all equal to zero and belonging to the ring if specified. If no ring is given, a free module element over ZZ is returned.
EXAMPLES:
A zero vector over the field of rationals.
sage: v = zero_vector(QQ, 5); v
(0, 0, 0, 0, 0)
sage: v.parent()
Vector space of dimension 5 over Rational Field
A free module zero element.
sage: w = zero_vector(Integers(6), 3); w
(0, 0, 0)
sage: w.parent()
Ambient free module of rank 3 over Ring of integers modulo 6
If no ring is given, the integers are used.
sage: u = zero_vector(9); u
(0, 0, 0, 0, 0, 0, 0, 0, 0)
sage: u.parent()
Ambient free module of rank 9 over the principal ideal domain Integer Ring
Non-integer degrees produce an error.
sage: zero_vector(5.6)
Traceback (most recent call last):
...
TypeError: Attempt to coerce non-integral RealNumber to Integer
Negative degrees also give an error.
sage: zero_vector(-3)
Traceback (most recent call last):
...
ValueError: rank (=-3) must be nonnegative
Garbage instead of a ring will be recognized as such.
sage: zero_vector(x^2, 5)
Traceback (most recent call last):
...
TypeError: first argument must be a ring