-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Vector & affine spaces, linear maps, and derivatives (requires ghc 6.9)
--   
--   <i>vector-space</i> provides classes and generic operations for vector
--   spaces and affine spaces. It also defines a type of infinite towers of
--   generalized derivatives. A generalized derivative is a linear
--   transformation rather than one of the common concrete representations
--   (scalars, vectors, matrices, ...).
--   
--   <i>Warning</i>: this package depends on type families working fairly
--   well, and requires ghc version at least 6.9.
--   
--   Project wiki page: <a>http://haskell.org/haskellwiki/vector-space</a>
--   
--   The module documentation pages have links to colorized source code and
--   to wiki pages where you can read and contribute user comments. Enjoy!
--   
--   © 2008 by Conal Elliott; BSD3 license.
@package vector-space
@version 0.5


-- | Number class instances for functions and tuples
module Data.NumInstances
instance (Floating a, Floating b, Floating c, Floating d) => Floating (a, b, c, d)
instance (Fractional a, Fractional b, Fractional c, Fractional d) => Fractional (a, b, c, d)
instance (Num a, Num b, Num c, Num d) => Num (a, b, c, d)
instance (Floating a, Floating b, Floating c) => Floating (a, b, c)
instance (Fractional a, Fractional b, Fractional c) => Fractional (a, b, c)
instance (Num a, Num b, Num c) => Num (a, b, c)
instance (Floating a, Floating b) => Floating (a, b)
instance (Fractional a, Fractional b) => Fractional (a, b)
instance (Num a, Num b) => Num (a, b)
instance (Floating b) => Floating (a -> b)
instance (Fractional b) => Fractional (a -> b)
instance (Num b) => Num (a -> b)
instance Show (a -> b)
instance (Ord b) => Ord (a -> b)
instance Eq (a -> b)


-- | Groups: zero, addition, and negation (additive inverse)
module Data.AdditiveGroup

-- | Additive group <tt>v</tt>.
class AdditiveGroup v
zeroV :: (AdditiveGroup v) => v
(^+^) :: (AdditiveGroup v) => v -> v -> v
negateV :: (AdditiveGroup v) => v -> v

-- | Group subtraction
(^-^) :: (AdditiveGroup v) => v -> v -> v

-- | Sum over several vectors
sumV :: (AdditiveGroup v) => [v] -> v
instance (HasTrie u, AdditiveGroup v) => AdditiveGroup (u :->: v)
instance (AdditiveGroup v) => AdditiveGroup (a -> v)
instance (AdditiveGroup u, AdditiveGroup v, AdditiveGroup w) => AdditiveGroup (u, v, w)
instance (AdditiveGroup u, AdditiveGroup v) => AdditiveGroup (u, v)
instance (RealFloat v, AdditiveGroup v) => AdditiveGroup (Complex v)
instance AdditiveGroup Float
instance AdditiveGroup Double
instance AdditiveGroup ()


-- | Vector spaces
--   
--   This version uses associated types instead of fundeps and requires
--   ghc-6.10 or later
module Data.VectorSpace

-- | Vector space <tt>v</tt> over a scalar field <tt>s</tt>. Extends
--   <a>AdditiveGroup</a> with scalar multiplication.
class (AdditiveGroup v) => VectorSpace v where { type family Scalar v :: *; }
(*^) :: (VectorSpace v) => Scalar v -> v -> v

-- | Vector divided by scalar
(^/) :: (VectorSpace v, s ~ (Scalar v), Fractional s) => v -> s -> v

-- | Vector multiplied by scalar
(^*) :: (VectorSpace v, s ~ (Scalar v)) => v -> s -> v

-- | Adds inner (dot) products.
class (VectorSpace v) => InnerSpace v
(<.>) :: (InnerSpace v) => v -> v -> Scalar v

-- | Linear interpolation between <tt>a</tt> (when <tt>t==0</tt>) and
--   <tt>b</tt> (when <tt>t==1</tt>).
lerp :: (VectorSpace v, s ~ (Scalar v), Num s) => v -> v -> s -> v

-- | Square of the length of a vector. Sometimes useful for efficiency. See
--   also <a>magnitude</a>.
magnitudeSq :: (InnerSpace v, s ~ (Scalar v)) => v -> s

-- | Length of a vector. See also <a>magnitudeSq</a>.
magnitude :: (InnerSpace v, s ~ (Scalar v), Floating s) => v -> s

