packages feed

vector-space 0.7.8 → 0.8.0

raw patch · 5 files changed

+22/−2 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Data.Basis: instance (s ~ Scalar u, s ~ Scalar v, HasBasis u, HasBasis v) => HasBasis (u, v)
- Data.Basis: instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, HasBasis u, HasBasis v, HasBasis w) => HasBasis (u, v, w)
- Data.Cross: instance (Basis s ~ (), HasBasis s, HasTrie (Basis s)) => HasNormal (One s :> Two s)
- Data.Cross: instance (Basis s ~ (), Num s, HasTrie (Basis (s, s)), HasBasis s) => HasNormal (Two s :> Three s)
- Data.Cross: instance (Basis s ~ (), Num s, VectorSpace s, HasBasis s, HasTrie (Basis s)) => HasNormal (Two (One s :> s))
- Data.Maclaurin: instance (s ~ Scalar a, Scalar s ~ s, HasBasis a, HasTrie (Basis a), Floating s, VectorSpace s) => Floating (a :> s)
- Data.Maclaurin: instance (s ~ Scalar a, Scalar s ~ s, HasBasis a, HasTrie (Basis a), Fractional s, VectorSpace s) => Fractional (a :> s)
- Data.Maclaurin: instance (s ~ Scalar a, Scalar s ~ s, HasBasis a, HasTrie (Basis a), Num s, VectorSpace s) => Num (a :> s)
- Data.Maclaurin: instance (s ~ Scalar u, InnerSpace u, AdditiveGroup s, HasBasis a, HasTrie (Basis a)) => InnerSpace (a :> u)
- Data.VectorSpace: instance (s ~ Scalar u, s ~ Scalar v, InnerSpace u, InnerSpace v, AdditiveGroup (Scalar v)) => InnerSpace (u, v)
- Data.VectorSpace: instance (s ~ Scalar u, s ~ Scalar v, VectorSpace u, VectorSpace v) => VectorSpace (u, v)
- Data.VectorSpace: instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, InnerSpace u, InnerSpace v, InnerSpace w, AdditiveGroup s) => InnerSpace (u, v, w)
- Data.VectorSpace: instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, VectorSpace u, VectorSpace v, VectorSpace w) => VectorSpace (u, v, w)
- Data.VectorSpace: instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, s ~ Scalar x, InnerSpace u, InnerSpace v, InnerSpace w, InnerSpace x, AdditiveGroup s) => InnerSpace (u, v, w, x)
- Data.VectorSpace: instance (s ~ Scalar u, s ~ Scalar v, s ~ Scalar w, s ~ Scalar x, VectorSpace u, VectorSpace v, VectorSpace w, VectorSpace x) => VectorSpace (u, v, w, x)
- Data.VectorSpace: instance (s ~ Scalar v, RealFloat v, InnerSpace v, AdditiveGroup s) => InnerSpace (Complex v)
+ Data.AdditiveGroup: instance Integral a => AdditiveGroup (Ratio a)
+ Data.AffineSpace: instance Integral a => AffineSpace (Ratio a)
+ Data.Basis: instance (HasBasis u, s ~ Scalar u, HasBasis v, s ~ Scalar v) => HasBasis (u, v)
+ Data.Basis: instance (HasBasis u, s ~ Scalar u, HasBasis v, s ~ Scalar v, HasBasis w, s ~ Scalar w) => HasBasis (u, v, w)
+ Data.Basis: instance Integral a => HasBasis (Ratio a)
+ Data.Cross: instance (HasBasis s, HasTrie (Basis s), Basis s ~ ()) => HasNormal (One s :> Two s)
+ Data.Cross: instance (Num s, HasTrie (Basis (s, s)), HasBasis s, Basis s ~ ()) => HasNormal (Two s :> Three s)
+ Data.Cross: instance (Num s, VectorSpace s, HasBasis s, HasTrie (Basis s), Basis s ~ ()) => HasNormal (Two (One s :> s))
+ Data.Maclaurin: instance (HasBasis a, s ~ Scalar a, HasTrie (Basis a), Floating s, VectorSpace s, Scalar s ~ s) => Floating (a :> s)
+ Data.Maclaurin: instance (HasBasis a, s ~ Scalar a, HasTrie (Basis a), Fractional s, VectorSpace s, Scalar s ~ s) => Fractional (a :> s)
+ Data.Maclaurin: instance (HasBasis a, s ~ Scalar a, HasTrie (Basis a), Num s, VectorSpace s, Scalar s ~ s) => Num (a :> s)
+ Data.Maclaurin: instance (InnerSpace u, s ~ Scalar u, AdditiveGroup s, HasBasis a, HasTrie (Basis a)) => InnerSpace (a :> u)
+ Data.VectorSpace: instance (InnerSpace u, s ~ Scalar u, InnerSpace v, s ~ Scalar v, AdditiveGroup (Scalar v)) => InnerSpace (u, v)
+ Data.VectorSpace: instance (InnerSpace u, s ~ Scalar u, InnerSpace v, s ~ Scalar v, InnerSpace w, s ~ Scalar w, AdditiveGroup s) => InnerSpace (u, v, w)
+ Data.VectorSpace: instance (InnerSpace u, s ~ Scalar u, InnerSpace v, s ~ Scalar v, InnerSpace w, s ~ Scalar w, InnerSpace x, s ~ Scalar x, AdditiveGroup s) => InnerSpace (u, v, w, x)
+ Data.VectorSpace: instance (RealFloat v, InnerSpace v, s ~ Scalar v, AdditiveGroup s) => InnerSpace (Complex v)
+ Data.VectorSpace: instance (VectorSpace u, s ~ Scalar u, VectorSpace v, s ~ Scalar v) => VectorSpace (u, v)
+ Data.VectorSpace: instance (VectorSpace u, s ~ Scalar u, VectorSpace v, s ~ Scalar v, VectorSpace w, s ~ Scalar w) => VectorSpace (u, v, w)
+ Data.VectorSpace: instance (VectorSpace u, s ~ Scalar u, VectorSpace v, s ~ Scalar v, VectorSpace w, s ~ Scalar w, VectorSpace x, s ~ Scalar x) => VectorSpace (u, v, w, x)
+ Data.VectorSpace: instance Integral a => InnerSpace (Ratio a)
+ Data.VectorSpace: instance Integral a => VectorSpace (Ratio a)
- Data.AffineSpace: class AdditiveGroup (Diff p) => AffineSpace p where { type family Diff p; }
+ Data.AffineSpace: class AdditiveGroup (Diff p) => AffineSpace p where type family Diff p
- Data.AffineSpace: distance :: (AffineSpace p, v ~ (Diff p), InnerSpace v, s ~ (Scalar v), Floating (Scalar v)) => p -> p -> s
+ Data.AffineSpace: distance :: (AffineSpace p, v ~ Diff p, InnerSpace v, s ~ Scalar v, Floating (Scalar v)) => p -> p -> s
- Data.AffineSpace: distanceSq :: (AffineSpace p, v ~ (Diff p), InnerSpace v) => p -> p -> Scalar v
+ Data.AffineSpace: distanceSq :: (AffineSpace p, v ~ Diff p, InnerSpace v) => p -> p -> Scalar v
- Data.Basis: class VectorSpace v => HasBasis v where { type family Basis v :: *; }
+ Data.Basis: class VectorSpace v => HasBasis v where type family Basis v :: *
- Data.LinearMap: (*.*) :: (HasBasis u, HasTrie (Basis u), HasBasis v, HasTrie (Basis v), VectorSpace w, (Scalar v) ~ (Scalar w)) => (v :-* w) -> (u :-* v) -> (u :-* w)
+ Data.LinearMap: (*.*) :: (HasBasis u, HasTrie (Basis u), HasBasis v, HasTrie (Basis v), VectorSpace w, Scalar v ~ Scalar w) => (v :-* w) -> (u :-* v) -> (u :-* w)
- Data.LinearMap: firstL :: (HasBasis u, HasBasis u', HasBasis v, HasTrie (Basis u), HasTrie (Basis v), (Scalar u) ~ (Scalar v), (Scalar u) ~ (Scalar u')) => (u :-* u') -> ((u, v) :-* (u', v))
+ Data.LinearMap: firstL :: (HasBasis u, HasBasis u', HasBasis v, HasTrie (Basis u), HasTrie (Basis v), Scalar u ~ Scalar v, Scalar u ~ Scalar u') => (u :-* u') -> ((u, v) :-* (u', v))
- Data.LinearMap: lapply :: (VectorSpace v, (Scalar u) ~ (Scalar v), HasBasis u, HasTrie (Basis u)) => (u :-* v) -> (u -> v)
+ Data.LinearMap: lapply :: (VectorSpace v, Scalar u ~ Scalar v, HasBasis u, HasTrie (Basis u)) => (u :-* v) -> (u -> v)
- Data.Maclaurin: fstD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), (Scalar a) ~ (Scalar b)) => (a, b) :~> a
+ Data.Maclaurin: fstD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), Scalar a ~ Scalar b) => (a, b) :~> a
- Data.Maclaurin: idD :: (VectorSpace u, s ~ (Scalar u), VectorSpace (u :> u), VectorSpace s, HasBasis u, HasTrie (Basis u)) => u :~> u
+ Data.Maclaurin: idD :: (VectorSpace u, s ~ Scalar u, VectorSpace (u :> u), VectorSpace s, HasBasis u, HasTrie (Basis u)) => u :~> u
- Data.Maclaurin: pairD :: (HasBasis a, HasTrie (Basis a), VectorSpace b, VectorSpace c, (Scalar b) ~ (Scalar c)) => (a :> b, a :> c) -> a :> (b, c)
+ Data.Maclaurin: pairD :: (HasBasis a, HasTrie (Basis a), VectorSpace b, VectorSpace c, Scalar b ~ Scalar c) => (a :> b, a :> c) -> a :> (b, c)
- Data.Maclaurin: sndD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), (Scalar a) ~ (Scalar b)) => (a, b) :~> b
+ Data.Maclaurin: sndD :: (HasBasis a, HasTrie (Basis a), HasBasis b, HasTrie (Basis b), Scalar a ~ Scalar b) => (a, b) :~> b
- Data.Maclaurin: tripleD :: (HasBasis a, HasTrie (Basis a), VectorSpace b, VectorSpace c, VectorSpace d, (Scalar b) ~ (Scalar c), (Scalar c) ~ (Scalar d)) => (a :> b, a :> c, a :> d) -> a :> (b, c, d)
+ Data.Maclaurin: tripleD :: (HasBasis a, HasTrie (Basis a), VectorSpace b, VectorSpace c, VectorSpace d, Scalar b ~ Scalar c, Scalar c ~ Scalar d) => (a :> b, a :> c, a :> d) -> a :> (b, c, d)
- Data.Maclaurin: unpairD :: (HasBasis a, HasTrie (Basis a), VectorSpace a, VectorSpace b, VectorSpace c, (Scalar b) ~ (Scalar c)) => (a :> (b, c)) -> (a :> b, a :> c)
+ Data.Maclaurin: unpairD :: (HasBasis a, HasTrie (Basis a), VectorSpace a, VectorSpace b, VectorSpace c, Scalar b ~ Scalar c) => (a :> (b, c)) -> (a :> b, a :> c)
- Data.Maclaurin: untripleD :: (HasBasis a, HasTrie (Basis a), VectorSpace a, VectorSpace b, VectorSpace c, VectorSpace d, (Scalar b) ~ (Scalar c), (Scalar c) ~ (Scalar d)) => (a :> (b, c, d)) -> (a :> b, a :> c, a :> d)
+ Data.Maclaurin: untripleD :: (HasBasis a, HasTrie (Basis a), VectorSpace a, VectorSpace b, VectorSpace c, VectorSpace d, Scalar b ~ Scalar c, Scalar c ~ Scalar d) => (a :> (b, c, d)) -> (a :> b, a :> c, a :> d)
- Data.VectorSpace: (^*) :: (VectorSpace v, s ~ (Scalar v)) => v -> s -> v
+ Data.VectorSpace: (^*) :: (VectorSpace v, s ~ Scalar v) => v -> s -> v
- Data.VectorSpace: (^/) :: (VectorSpace v, s ~ (Scalar v), Fractional s) => v -> s -> v
+ Data.VectorSpace: (^/) :: (VectorSpace v, s ~ Scalar v, Fractional s) => v -> s -> v
- Data.VectorSpace: class AdditiveGroup v => VectorSpace v where { type family Scalar v :: *; }
+ Data.VectorSpace: class AdditiveGroup v => VectorSpace v where type family Scalar v :: *
- Data.VectorSpace: magnitude :: (InnerSpace v, s ~ (Scalar v), Floating s) => v -> s
+ Data.VectorSpace: magnitude :: (InnerSpace v, s ~ Scalar v, Floating s) => v -> s
- Data.VectorSpace: magnitudeSq :: (InnerSpace v, s ~ (Scalar v)) => v -> s
+ Data.VectorSpace: magnitudeSq :: (InnerSpace v, s ~ Scalar v) => v -> s
- Data.VectorSpace: normalized :: (InnerSpace v, s ~ (Scalar v), Floating s) => v -> v
+ Data.VectorSpace: normalized :: (InnerSpace v, s ~ Scalar v, Floating s) => v -> v
- Data.VectorSpace: project :: (InnerSpace v, s ~ (Scalar v), Floating s) => v -> v -> v
+ Data.VectorSpace: project :: (InnerSpace v, s ~ Scalar v, Floating s) => v -> v -> v

