| Copyright | (c) Justus Sagemüller 2016 |
|---|---|
| License | GPL v3 |
| Maintainer | (@) jsag $ hvl.no |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | None |
| Language | Haskell2010 |
Data.VectorSpace.Free
Description
Synopsis
- data V0 a
- data V1 a
- data V2 a
- data V3 a
- data V4 a
- type Sequence = GSequence Vector
- data FinSuppSeq n
- class AdditiveGroup (Diff p) => AffineSpace p where
- class AdditiveGroup v where
- class AdditiveGroup v => VectorSpace v where
- class (VectorSpace v, AdditiveGroup (Scalar v)) => InnerSpace v where
- class VectorSpace v => HasBasis v where
- type Basis v
- basisValue :: Basis v -> v
- decompose :: v -> [(Basis v, Scalar v)]
- decompose' :: v -> Basis v -> Scalar v
- class (VectorSpace v, Fractional (Scalar v)) => OneDimensional v where
- class (VectorSpace v, Num (Scalar v)) => FreeVectorSpace v where
- class (VectorSpace v, Num (Scalar v)) => FiniteFreeSpace v where
- freeDimension :: Functor p => p v -> Int
- toFullUnboxVect :: Unbox (Scalar v) => v -> Vector (Scalar v)
- unsafeFromFullUnboxVect :: Unbox (Scalar v) => Vector (Scalar v) -> v
- fromUnboxVect :: Unbox (Scalar v) => Vector (Scalar v) -> v
Supported types
Fixed low dimension
These come from the linear package.
A 0-dimensional vector
>>>pure 1 :: V0 IntV0
>>>V0 + V0V0
Instances
| Monad V0 | |
| Functor V0 | |
| MonadFix V0 | |
| Applicative V0 | |
| Foldable V0 | |
Defined in Linear.V0 Methods fold :: Monoid m => V0 m -> m # foldMap :: Monoid m => (a -> m) -> V0 a -> m # foldMap' :: Monoid m => (a -> m) -> V0 a -> m # foldr :: (a -> b -> b) -> b -> V0 a -> b # foldr' :: (a -> b -> b) -> b -> V0 a -> b # foldl :: (b -> a -> b) -> b -> V0 a -> b # foldl' :: (b -> a -> b) -> b -> V0 a -> b # foldr1 :: (a -> a -> a) -> V0 a -> a # foldl1 :: (a -> a -> a) -> V0 a -> a # elem :: Eq a => a -> V0 a -> Bool # maximum :: Ord a => V0 a -> a # | |
| Traversable V0 | |
| Distributive V0 | |
| Representable V0 | |
| Eq1 V0 | |
| Ord1 V0 | |
| Read1 V0 | |
| Show1 V0 | |
| MonadZip V0 | |
| Serial1 V0 | |
Defined in Linear.V0 Methods serializeWith :: MonadPut m => (a -> m ()) -> V0 a -> m () # deserializeWith :: MonadGet m => m a -> m (V0 a) # | |
| Hashable1 V0 | |
| Apply V0 | |
| Affine V0 | |
| Finite V0 | |
| Metric V0 | |
| Additive V0 | |
| Bind V0 | |
| Lift (V0 a :: Type) | |
| Vector Vector (V0 a) | |
Defined in Linear.V0 Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (V0 a) -> m (Vector (V0 a)) # basicUnsafeThaw :: PrimMonad m => Vector (V0 a) -> m (Mutable Vector (PrimState m) (V0 a)) # basicLength :: Vector (V0 a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (V0 a) -> Vector (V0 a) # basicUnsafeIndexM :: Monad m => Vector (V0 a) -> Int -> m (V0 a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (V0 a) -> Vector (V0 a) -> m () # | |
| MVector MVector (V0 a) | |
Defined in Linear.V0 Methods basicLength :: MVector s (V0 a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (V0 a) -> MVector s (V0 a) # basicOverlaps :: MVector s (V0 a) -> MVector s (V0 a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (V0 a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (V0 a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> V0 a -> m (MVector (PrimState m) (V0 a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (V0 a) -> Int -> m (V0 a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (V0 a) -> Int -> V0 a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (V0 a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (V0 a) -> V0 a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (V0 a) -> MVector (PrimState m) (V0 a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (V0 a) -> MVector (PrimState m) (V0 a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (V0 a) -> Int -> m (MVector (PrimState m) (V0 a)) # | |
| Bounded (V0 a) | |
| Enum (V0 a) | |
| Eq (V0 a) | |
| Floating (V0 a) | |
| Fractional (V0 a) | |
| Data a => Data (V0 a) | |
Defined in Linear.V0 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V0 a -> c (V0 a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V0 a) # dataTypeOf :: V0 a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V0 a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V0 a)) # gmapT :: (forall b. Data b => b -> b) -> V0 a -> V0 a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V0 a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V0 a -> r # gmapQ :: (forall d. Data d => d -> u) -> V0 a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V0 a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V0 a -> m (V0 a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V0 a -> m (V0 a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V0 a -> m (V0 a) # | |
| Num (V0 a) | |
| Ord (V0 a) | |
| Read (V0 a) | |
| Show (V0 a) | |
| Ix (V0 a) | |
| Generic (V0 a) | |
| Semigroup (V0 a) | |
| Monoid (V0 a) | |
| HasTrie (E V0) Source # | |
| Storable (V0 a) | |
| Binary (V0 a) | |
| Serial (V0 a) | |
| Serialize (V0 a) | |
| NFData (V0 a) | |
| Hashable (V0 a) | |
| Unbox (V0 a) | |
Defined in Linear.V0 | |
| Ixed (V0 a) | |
| Epsilon (V0 a) | |
| Show (V0 Double) Source # | |
| Show (V0 Float) Source # | |
| Show (V0 Int) Source # | |
| Show (V0 Integer) Source # | |
| Random (V0 a) | |
| Num s => AffineSpace (V0 s) Source # | |
| (Num s, AdditiveGroup s) => HasBasis (V0 s) Source # | |
| Num s => VectorSpace (V0 s) Source # | |
| (Num s, AdditiveGroup s) => InnerSpace (V0 s) Source # | |
| Num s => AdditiveGroup (V0 s) Source # | |
| Num s => FiniteFreeSpace (V0 s) Source # | |
| Generic1 V0 | |
| FunctorWithIndex (E V0) V0 | |
| FoldableWithIndex (E V0) V0 | |
| TraversableWithIndex (E V0) V0 | |
| Each (V0 a) (V0 b) a b | |
| Num s => AffineSpace (Point V0 s) Source # | |
| type Rep V0 | |
| type Diff V0 | |
Defined in Linear.Affine | |
| type Size V0 | |
| newtype MVector s (V0 a) | |
| type Rep (V0 a) | |
| newtype (E V0) :->: a Source # | |
| newtype Vector (V0 a) | |
| type Index (V0 a) | |
| type IxValue (V0 a) | |
| type Diff (V0 s) Source # | |
Defined in Data.VectorSpace.Free | |
| type Basis (V0 s) Source # | |
Defined in Data.VectorSpace.Free | |
| type Scalar (V0 s) Source # | |
Defined in Data.VectorSpace.Free | |
| type Rep1 V0 | |
| type Diff (Point V0 s) Source # | |
Defined in Data.VectorSpace.Free | |
A 1-dimensional vector
>>>pure 1 :: V1 IntV1 1
>>>V1 2 + V1 3V1 5
>>>V1 2 * V1 3V1 6
>>>sum (V1 2)2
Instances
| Monad V1 | |
| Functor V1 | |
| MonadFix V1 | |
| Applicative V1 | |
| Foldable V1 | |
Defined in Linear.V1 Methods fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
| Traversable V1 | |
| Distributive V1 | |
| Representable V1 | |
| Eq1 V1 | |
| Ord1 V1 | |
| Read1 V1 | |
| Show1 V1 | |
| MonadZip V1 | |
| Serial1 V1 | |
Defined in Linear.V1 Methods serializeWith :: MonadPut m => (a -> m ()) -> V1 a -> m () # deserializeWith :: MonadGet m => m a -> m (V1 a) # | |
| Hashable1 V1 | |
| Apply V1 | |
| Traversable1 V1 | |
| Affine V1 | |
| R1 V1 | |
| Finite V1 | |
| Metric V1 | |
| Additive V1 | |
| Bind V1 | |
| Foldable1 V1 | |
| Lift a => Lift (V1 a :: Type) | |
| Unbox a => Vector Vector (V1 a) | |
Defined in Linear.V1 Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (V1 a) -> m (Vector (V1 a)) # basicUnsafeThaw :: PrimMonad m => Vector (V1 a) -> m (Mutable Vector (PrimState m) (V1 a)) # basicLength :: Vector (V1 a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (V1 a) -> Vector (V1 a) # basicUnsafeIndexM :: Monad m => Vector (V1 a) -> Int -> m (V1 a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (V1 a) -> Vector (V1 a) -> m () # | |
| Unbox a => MVector MVector (V1 a) | |
Defined in Linear.V1 Methods basicLength :: MVector s (V1 a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (V1 a) -> MVector s (V1 a) # basicOverlaps :: MVector s (V1 a) -> MVector s (V1 a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (V1 a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (V1 a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> V1 a -> m (MVector (PrimState m) (V1 a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (V1 a) -> Int -> m (V1 a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (V1 a) -> Int -> V1 a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (V1 a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (V1 a) -> V1 a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (V1 a) -> MVector (PrimState m) (V1 a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (V1 a) -> MVector (PrimState m) (V1 a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (V1 a) -> Int -> m (MVector (PrimState m) (V1 a)) # | |
| Bounded a => Bounded (V1 a) | |
| Eq a => Eq (V1 a) | |
| Floating a => Floating (V1 a) | |
| Fractional a => Fractional (V1 a) | |
| Data a => Data (V1 a) | |
Defined in Linear.V1 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 a -> c (V1 a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 a) # dataTypeOf :: V1 a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V1 a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 a)) # gmapT :: (forall b. Data b => b -> b) -> V1 a -> V1 a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 a -> r # gmapQ :: (forall d. Data d => d -> u) -> V1 a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 a -> m (V1 a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 a -> m (V1 a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 a -> m (V1 a) # | |
| Num a => Num (V1 a) | |
| Ord a => Ord (V1 a) | |
| Read a => Read (V1 a) | |
| Show a => Show (V1 a) | |
| Ix a => Ix (V1 a) | |
| Generic (V1 a) | |
| Semigroup a => Semigroup (V1 a) | |
| Monoid a => Monoid (V1 a) | |
| HasTrie (E V1) Source # | |
| Storable a => Storable (V1 a) | |
| Binary a => Binary (V1 a) | |
| Serial a => Serial (V1 a) | |
| Serialize a => Serialize (V1 a) | |
| NFData a => NFData (V1 a) | |
| Hashable a => Hashable (V1 a) | |
| Unbox a => Unbox (V1 a) | |
Defined in Linear.V1 | |
| Ixed (V1 a) | |
| Epsilon a => Epsilon (V1 a) | |
| Show (V1 Double) Source # | |
| Show (V1 Float) Source # | |
| Show (V1 Int) Source # | |
| Show (V1 Integer) Source # | |
| Random a => Random (V1 a) | |
| Num s => AffineSpace (V1 s) Source # | |
| (Num s, AdditiveGroup s) => HasBasis (V1 s) Source # | |
| Num s => VectorSpace (V1 s) Source # | |
| (Num s, AdditiveGroup s) => InnerSpace (V1 s) Source # | |
| Num s => AdditiveGroup (V1 s) Source # | |
| Num s => FiniteFreeSpace (V1 s) Source # | |
| (Eq r, Fractional r) => OneDimensional (V1 r) Source # | |
| Generic1 V1 | |
| FunctorWithIndex (E V1) V1 | |
| FoldableWithIndex (E V1) V1 | |
| TraversableWithIndex (E V1) V1 | |
| Each (V1 a) (V1 b) a b | |
| Field1 (V1 a) (V1 b) a b | |
| Num s => AffineSpace (Point V1 s) Source # | |
| type Rep V1 | |
| type Diff V1 | |
Defined in Linear.Affine | |
| type Size V1 | |
| newtype MVector s (V1 a) | |
| type Rep (V1 a) | |
| newtype (E V1) :->: a Source # | |
| newtype Vector (V1 a) | |
| type Index (V1 a) | |
| type IxValue (V1 a) | |
| type Diff (V1 s) Source # | |
Defined in Data.VectorSpace.Free | |
| type Basis (V1 s) Source # | |
Defined in Data.VectorSpace.Free | |
| type Scalar (V1 s) Source # | |
Defined in Data.VectorSpace.Free | |
| type Rep1 V1 | |
| type Diff (Point V1 s) Source # | |
Defined in Data.VectorSpace.Free | |
A 2-dimensional vector
>>>pure 1 :: V2 IntV2 1 1
>>>V2 1 2 + V2 3 4V2 4 6
>>>V2 1 2 * V2 3 4V2 3 8
>>>sum (V2 1 2)3
Instances
A 3-dimensional vector
Instances
A 4-dimensional vector.
Instances
Arbitrary dimension
data FinSuppSeq n Source #
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.)
Instances
The vector-space type classes
General
These come from the vector-space package.
class AdditiveGroup (Diff p) => AffineSpace p where #
Minimal complete definition
Nothing
Methods
(.-.) :: p -> p -> Diff p infix 6 #
Subtract points
(.+^) :: p -> Diff p -> p infixl 6 #
Point plus vector
Instances
class AdditiveGroup v where #
Additive group v.
Minimal complete definition
Nothing
Methods
The zero element: identity for (^+^)
(^+^) :: v -> v -> v infixl 6 #
Add vectors
Additive inverse
(^-^) :: v -> v -> v infixl 6 #
Group subtraction
Instances
class AdditiveGroup v => VectorSpace v where #
Vector space v.
Minimal complete definition
Nothing
Instances
class (VectorSpace v, AdditiveGroup (Scalar v)) => InnerSpace v where #
Adds inner (dot) products.
Minimal complete definition
Nothing
Instances
class VectorSpace v => HasBasis v where #
Minimal complete definition
Nothing
Associated Types
Representation of the canonical basis for v
Methods
basisValue :: Basis v -> v #
Interpret basis rep as a vector
decompose :: v -> [(Basis v, Scalar v)] #
Extract coordinates
decompose' :: v -> Basis v -> Scalar v #
Experimental version. More elegant definitions, and friendly to infinite-dimensional vector spaces.
Instances
Small
class (VectorSpace v, Fractional (Scalar v)) => OneDimensional v where Source #
Minimal complete definition
Nothing
Methods
(^/^) :: v -> v -> Maybe (Scalar v) infixr 7 Source #
Compare the (directed) length of two vectors.
default (^/^) :: (Generic v, OneDimensional (VRep v), Scalar (VRep v) ~ Scalar v) => v -> v -> Maybe (Scalar v) Source #
(^/!) :: v -> v -> Scalar v infixr 7 Source #
Unsafe version of ^/^.
Instances
| OneDimensional Double Source # | |
| OneDimensional Float Source # | |
| OneDimensional CFloat Source # | |
| OneDimensional CDouble Source # | |
| Integral i => OneDimensional (Ratio i) Source # | |
| (Eq r, Fractional r) => OneDimensional (V1 r) Source # | |
| OneDimensional a => OneDimensional (Rec0 a s) Source # | |
| OneDimensional (f p) => OneDimensional (M1 i c f p) Source # | |
Free
class (VectorSpace v, Num (Scalar v)) => FreeVectorSpace v where Source #
Vector spaces that are spanned by a specific, canonical set of basis vectors.
Methods
Element-wise multiplication, equivalent to Matlab's .* operator or
liftI2 (*)
vmap :: (Scalar v -> Scalar v) -> v -> v Source #
Like a monomorphic fmap. Only guaranteed to act on the nonzero entries;
whether the function is also applied on zeroes is instance-specific.
Instances
class (VectorSpace v, Num (Scalar v)) => FiniteFreeSpace v where Source #
Minimal complete definition
Nothing
Methods
freeDimension :: Functor p => p v -> Int Source #
default freeDimension :: (Generic v, FiniteFreeSpace (VRep v)) => p v -> Int Source #
toFullUnboxVect :: Unbox (Scalar v) => v -> Vector (Scalar v) Source #
default toFullUnboxVect :: (Generic v, FiniteFreeSpace (VRep v), Unbox (Scalar v), Scalar (VRep v) ~ Scalar v) => v -> Vector (Scalar v) Source #
unsafeFromFullUnboxVect :: Unbox (Scalar v) => Vector (Scalar v) -> v Source #
default unsafeFromFullUnboxVect :: (Generic v, FiniteFreeSpace (VRep v), Unbox (Scalar v), Scalar (VRep v) ~ Scalar v) => Vector (Scalar v) -> v Source #
fromUnboxVect :: Unbox (Scalar v) => Vector (Scalar v) -> v Source #