-- | Vector in same direction as given one but with length of one. If given
--   the zero vector, then return it.
normalized :: (InnerSpace v, s ~ (Scalar v), Floating s) => v -> v
instance (HasTrie a, VectorSpace v) => VectorSpace (a :->: v)
instance (VectorSpace v) => VectorSpace (a -> v)
instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, InnerSpace u, InnerSpace v, InnerSpace w, AdditiveGroup s) => InnerSpace (u, v, w)
instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, VectorSpace u, VectorSpace v, VectorSpace w) => VectorSpace (u, v, w)
instance (s ~ Scalar u, s ~ Scalar v, InnerSpace u, InnerSpace v, AdditiveGroup (Scalar v)) => InnerSpace (u, v)
instance (s ~ Scalar u, s ~ Scalar v, VectorSpace u, VectorSpace v) => VectorSpace (u, v)
instance (s ~ Scalar v, RealFloat v, InnerSpace v, AdditiveGroup s) => InnerSpace (Complex v)
instance (RealFloat v, VectorSpace v) => VectorSpace (Complex v)
instance InnerSpace Float
instance VectorSpace Float
instance InnerSpace Double
instance VectorSpace Double


-- | Basis of a vector space, as an associated type This module requires
--   ghc-6.10 or later
module Data.Basis
class (VectorSpace v) => HasBasis v where { type family Basis v :: *; }
basisValue :: (HasBasis v) => Basis v -> v
decompose :: (HasBasis v) => v -> [(Basis v, Scalar v)]
decompose' :: (HasBasis v) => v -> (Basis v -> Scalar v)

-- | Linear combination
linearCombo :: (VectorSpace v) => [(v, Scalar v)] -> v
recompose :: (HasBasis v) => [(Basis v, Scalar v)] -> v
instance (Eq a, HasBasis u) => HasBasis (a -> u)
instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, HasBasis u, HasBasis v, HasBasis w) => HasBasis (u, v, w)
instance (s ~ Scalar u, s ~ Scalar v, HasBasis u, HasBasis v) => HasBasis (u, v)
instance HasBasis Double
instance HasBasis Float


-- | Linear maps This version uses ABasis, which requires ghc-6.10 or
--   later.
module Data.LinearMap

-- | Linear map, represented as a memo-trie from basis to values.
type :-* u v = Basis u :->: v

-- | Function (assumed linear) as linear map.
linear :: (VectorSpace u, VectorSpace v, HasBasis u, HasTrie (Basis u)) => (u -> v) -> (u :-* v)

-- | Apply a linear map to a vector.
lapply :: (VectorSpace u, VectorSpace v, (Scalar u) ~ (Scalar v), HasBasis u, HasTrie (Basis u)) => (u :-* v) -> (u -> v)


-- | Infinite derivative towers via linear maps, using the Maclaurin
--   representation. See blog posts
--   <a>http://conal.net/blog/tag/derivatives/</a>.
module Data.Maclaurin

-- | Tower of derivatives.
data (:>) a b
powVal :: :> a b -> b
derivative :: :> a b -> a :-* (a :> b)

-- | Infinitely differentiable functions
type :~> a b = a -> (a :> b)

-- | Derivative tower full of <a>zeroV</a>.
dZero :: (AdditiveGroup b, HasBasis a, HasTrie (Basis a)) => a :> b

-- | Constant derivative tower.
pureD :: (AdditiveGroup b, HasBasis a, HasTrie (Basis a)) => b -> a :> b
fmapD :: (HasTrie (Basis a), VectorSpace b) => (b -> c) -> (a :> b) -> (a :> c)

-- | Map a <i>linear</i> function over a derivative tower.
(<$>>) :: (HasTrie (Basis a), VectorSpace b) => (b -> c) -> (a :> b) -> (a :> c)

-- | Apply a <i>linear</i> binary function over derivative towers.
liftD2 :: (HasTrie (Basis a), VectorSpace b, VectorSpace c, VectorSpace d) => (b -> c -> d) -> (a :> b) -> (a :> c) -> (a :> d)

-- | Apply a <i>linear</i> ternary function over derivative towers.
liftD3 :: (HasTrie (Basis a), VectorSpace b, VectorSpace c, VectorSpace d, VectorSpace e) => (b -> c -> d -> e) -> (a :> b) -> (a :> c) -> (a :> d) -> (a :> e)

-- | Differentiable identity function. Sometimes called <a>the derivation
--   variable</a> or similar, but it's not really a variable.
idD :: (VectorSpace u, s ~ (Scalar u), VectorSpace (u :> u), VectorSpace s, HasBasis u, HasTrie (Basis u)) => u :~> u

-- | Differentiable version of <a>fst</a>
fstD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), (Scalar a) ~ (Scalar b)) => (a, b) :~> a

-- | Differentiable version of <a>snd</a>
sndD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), (Scalar a) ~ (Scalar b)) => (a, b) :~> b

