# VectorSpaceBasis RΒΆ

The domain `VectorSpaceBasis F` implements subspaces of finite dimensional vector spaces over a field `F`. A subspace is represented by a list of linearly independent coordinate vectors which constitute a basis. The empty list represents the space of dimension 0.

0: %

`0` creates the empty basis describing the space with the zero vector. The length of this zero vector is undefined.

*: (%, %) -> %

`b1*b2` computes a basis of the intersection of two subspaces.

+: (%, %) -> %

`B1+B2` computes a basis of the sum of two subspaces.

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

basis: List Vector R -> %

`basis LV` extracts a basis of the subspace spanned by the list of vectors `LV`.

canonicalBasis: NonNegativeInteger -> %

`canonicalBasis n` builds the canonical basis of the vector space of dimension `n`.

coerce: % -> List Vector R

`coerce b` returns the basis as a list of vectors.

coerce: % -> OutputForm
columnSpace: Matrix R -> %

`columnSpace M` builds a basis of the image space of the linear transformation defined by the matrix `M`. This function calls the `columnSpace` from the `Matrix` domain. Only the signature changes.

complementSpace: % -> %

`complementSpace B` builds a complement space of the basis `B` from some vectors of the canonical basis. This function fails with the empty basis.

complementSpace: (%, NonNegativeInteger) -> %

`complementSpace(B, n)` builds a complement space of the basis `B` from some vectors of the canonical basis `B`. The integer `n` provides the length of the vectors in the case of the empty basis.

complementSpace: (List Vector R, NonNegativeInteger) -> %

`complementSpace(Lv, n)` builds a complement space of the subspace spanned by the list of vectors `LV`. The integer `n` provides the length of the vectors in the case of the empty basis.

complementSpace: List Vector R -> %

`complementSpace Lv` builds a complement space of the subspace spanned by the list of vectors `LV`. This function fails with the empty basis.

coordinates: (Vector R, %) -> Vector R

`coordinates(v, B)` computes the coordinates of the vector `v` in the basis `B` if possible and produces an error otherwise.

coordinatesIfCan: (Vector R, %) -> Union(Vector R, failed)

`coordinatesIfCan(v, B)` computes the coordinates of the vector `v` in the basis `B` if possible and returns `"failed"` otherwise.

intBasis: (%, %) -> %

`intBasis(B1, B2)` computes a basis of the intersection of the two subspaces.

intBasis: (List Vector R, List Vector R) -> %

`intBasis(Lv1, Lv2)` computes a basis of the intersection of the two subspaces spanned by the vectors of `Lv1` and `Lv2`.

intBasis: List % -> %

`intBasis Lb` computes a basis of the intersection of the list of subspaces represented by `LLv`.

intBasis: List List Vector R -> %

`intBasis LLv` computes a basis of the intersection of the list of subspaces represented by `LLv`.

isBasis?: List Vector R -> Boolean

`isBasis? Lv` tests for linear independence of a list of vectors.

member?: (Vector R, %) -> Boolean

`member?(v, B)` tests if the vector `v` is in the subspace spanned by `B`.

nullSpace: Matrix R -> %

`nullSpace M` builds a basis of the kernel of the linear transformation defined by the matrix `M`. This function calls the function `nullSpace` from the `Matrix` domain. Only the signature changes.

rank: % -> NonNegativeInteger

`rank b` computes the rank of a basis, i.e. the number of vectors in the basis.

rank: List Vector R -> NonNegativeInteger

`rank Lv` computes the rank of a list of vectors.

subspace?: (%, %) -> Boolean

`subspace?(B1, B2)` tests if the first space is included in the second.

sumBasis: (%, %) -> %

`sumBasis(B1, B2)` computes a basis of the sum of the two subspaces.

sumBasis: (List Vector R, List Vector R) -> %

`sumBasis(Lv1, Lv2)` computes a basis of the sum of the two subspaces spanned by the vectors of `Lv1` and `Lv2`.

sumBasis: List % -> %

`sumBasis Lb` computes a basis of the sum of list of subspaces. This function is slightly more efficient than `reduce(sumBasis, Lb)`.

sumBasis: List List Vector R -> %

`sumBasis LLv` computes a basis of the sum of the list of subspaces represented by `LLv`. This function is slightly more efficient than `reduce(sumBasis, LLv)`.

BasicType