Files

src/Data/AdditiveGroup.hs view
@@ -23,6 +23,7 @@ import Data.Monoid (Monoid(..)) import Data.Foldable (Foldable,foldr) import Data.Complex hiding (magnitude)+import Data.Ratio  import Data.MemoTrie @@ -58,7 +59,8 @@ instance AdditiveGroup Integer where {zeroV=0; (^+^) = (+); negateV = negate} instance AdditiveGroup Float   where {zeroV=0; (^+^) = (+); negateV = negate} instance AdditiveGroup Double  where {zeroV=0; (^+^) = (+); negateV = negate}-+instance Integral a => AdditiveGroup (Ratio a) where+  {zeroV=0; (^+^) = (+); negateV = negate}  instance (RealFloat v, AdditiveGroup v) => AdditiveGroup (Complex v) where   zeroV   = zeroV :+ zeroV
src/Data/AffineSpace.hs view
@@ -17,6 +17,7 @@   ) where  import Control.Applicative (liftA2)+import Data.Ratio  import Data.VectorSpace @@ -65,6 +66,10 @@   (.-.) =  (-)   (.+^) =  (+) +instance Integral a => AffineSpace (Ratio a) where+  type Diff (Ratio a) = Ratio a+  (.-.) = (-)+  (.+^) = (+)  instance (AffineSpace p, AffineSpace q) => AffineSpace (p,q) where   type Diff (p,q)   = (Diff p, Diff q)
src/Data/Basis.hs view
@@ -23,6 +23,7 @@  -- import Control.Applicative ((<$>)) import Control.Arrow (first)+import Data.Ratio -- import Data.Either  import Data.VectorSpace@@ -72,6 +73,12 @@   basisValue ()     = 1   decompose s       = [((),s)]   decompose' s      = const s++instance Integral a => HasBasis (Ratio a) where+  type Basis (Ratio a) = ()+  basisValue ()        = 1+  decompose s          = [((),s)]+  decompose' s         = const s  instance ( HasBasis u, s ~ Scalar u          , HasBasis v, s ~ Scalar v )
src/Data/VectorSpace.hs view
@@ -32,6 +32,7 @@  import Control.Applicative (liftA2) import Data.Complex hiding (magnitude)+import Data.Ratio  import Data.AdditiveGroup import Data.MemoTrie@@ -96,6 +97,11 @@   type Scalar Float = Float   (*^)  = (*) instance InnerSpace  Float  where (<.>) = (*)++instance Integral a => VectorSpace (Ratio a) where+  type Scalar (Ratio a) = Ratio a+  (*^) = (*)+instance Integral a => InnerSpace  (Ratio a) where (<.>) = (*)  instance (RealFloat v, VectorSpace v) => VectorSpace (Complex v) where   type Scalar (Complex v) = Scalar v
vector-space.cabal view
@@ -1,5 +1,5 @@ Name:                vector-space-Version:             0.7.8+Version:             0.8.0 Cabal-Version:       >= 1.2 Synopsis:            Vector & affine spaces, linear maps, and derivatives Category:            math