Safe Haskell  Safe 

Language  Haskell2010 
 class Functor f => Additive f where
 negated :: (Num a, Functor f) => f a > f a
 (^^) :: (Additive f, Num a) => f a > f a > f a
 class Additive f => VectorSpace f where
 lerp :: (VectorSpace f, Num a) => a > f a > f a > f a
 class VectorSpace f => Hilbert f where
 hilbertDistSq :: (Hilbert f, Num a) => f a > f a > a
 class Hilbert f => Normed f where
 normSq :: (Hilbert f, Num a) => f a > a
 norm1 :: (Foldable t, Num a, Functor t) => t a > a
 norm2 :: (Hilbert f, Floating a) => f a > a
 normP :: (Foldable t, Functor t, Floating a) => a > t a > a
 normInfty :: (Foldable t, Ord a) => t a > a
 normalize :: (Normed f, Floating a, Eq a) => a > f a > f a
 dotLp :: (Set t, Foldable t, Floating a) => a > t a > t a > a
 reciprocal :: (Functor f, Fractional b) => f b > f b
 scale :: (Num b, Functor f) => b > f b > f b
 class Additive f => FiniteDim f where
 withDim :: (FiniteDim f, Show e) => f a > (FDSize f > f a > Bool) > (f a > c) > String > (f a > e) > c
 withDim2 :: (FiniteDim f, FiniteDim g, Show e) => f a > g b > (FDSize f > FDSize g > f a > g b > Bool) > (f a > g b > c) > String > (f a > g b > e) > c
 class Additive f => HasData f a where
 class (FiniteDim f, HasData f a) => Sparse f a where
 class Functor f => Set f where
 class Sparse c a => SpContainer c a where
Additive ring
Vector space
class Additive f => VectorSpace f where Source #
VectorSpace SpVector Source # 

lerp :: (VectorSpace f, Num a) => a > f a > f a > f a Source #
linear interpolation
Hilbert space (inner product)
class VectorSpace f => Hilbert f where Source #
Hilbertspace distance function
hilbertDistSq :: (Hilbert f, Num a) => f a > f a > a Source #
`hilbertDistSq x y =  x  y ^2`
Normed vector space
Norms and related results
normalize :: (Normed f, Floating a, Eq a) => a > f a > f a Source #
Normalize w.r.t. pnorm (p finite)
reciprocal :: (Functor f, Fractional b) => f b > f b Source #
Reciprocal
FiniteDim : finitedimensional objects
withDim :: (FiniteDim f, Show e) => f a > (FDSize f > f a > Bool) > (f a > c) > String > (f a > e) > c Source #
unary dimensionchecking bracket
withDim2 :: (FiniteDim f, FiniteDim g, Show e) => f a > g b > (FDSize f > FDSize g > f a > g b > Bool) > (f a > g b > c) > String > (f a > g b > e) > c Source #
binary dimensionchecking bracket
HasData : accessing inner data (do not export)
Sparse : sparse datastructures
class (FiniteDim f, HasData f a) => Sparse f a where Source #
spy :: Fractional b => f a > b Source #
Set : types that behave as sets
class Sparse c a => SpContainer c a where Source #