-- | Every linear function has a constant derivative equal to the function
--   itself (as a linear map).
linearD :: (HasBasis u, HasTrie (Basis u), VectorSpace v) => (u -> v) -> (u :~> v)

-- | Derivative tower for applying a binary function that distributes over
--   addition, such as multiplication. A bit weaker assumption than
--   bilinearity.
distrib :: (HasBasis a, HasTrie (Basis a), VectorSpace u) => (b -> c -> u) -> (a :> b) -> (a :> c) -> (a :> u)

-- | Specialized chain rule. See also '(@.)'
(>-<) :: (HasBasis a, HasTrie (Basis a), VectorSpace u) => (u -> u) -> ((a :> u) -> (a :> Scalar u)) -> (a :> u) -> (a :> u)
instance (s ~ Scalar a, Scalar s ~ s, HasBasis a, HasTrie (Basis a), Floating s, VectorSpace s) => Floating (a :> s)
instance (s ~ Scalar a, Scalar s ~ s, HasBasis a, HasTrie (Basis a), Fractional s, VectorSpace s) => Fractional (a :> s)
instance (s ~ Scalar a, Scalar s ~ s, HasBasis a, HasTrie (Basis a), Num s, VectorSpace s) => Num (a :> s)
instance (s ~ Scalar u, s ~ Scalar s, InnerSpace u, InnerSpace s, HasBasis a, HasTrie (Basis a)) => InnerSpace (a :> u)
instance (s ~ Scalar u, HasBasis a, HasTrie (Basis a), VectorSpace u) => VectorSpace (a :> u)
instance (HasBasis a, HasTrie (Basis a), VectorSpace u) => AdditiveGroup (a :> u)
instance (Ord b) => Ord (a :> b)
instance (Eq b) => Eq (a :> b)
instance (Show b) => Show (a :> b)


-- | Module indirection module. For Maclaurin- vs Horner-based derivative
--   towers.
module Data.Derivative


-- | Cross products and normals
module Data.Cross

-- | Thing with a normal vector (not necessarily normalized).
class HasNormal v
normalVec :: (HasNormal v) => v -> v

-- | Normalized normal vector. See also <tt>cross</tt>.
normal :: (HasNormal v, InnerSpace v, Floating (Scalar v)) => v -> v

-- | Singleton
type One s = s

-- | Homogeneous pair
type Two s = (s, s)

-- | Homogeneous triple
type Three s = (s, s, s)

-- | Cross product of various forms of 2D vectors
class HasCross2 v
cross2 :: (HasCross2 v) => v -> v

-- | Cross product of various forms of 3D vectors
class HasCross3 v
cross3 :: (HasCross3 v) => v -> v -> v
instance (Num s, VectorSpace s, HasBasis s, HasTrie (Basis s), HasNormal (Two s :> Three s)) => HasNormal (Three (Two s :> s))
instance (Basis s ~ (), Num s, HasTrie (Basis (s, s)), HasBasis s) => HasNormal (Two s :> Three s)
instance (HasBasis a, HasTrie (Basis a), VectorSpace v, HasCross3 v) => HasCross3 (a :> v)
instance (Num s) => HasCross3 (s, s, s)
instance (Basis s ~ (), Num s, VectorSpace s, HasBasis s, HasTrie (Basis s)) => HasNormal (Two (One s :> s))
instance (Basis s ~ (), HasBasis s, HasTrie (Basis s)) => HasNormal (One s :> Two s)
instance (HasBasis a, HasTrie (Basis a), VectorSpace v, HasCross2 v) => HasCross2 (a :> v)
instance (AdditiveGroup u) => HasCross2 (u, u)


-- | Affine spaces.
module Data.AffineSpace
class (VectorSpace (AVector p)) => AffineSpace p where { type family AVector p; }
(.-.) :: (AffineSpace p) => p -> p -> AVector p
(.+^) :: (AffineSpace p) => p -> AVector p -> p

-- | Point minus vector
(.-^) :: (AffineSpace p) => p -> AVector p -> p

-- | Square of the distance between two points. Sometimes useful for
--   efficiency. See also <a>distance</a>.
distanceSq :: (AffineSpace p, v ~ (AVector p), InnerSpace v) => p -> p -> Scalar v

-- | Distance between two points. See also <a>distanceSq</a>.
distance :: (AffineSpace p, v ~ (AVector p), InnerSpace v, s ~ (Scalar v), Floating (Scalar v)) => p -> p -> s

-- | Affine linear interpolation. Varies from <tt>p</tt> to <tt>p'</tt> as
--   <tt>s</tt> varies from 0 to 1. See also <a>lerp</a> (on vector
--   spaces).
alerp :: (AffineSpace p) => p -> p -> Scalar (AVector p) -> p
instance AffineSpace Float
instance AffineSpace Double