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


-- | Vector & affine spaces, linear maps, and derivatives (requires ghc 6.9)
--   
--   '''vector-space''' 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, ...).
--   
--   '''Warning''': 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.3.1


-- | 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 (u -> 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


-- | Vector spaces
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 s | v -> s
(*^) :: (VectorSpace v s) => s -> v -> v

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

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

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

-- | Linear interpolation between <tt>a</tt> (when <tt>t==0</tt>) and
--   <tt>b</tt> (when <tt>t==1</tt>).
lerp :: (VectorSpace v s, 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) => v -> s

-- | Length of a vector. See also <a>magnitudeSq</a>.
magnitude :: (InnerSpace v s, 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, Floating s) => v -> v
instance (HasTrie u, VectorSpace v s, AdditiveGroup (u :->: v)) => VectorSpace (u :->: v) s
instance (VectorSpace v s) => VectorSpace (a -> v) s
instance (InnerSpace u s, InnerSpace v s, InnerSpace w s, AdditiveGroup s) => InnerSpace (u, v, w) s
instance (VectorSpace u s, VectorSpace v s, VectorSpace w s) => VectorSpace (u, v, w) s
instance (InnerSpace u s, InnerSpace v s, AdditiveGroup s) => InnerSpace (u, v) s
instance (VectorSpace u s, VectorSpace v s) => VectorSpace (u, v) s
instance (RealFloat v, InnerSpace v s, AdditiveGroup s) => InnerSpace (Complex v) s
instance (RealFloat v, VectorSpace v s) => VectorSpace (Complex v) s
instance InnerSpace Float Float
instance VectorSpace Float Float
instance InnerSpace Double Double
instance VectorSpace Double Double


-- | Basis of a vector space, as an associated type
module Data.Basis
class (VectorSpace v s) => HasBasis v s where { type family Basis v :: *; }
basisValue :: (HasBasis v s) => Basis v -> v
decompose :: (HasBasis v s) => v -> [(s, Basis v)]
instance (HasBasis u s, HasBasis v s, HasBasis w s) => HasBasis (u, v, w) s
instance (HasBasis u s, HasBasis v s) => HasBasis (u, v) s
instance HasBasis Double Double
instance HasBasis Float Float


-- | Linear maps
module Data.LinearMap

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

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

-- | Apply a linear map to a vector.
lapply :: (VectorSpace u s, VectorSpace v s, HasBasis u s, 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 s, HasTrie (Basis a)) => a :> b

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

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

-- | Apply a <i>linear</i> binary function over derivative towers.
liftD2 :: (HasTrie (Basis a), VectorSpace b s, VectorSpace c s, VectorSpace d s) => (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 s, VectorSpace c s, VectorSpace d s, VectorSpace e s) => (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, VectorSpace (u :> u) (u :> s), VectorSpace s s, HasBasis u s, HasTrie (Basis u)) => u :~> u

-- | Every linear function has a constant derivative equal to the function
--   itself (as a linear map).
linearD :: (HasBasis u s, HasTrie (Basis u), VectorSpace v s, VectorSpace s s) => (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 s, HasTrie (Basis a), VectorSpace b s, VectorSpace c s, VectorSpace u s) => (b -> c -> u) -> (a :> b) -> (a :> c) -> (a :> u)

-- | Specialized chain rule. See also '(@.)'
(>-<) :: (HasBasis a s, HasTrie (Basis a), VectorSpace s s, VectorSpace u s) => (u -> u) -> ((a :> u) -> (a :> s)) -> (a :> u) -> (a :> u)
(**^) :: (HasBasis a s, HasTrie (Basis a), VectorSpace c s, VectorSpace s s) => (a :> s) -> (a :> c) -> (a :> c)
(<*.>) :: (HasBasis a s, HasTrie (Basis a), InnerSpace b s, VectorSpace s s) => (a :> b) -> (a :> b) -> (a :> s)
instance (HasBasis a s, HasTrie (Basis a), Floating s, VectorSpace s s) => Floating (a :> s)
instance (HasBasis a s, HasTrie (Basis a), Fractional s, VectorSpace s s) => Fractional (a :> s)
instance (HasBasis a s, HasTrie (Basis a), Num s, VectorSpace s s) => Num (a :> s)
instance (InnerSpace u s, InnerSpace s s', VectorSpace s s, HasBasis a s, HasTrie (Basis a)) => InnerSpace (a :> u) (a :> s)
instance (HasBasis a s, HasTrie (Basis a), VectorSpace u s, VectorSpace s s) => VectorSpace (a :> u) (a :> s)
instance (HasBasis a s, HasTrie (Basis a), VectorSpace u s) => 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 s, Floating s) => 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 s, HasBasis s 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 s) => HasNormal (Two s :> Three s)
instance (HasBasis a s, HasTrie (Basis a), VectorSpace v s, HasCross3 v) => HasCross3 (a :> v)
instance (Num s) => HasCross3 (s, s, s)
instance (Basis s ~ (), Num s, VectorSpace s s, HasBasis s s, HasTrie (Basis s)) => HasNormal (Two (One s :> s))
instance (Basis s ~ (), HasBasis s s, HasTrie (Basis s)) => HasNormal (One s :> Two s)
instance (HasBasis a s, HasTrie (Basis a), VectorSpace v s, HasCross2 v) => HasCross2 (a :> v)
instance (AdditiveGroup u) => HasCross2 (u, u)


-- | Affine spaces.
module Data.AffineSpace
class (VectorSpace v s) => AffineSpace p v s | p -> v s
(.-.) :: (AffineSpace p v s) => p -> p -> v
(.+^) :: (AffineSpace p v s) => p -> v -> p

-- | Point minus vector
(.-^) :: (Num s, AffineSpace p v s) => p -> v -> p

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

-- | Distance between two points. See also <a>distanceSq</a>.
distance :: (Floating s, AffineSpace p v s, InnerSpace v s) => 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 v s) => p -> p -> s -> p
instance AffineSpace Float Float Float
instance AffineSpace Double Double Double