Data.VectorSpace.Free.FiniteSupportedSequence

Documentation

newtype FinSuppSeq n

The space of finitely-supported sequences is an infinite-dimensional space. An vector of length l is here understood as an infinite sequence that begins with l nonzero values, and continues with infinite zeroes.

You may also consider this as the type that languages like Octave/Matlab (as well as Haskell's hmatrix library) approximate with their “vectors”, with one important difference: there is no such thing as a dimensional-mismatch error, since we consider all these vectors as elements of the same infinite-dimensional space. Adding two different-size vectors will simply zero-pad the shorter, and unlike in Matlab this behaviour extends consequently to matrix multiplication etc. (defined in linearmap-category)

Of course it can make sense to constrain the dimension, but for this the type system should be used, not runtime checks.

(This is the same behaviour that the linear library gives to the standard list and vector types, but the problem there is that it can't use unboxed arrays as these are not functors, but unboxing is crucial for performance.)

Constructors

FinSuppSeq

Fields

• getFiniteSeq :: Vector n

Instances

Unbox n => IsList (FinSuppSeq n)

Associated Types

type Item (FinSuppSeq n) :: *

Methods

fromList :: [Item (FinSuppSeq n)] -> FinSuppSeq n

fromListN :: Int -> [Item (FinSuppSeq n)] -> FinSuppSeq n

toList :: FinSuppSeq n -> [Item (FinSuppSeq n)]

(Unbox n, Show n) => Show (FinSuppSeq n)

Methods

showsPrec :: Int -> FinSuppSeq n -> ShowS

show :: FinSuppSeq n -> String

showList :: [FinSuppSeq n] -> ShowS

(Num n, Unbox n) => AffineSpace (FinSuppSeq n)

Associated Types

type Diff (FinSuppSeq n) :: *

Methods

(.-.) :: FinSuppSeq n -> FinSuppSeq n -> Diff (FinSuppSeq n)

(.+^) :: FinSuppSeq n -> Diff (FinSuppSeq n) -> FinSuppSeq n

(Num n, Unbox n) => HasBasis (FinSuppSeq n)

Associated Types

type Basis (FinSuppSeq n) :: *

Methods

basisValue :: Basis (FinSuppSeq n) -> FinSuppSeq n

decompose :: FinSuppSeq n -> [(Basis (FinSuppSeq n), Scalar (FinSuppSeq n))]

decompose' :: FinSuppSeq n -> Basis (FinSuppSeq n) -> Scalar (FinSuppSeq n)

(Num n, Unbox n) => VectorSpace (FinSuppSeq n)

Associated Types

type Scalar (FinSuppSeq n) :: *

Methods

(*^) :: Scalar (FinSuppSeq n) -> FinSuppSeq n -> FinSuppSeq n

(Num n, AdditiveGroup n, Unbox n) => InnerSpace (FinSuppSeq n)

Methods

(<.>) :: FinSuppSeq n -> FinSuppSeq n -> Scalar (FinSuppSeq n)

(Num n, Unbox n) => AdditiveGroup (FinSuppSeq n)

Methods

zeroV :: FinSuppSeq n

(^+^) :: FinSuppSeq n -> FinSuppSeq n -> FinSuppSeq n

negateV :: FinSuppSeq n -> FinSuppSeq n

(^-^) :: FinSuppSeq n -> FinSuppSeq n -> FinSuppSeq n

(Num n, AdditiveGroup n, Unbox n) => FreeVectorSpace (FinSuppSeq n)

Methods

(^*^) :: FinSuppSeq n -> FinSuppSeq n -> FinSuppSeq n

vmap :: (Scalar (FinSuppSeq n) -> Scalar (FinSuppSeq n)) -> FinSuppSeq n -> FinSuppSeq n

type Item (FinSuppSeq n)

type Item (FinSuppSeq n) = n

type Diff (FinSuppSeq n)

type Diff (FinSuppSeq n) = FinSuppSeq n

type Basis (FinSuppSeq n)

type Basis (FinSuppSeq n) = Int

type Scalar (FinSuppSeq n)

type Scalar (FinSuppSeq n) = n

data SparseSuppSeq n

Sparsely supported sequences (what other languages would call sparse vectors) are sequences consisting of lots of zeroes, with finitely many nonzeroes scattered around. Only these nonzero elements are stored.

Constructors

SparseSuppSeq

Fields

• sparseNonzeroes :: Vector (Int, n)

Instances

(Unbox n, Eq n, Num n) => IsList (SparseSuppSeq n)

Associated Types

type Item (SparseSuppSeq n) :: *

Methods

fromList :: [Item (SparseSuppSeq n)] -> SparseSuppSeq n

fromListN :: Int -> [Item (SparseSuppSeq n)] -> SparseSuppSeq n

toList :: SparseSuppSeq n -> [Item (SparseSuppSeq n)]

(Num n, Unbox n) => AffineSpace (SparseSuppSeq n)

Associated Types

type Diff (SparseSuppSeq n) :: *

Methods

(.-.) :: SparseSuppSeq n -> SparseSuppSeq n -> Diff (SparseSuppSeq n)

(.+^) :: SparseSuppSeq n -> Diff (SparseSuppSeq n) -> SparseSuppSeq n

(Num n, Unbox n) => HasBasis (SparseSuppSeq n)

Associated Types

type Basis (SparseSuppSeq n) :: *

Methods

basisValue :: Basis (SparseSuppSeq n) -> SparseSuppSeq n

decompose :: SparseSuppSeq n -> [(Basis (SparseSuppSeq n), Scalar (SparseSuppSeq n))]

decompose' :: SparseSuppSeq n -> Basis (SparseSuppSeq n) -> Scalar (SparseSuppSeq n)

(Num n, Unbox n) => VectorSpace (SparseSuppSeq n)

Associated Types

type Scalar (SparseSuppSeq n) :: *

Methods

(*^) :: Scalar (SparseSuppSeq n) -> SparseSuppSeq n -> SparseSuppSeq n

(Num n, AdditiveGroup n, Unbox n) => InnerSpace (SparseSuppSeq n)

Methods

(<.>) :: SparseSuppSeq n -> SparseSuppSeq n -> Scalar (SparseSuppSeq n)

(Num n, Unbox n) => AdditiveGroup (SparseSuppSeq n)

Methods

zeroV :: SparseSuppSeq n

(^+^) :: SparseSuppSeq n -> SparseSuppSeq n -> SparseSuppSeq n

negateV :: SparseSuppSeq n -> SparseSuppSeq n

(^-^) :: SparseSuppSeq n -> SparseSuppSeq n -> SparseSuppSeq n

(Num n, Unbox n) => FreeVectorSpace (SparseSuppSeq n)

Methods

(^*^) :: SparseSuppSeq n -> SparseSuppSeq n -> SparseSuppSeq n

vmap :: (Scalar (SparseSuppSeq n) -> Scalar (SparseSuppSeq n)) -> SparseSuppSeq n -> SparseSuppSeq n

type Item (SparseSuppSeq n)

type Item (SparseSuppSeq n) = n

type Diff (SparseSuppSeq n)

type Diff (SparseSuppSeq n) = SparseSuppSeq n

type Basis (SparseSuppSeq n)

type Basis (SparseSuppSeq n) = Int

type Scalar (SparseSuppSeq n)

type Scalar (SparseSuppSeq n) = n

data SemisparseSuppSeq n

Like SparseSuppSeq, this type of number-sequence ignores zeroes and only stores nonzero elements with positional information, but it does this not for every single entry separately: only the first position of each contiguous chunk of nonzeroes is tracked. It is thus more suited for vectors that are in some places dense but still have lots of zeroes.

The drawback is that random access (i.e. decompose') has complexity 𝓞(𝑛) – instead of 𝓞(1) for FinSuppSeq, or 𝓞(log 𝑛) for SparseSuppSeq – so this type should only be used for “abstract vector operations”.

Constructors

SemisparseSuppSeq

Fields

• chunkSparseNonzeroes :: Vector n
• sparseNonzeroLocation :: Vector (Int, Int)

  Start index of block, size of block of consecutive nonzeroes

Instances

(Unbox n, Eq n, Num n) => IsList (SemisparseSuppSeq n)

Associated Types

type Item (SemisparseSuppSeq n) :: *

Methods

fromList :: [Item (SemisparseSuppSeq n)] -> SemisparseSuppSeq n

fromListN :: Int -> [Item (SemisparseSuppSeq n)] -> SemisparseSuppSeq n

toList :: SemisparseSuppSeq n -> [Item (SemisparseSuppSeq n)]

(Num n, Unbox n) => AffineSpace (SemisparseSuppSeq n)

Associated Types

type Diff (SemisparseSuppSeq n) :: *

Methods

(.-.) :: SemisparseSuppSeq n -> SemisparseSuppSeq n -> Diff (SemisparseSuppSeq n)

(.+^) :: SemisparseSuppSeq n -> Diff (SemisparseSuppSeq n) -> SemisparseSuppSeq n

(Num n, Unbox n) => HasBasis (SemisparseSuppSeq n)

Associated Types

type Basis (SemisparseSuppSeq n) :: *

Methods

basisValue :: Basis (SemisparseSuppSeq n) -> SemisparseSuppSeq n

decompose :: SemisparseSuppSeq n -> [(Basis (SemisparseSuppSeq n), Scalar (SemisparseSuppSeq n))]

decompose' :: SemisparseSuppSeq n -> Basis (SemisparseSuppSeq n) -> Scalar (SemisparseSuppSeq n)

(Num n, Unbox n) => VectorSpace (SemisparseSuppSeq n)

Associated Types

type Scalar (SemisparseSuppSeq n) :: *

Methods

(*^) :: Scalar (SemisparseSuppSeq n) -> SemisparseSuppSeq n -> SemisparseSuppSeq n

(Num n, AdditiveGroup n, Unbox n) => InnerSpace (SemisparseSuppSeq n)

Methods

(<.>) :: SemisparseSuppSeq n -> SemisparseSuppSeq n -> Scalar (SemisparseSuppSeq n)

(Num n, Unbox n) => AdditiveGroup (SemisparseSuppSeq n)

Methods

zeroV :: SemisparseSuppSeq n

(^+^) :: SemisparseSuppSeq n -> SemisparseSuppSeq n -> SemisparseSuppSeq n

negateV :: SemisparseSuppSeq n -> SemisparseSuppSeq n

(^-^) :: SemisparseSuppSeq n -> SemisparseSuppSeq n -> SemisparseSuppSeq n

(Num n, Unbox n) => FreeVectorSpace (SemisparseSuppSeq n)

Methods

(^*^) :: SemisparseSuppSeq n -> SemisparseSuppSeq n -> SemisparseSuppSeq n

vmap :: (Scalar (SemisparseSuppSeq n) -> Scalar (SemisparseSuppSeq n)) -> SemisparseSuppSeq n -> SemisparseSuppSeq n

type Item (SemisparseSuppSeq n)

type Item (SemisparseSuppSeq n) = n

type Diff (SemisparseSuppSeq n)

type Diff (SemisparseSuppSeq n) = SemisparseSuppSeq n

type Basis (SemisparseSuppSeq n)

type Basis (SemisparseSuppSeq n) = Int

type Scalar (SemisparseSuppSeq n)

type Scalar (SemisparseSuppSeq n) = n