vector-space 0.10.4 → 0.19
raw patch · 9 files changed
Files
- src/Data/AdditiveGroup.hs +70/−10
- src/Data/AffineSpace.hs +77/−1
- src/Data/Basis.hs +39/−1
- src/Data/Cross.hs +2/−1
- src/Data/LinearMap.hs +2/−2
- src/Data/Maclaurin.hs +1/−1
- src/Data/VectorSpace.hs +62/−9
- src/Data/VectorSpace/Generic.hs +20/−0
- vector-space.cabal +9/−10
src/Data/AdditiveGroup.hs view
@@ -1,18 +1,22 @@ {-# LANGUAGE TypeOperators, CPP #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE ScopedTypeVariables #-} ---------------------------------------------------------------------- -- | -- Module : Data.AdditiveGroup -- Copyright : (c) Conal Elliott and Andy J Gill 2008 -- License : BSD3--- +-- -- Maintainer : conal@conal.net, andygill@ku.edu -- Stability : experimental--- +-- -- Groups: zero, addition, and negation (additive inverse) ---------------------------------------------------------------------- module Data.AdditiveGroup- ( + ( AdditiveGroup(..), sumV , Sum(..), inSum, inSum2 ) where@@ -27,20 +31,36 @@ import Data.Foldable (foldr) import Data.Complex hiding (magnitude) import Data.Ratio+#if !(MIN_VERSION_base(4,11,0))+import Data.Semigroup (Semigroup(..))+#endif import Foreign.C.Types (CSChar, CInt, CShort, CLong, CLLong, CIntMax, CFloat, CDouble) import Data.MemoTrie +import Data.VectorSpace.Generic+import qualified GHC.Generics as Gnrx+import GHC.Generics (Generic, (:*:)(..))+ infixl 6 ^+^, ^-^ -- | Additive group @v@. class AdditiveGroup v where -- | The zero element: identity for '(^+^)' zeroV :: v+ default zeroV :: (Generic v, AdditiveGroup (VRep v)) => v+ zeroV = Gnrx.to (zeroV :: VRep v)+ {-# INLINE zeroV #-} -- | Add vectors (^+^) :: v -> v -> v+ default (^+^) :: (Generic v, AdditiveGroup (VRep v)) => v -> v -> v+ v ^+^ v' = Gnrx.to (Gnrx.from v ^+^ Gnrx.from v' :: VRep v)+ {-# INLINE (^+^) #-} -- | Additive inverse negateV :: v -> v+ default negateV :: (Generic v, AdditiveGroup (VRep v)) => v -> v+ negateV v = Gnrx.to (negateV $ Gnrx.from v :: VRep v)+ {-# INLINE negateV #-} -- | Group subtraction (^-^) :: v -> v -> v v ^-^ v' = v ^+^ negateV v'@@ -48,6 +68,7 @@ -- | Sum over several vectors sumV :: (Foldable f, AdditiveGroup v) => f v -> v sumV = foldr (^+^) zeroV+{-# INLINE sumV #-} instance AdditiveGroup () where zeroV = ()@@ -55,7 +76,7 @@ negateV = id -- For 'Num' types:--- +-- -- instance AdditiveGroup n where {zeroV=0; (^+^) = (+); negateV = negate} #define ScalarTypeCon(con,t) \@@ -164,6 +185,7 @@ instance Functor Sum where fmap f (Sum a) = Sum (f a)+ {-# INLINE fmap #-} -- instance Applicative Sum where -- pure a = Sum a@@ -171,32 +193,40 @@ instance Applicative Sum where pure = Sum+ {-# INLINE pure #-} (<*>) = inSum2 ($)+ {-# INLINE (<*>) #-} +instance AdditiveGroup a => Semigroup (Sum a) where+ (<>) = liftA2 (^+^)+ {-# INLINE (<>) #-}+ instance AdditiveGroup a => Monoid (Sum a) where mempty = Sum zeroV- mappend = liftA2 (^+^)-+#if !(MIN_VERSION_base(4,11,0))+ mappend = (<>)+#endif -- | Application a unary function inside a 'Sum' inSum :: (a -> b) -> (Sum a -> Sum b) inSum = getSum ~> Sum+{-# INLINE inSum #-} -- | Application a binary function inside a 'Sum' inSum2 :: (a -> b -> c) -> (Sum a -> Sum b -> Sum c) inSum2 = getSum ~> inSum-+{-# INLINE inSum2 #-} instance AdditiveGroup a => AdditiveGroup (Sum a) where- zeroV = mempty- (^+^) = mappend+ zeroV = Sum zeroV+ (^+^) = (<>) negateV = inSum negateV - ---- to go elsewhere (~>) :: (a' -> a) -> (b -> b') -> ((a -> b) -> (a' -> b')) (i ~> o) f = o . f . i+{-# INLINE (~>) #-} -- result :: (b -> b') -> ((a -> b) -> (a -> b')) -- result = (.)@@ -205,3 +235,33 @@ -- argument = flip (.) -- g ~> f = result g . argument f++++instance AdditiveGroup a => AdditiveGroup (Gnrx.Rec0 a s) where+ zeroV = Gnrx.K1 zeroV+ {-# INLINE zeroV #-}+ negateV (Gnrx.K1 v) = Gnrx.K1 $ negateV v+ {-# INLINE negateV #-}+ Gnrx.K1 v ^+^ Gnrx.K1 w = Gnrx.K1 $ v ^+^ w+ {-# INLINE (^+^) #-}+ Gnrx.K1 v ^-^ Gnrx.K1 w = Gnrx.K1 $ v ^-^ w+ {-# INLINE (^-^) #-}+instance AdditiveGroup (f p) => AdditiveGroup (Gnrx.M1 i c f p) where+ zeroV = Gnrx.M1 zeroV+ {-# INLINE zeroV #-}+ negateV (Gnrx.M1 v) = Gnrx.M1 $ negateV v+ {-# INLINE negateV #-}+ Gnrx.M1 v ^+^ Gnrx.M1 w = Gnrx.M1 $ v ^+^ w+ {-# INLINE (^+^) #-}+ Gnrx.M1 v ^-^ Gnrx.M1 w = Gnrx.M1 $ v ^-^ w+ {-# INLINE (^-^) #-}+instance (AdditiveGroup (f p), AdditiveGroup (g p)) => AdditiveGroup ((f :*: g) p) where+ zeroV = zeroV :*: zeroV+ {-# INLINE zeroV #-}+ negateV (x:*:y) = negateV x :*: negateV y+ {-# INLINE negateV #-}+ (x:*:y) ^+^ (ξ:*:υ) = (x^+^ξ) :*: (y^+^υ)+ {-# INLINE (^+^) #-}+ (x:*:y) ^-^ (ξ:*:υ) = (x^-^ξ) :*: (y^-^υ)+ {-# INLINE (^-^) #-}
src/Data/AffineSpace.hs view
@@ -1,4 +1,10 @@ {-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, TypeFamilies, CPP #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE DeriveGeneric #-} ---------------------------------------------------------------------- -- | -- Module : Data.AffineSpace@@ -15,14 +21,20 @@ ( AffineSpace(..), (.-^), distanceSq, distance, alerp, affineCombo ) where-+#if !MIN_VERSION_base(4,10,0) import Control.Applicative (liftA2)+#endif import Data.Ratio import Foreign.C.Types (CSChar, CInt, CShort, CLong, CLLong, CIntMax, CFloat, CDouble) import Control.Arrow(first) import Data.VectorSpace+import Data.Basis +import Data.VectorSpace.Generic+import qualified GHC.Generics as Gnrx+import GHC.Generics (Generic, (:*:)(..))+ -- Through 0.8.4, I used the following fixities. -- -- infix 4 .+^, .-^, .-.@@ -40,10 +52,18 @@ class AdditiveGroup (Diff p) => AffineSpace p where -- | Associated vector space type Diff p+ type Diff p = GenericDiff p -- | Subtract points (.-.) :: p -> p -> Diff p+ default (.-.) :: ( Generic p, Diff p ~ GenericDiff p, AffineSpace (VRep p) )+ => p -> p -> Diff p+ p .-. q = GenericDiff+ $ (Gnrx.from p .-. (Gnrx.from q :: VRep p)) -- | Point plus vector (.+^) :: p -> Diff p -> p+ default (.+^) :: ( Generic p, Diff p ~ GenericDiff p, AffineSpace (VRep p) )+ => p -> Diff p -> p+ p .+^ GenericDiff q = Gnrx.to (Gnrx.from p .+^ q :: VRep p) -- | Point minus vector (.-^) :: AffineSpace p => p -> Diff p -> p@@ -122,3 +142,59 @@ type Diff (a -> p) = a -> Diff p (.-.) = liftA2 (.-.) (.+^) = liftA2 (.+^)++++newtype GenericDiff p = GenericDiff (Diff (VRep p))+ deriving (Generic)++instance AdditiveGroup (Diff (VRep p)) => AdditiveGroup (GenericDiff p)+instance VectorSpace (Diff (VRep p)) => VectorSpace (GenericDiff p)+instance (AdditiveGroup (Scalar (Diff (VRep p))), InnerSpace (Diff (VRep p))) => InnerSpace (GenericDiff p)+instance HasBasis (Diff (VRep p)) => HasBasis (GenericDiff p)++data AffineDiffProductSpace f g p = AffineDiffProductSpace+ !(Diff (f p)) !(Diff (g p)) deriving (Generic)+instance (AffineSpace (f p), AffineSpace (g p))+ => AdditiveGroup (AffineDiffProductSpace f g p)+instance ( AffineSpace (f p), AffineSpace (g p)+ , VectorSpace (Diff (f p)), VectorSpace (Diff (g p))+ , Scalar (Diff (f p)) ~ Scalar (Diff (g p)) )+ => VectorSpace (AffineDiffProductSpace f g p)+instance ( AdditiveGroup (Scalar (Diff (g p)))+ , AffineSpace (f p), AffineSpace (g p)+ , InnerSpace (Diff (f p)), InnerSpace (Diff (g p))+ , Scalar (Diff (f p)) ~ Scalar (Diff (g p))+ , Num (Scalar (Diff (f p))) )+ => InnerSpace (AffineDiffProductSpace f g p)+instance (AffineSpace (f p), AffineSpace (g p))+ => AffineSpace (AffineDiffProductSpace f g p) where+ type Diff (AffineDiffProductSpace f g p) = AffineDiffProductSpace f g p+ (.+^) = (^+^)+ (.-.) = (^-^)+instance ( AffineSpace (f p), AffineSpace (g p)+ , HasBasis (Diff (f p)), HasBasis (Diff (g p))+ , Scalar (Diff (f p)) ~ Scalar (Diff (g p)) )+ => HasBasis (AffineDiffProductSpace f g p) where+ type Basis (AffineDiffProductSpace f g p) = Either (Basis (Diff (f p)))+ (Basis (Diff (g p)))+ basisValue (Left bf) = AffineDiffProductSpace (basisValue bf) zeroV+ basisValue (Right bg) = AffineDiffProductSpace zeroV (basisValue bg)+ decompose (AffineDiffProductSpace vf vg)+ = map (first Left) (decompose vf) ++ map (first Right) (decompose vg)+ decompose' (AffineDiffProductSpace vf _) (Left bf) = decompose' vf bf+ decompose' (AffineDiffProductSpace _ vg) (Right bg) = decompose' vg bg+++instance AffineSpace a => AffineSpace (Gnrx.Rec0 a s) where+ type Diff (Gnrx.Rec0 a s) = Diff a+ Gnrx.K1 v .+^ w = Gnrx.K1 $ v .+^ w+ Gnrx.K1 v .-. Gnrx.K1 w = v .-. w+instance AffineSpace (f p) => AffineSpace (Gnrx.M1 i c f p) where+ type Diff (Gnrx.M1 i c f p) = Diff (f p)+ Gnrx.M1 v .+^ w = Gnrx.M1 $ v .+^ w+ Gnrx.M1 v .-. Gnrx.M1 w = v .-. w+instance (AffineSpace (f p), AffineSpace (g p)) => AffineSpace ((f :*: g) p) where+ type Diff ((f:*:g) p) = AffineDiffProductSpace f g p+ (x:*:y) .+^ AffineDiffProductSpace ξ υ = (x.+^ξ) :*: (y.+^υ)+ (x:*:y) .-. (ξ:*:υ) = AffineDiffProductSpace (x.-.ξ) (y.-.υ)
src/Data/Basis.hs view
@@ -1,5 +1,8 @@ {-# LANGUAGE TypeOperators, TypeFamilies, UndecidableInstances , FlexibleInstances, MultiParamTypeClasses, CPP #-}+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# OPTIONS_GHC -Wall -fno-warn-orphans #-} ---------------------------------------------------------------------- -- |@@ -20,23 +23,40 @@ import Control.Arrow (first) import Data.Ratio import Foreign.C.Types (CFloat, CDouble)+import Data.Kind -- import Data.Either import Data.VectorSpace +import Data.VectorSpace.Generic+import qualified GHC.Generics as Gnrx+import GHC.Generics (Generic, (:*:)(..))+ -- using associated data type instead of associated type synonym to work -- around ghc bug <http://hackage.haskell.org/trac/ghc/ticket/3038> class VectorSpace v => HasBasis v where -- | Representation of the canonical basis for @v@- type Basis v :: *+ type Basis v :: Type+ type Basis v = Basis (VRep v) -- | Interpret basis rep as a vector basisValue :: Basis v -> v+ default basisValue :: (Generic v, HasBasis (VRep v), Basis (VRep v) ~ Basis v)+ => Basis v -> v+ basisValue b = Gnrx.to (basisValue b :: VRep v) -- | Extract coordinates decompose :: v -> [(Basis v, Scalar v)]+ default decompose :: ( Generic v, HasBasis (VRep v)+ , Scalar (VRep v) ~ Scalar v, Basis (VRep v) ~ Basis v )+ => v -> [(Basis v, Scalar v)]+ decompose v = decompose (Gnrx.from v :: VRep v) -- | Experimental version. More elegant definitions, and friendly to -- infinite-dimensional vector spaces. decompose' :: v -> (Basis v -> Scalar v)+ default decompose' :: ( Generic v, HasBasis (VRep v)+ , Scalar (VRep v) ~ Scalar v, Basis (VRep v) ~ Basis v )+ => v -> Basis v -> Scalar v+ decompose' v = decompose' (Gnrx.from v :: VRep v) -- Defining property: recompose . decompose == id @@ -131,3 +151,21 @@ t4 = basisValue (Right (Left ())) :: (Float,Double,Float) -}++instance HasBasis a => HasBasis (Gnrx.Rec0 a s) where+ type Basis (Gnrx.Rec0 a s) = Basis a+ basisValue = Gnrx.K1 . basisValue+ decompose = decompose . Gnrx.unK1+ decompose' = decompose' . Gnrx.unK1+instance HasBasis (f p) => HasBasis (Gnrx.M1 i c f p) where+ type Basis (Gnrx.M1 i c f p) = Basis (f p)+ basisValue = Gnrx.M1 . basisValue+ decompose = decompose . Gnrx.unM1+ decompose' = decompose' . Gnrx.unM1+instance (HasBasis (f p), HasBasis (g p), Scalar (f p) ~ Scalar (g p))+ => HasBasis ((f :*: g) p) where+ type Basis ((f:*:g) p) = Either (Basis (f p)) (Basis (g p))+ basisValue (Left bf) = basisValue bf :*: zeroV+ basisValue (Right bg) = zeroV :*: basisValue bg+ decompose (u:*:v) = decomp2 Left u ++ decomp2 Right v+ decompose' (u:*:v) = decompose' u `either` decompose' v
src/Data/Cross.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE FlexibleInstances, FlexibleContexts, TypeOperators- , TypeFamilies, TypeSynonymInstances #-}+ , TypeFamilies, TypeSynonymInstances + , UndecidableInstances #-} {-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- |
src/Data/LinearMap.hs view
@@ -25,9 +25,9 @@ where #if !(MIN_VERSION_base(4,8,0))-import Control.Applicative (Applicative)+import Control.Applicative (Applicative, liftA2) #endif-import Control.Applicative (liftA2, liftA3)+import Control.Applicative (liftA3) import Control.Arrow (first,second) import Data.MemoTrie (HasTrie(..),(:->:))
src/Data/Maclaurin.hs view
@@ -24,7 +24,7 @@ -- Stability : experimental -- -- Infinite derivative towers via linear maps, using the Maclaurin--- representation. See blog posts <http://conal.net/blog/tag/derivatives/>.+-- representation. See blog posts <http://conal.net/blog/tag/derivative/>. ---------------------------------------------------------------------- module Data.Maclaurin
src/Data/VectorSpace.hs view
@@ -1,18 +1,21 @@ {-# LANGUAGE MultiParamTypeClasses, TypeOperators , TypeFamilies, UndecidableInstances, CPP , FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# OPTIONS_GHC -Wall #-} ---------------------------------------------------------------------- -- | -- Module : Data.VectorSpace -- Copyright : (c) Conal Elliott and Andy J Gill 2008 -- License : BSD3--- +-- -- Maintainer : conal@conal.net, andygill@ku.edu -- Stability : experimental--- +-- -- Vector spaces--- +-- -- This version uses associated types instead of fundeps and -- requires ghc-6.10 or later ----------------------------------------------------------------------@@ -20,7 +23,7 @@ -- NB: I'm attempting to replace fundeps with associated types. See -- NewVectorSpace.hs. Ran into trouble with type equality constraints not -- getting propagated. Manuel Ch is looking into it.--- +-- -- Blocking bug: http://hackage.haskell.org/trac/ghc/ticket/2448 module Data.VectorSpace@@ -29,22 +32,33 @@ , InnerSpace(..) , lerp, linearCombo, magnitudeSq, magnitude, normalized, project ) where-+#if !(MIN_VERSION_base(4,8,0)) import Control.Applicative (liftA2)+#endif import Data.Complex hiding (magnitude) import Foreign.C.Types (CSChar, CInt, CShort, CLong, CLLong, CIntMax, CFloat, CDouble) import Data.Ratio+import Data.Kind import Data.AdditiveGroup import Data.MemoTrie +import Data.VectorSpace.Generic+import qualified GHC.Generics as Gnrx+import GHC.Generics (Generic, (:*:)(..))+ infixr 7 *^ -- | Vector space @v@. class AdditiveGroup v => VectorSpace v where- type Scalar v :: *+ type Scalar v :: Type+ type Scalar v = Scalar (VRep v) -- | Scale a vector (*^) :: Scalar v -> v -> v+ default (*^) :: (Generic v, VectorSpace (VRep v), Scalar (VRep v) ~ Scalar v)+ => Scalar v -> v -> v+ μ *^ v = Gnrx.to (μ *^ Gnrx.from v :: VRep v)+ {-# INLINE (*^) #-} infixr 7 <.> @@ -52,45 +66,57 @@ class (VectorSpace v, AdditiveGroup (Scalar v)) => InnerSpace v where -- | Inner/dot product (<.>) :: v -> v -> Scalar v+ default (<.>) :: (Generic v, InnerSpace (VRep v), Scalar (VRep v) ~ Scalar v)+ => v -> v -> Scalar v+ v<.>w = (Gnrx.from v :: VRep v) <.> Gnrx.from w+ {-# INLINE (<.>) #-} infixr 7 ^/ infixl 7 ^* -- | Vector divided by scalar (^/) :: (VectorSpace v, s ~ Scalar v, Fractional s) => v -> s -> v-v ^/ s = (1/s) *^ v+v ^/ s = recip s *^ v+{-# INLINE (^/) #-} -- | Vector multiplied by scalar (^*) :: (VectorSpace v, s ~ Scalar v) => v -> s -> v (^*) = flip (*^)+{-# INLINE (^*) #-} -- | Linear interpolation between @a@ (when @t==0@) and @b@ (when @t==1@). -- lerp :: (VectorSpace v, s ~ Scalar v, Num s) => v -> v -> s -> v lerp :: VectorSpace v => v -> v -> Scalar v -> v lerp a b t = a ^+^ t *^ (b ^-^ a)+{-# INLINE lerp #-} -- | Linear combination of vectors linearCombo :: VectorSpace v => [(v,Scalar v)] -> v linearCombo ps = sumV [v ^* s | (v,s) <- ps]+{-# INLINE linearCombo #-} -- | Square of the length of a vector. Sometimes useful for efficiency. -- See also 'magnitude'. magnitudeSq :: (InnerSpace v, s ~ Scalar v) => v -> s magnitudeSq v = v <.> v+{-# INLINE magnitudeSq #-} -- | Length of a vector. See also 'magnitudeSq'. magnitude :: (InnerSpace v, s ~ Scalar v, Floating s) => v -> s magnitude = sqrt . magnitudeSq+{-# INLINE magnitude #-} --- | Vector in same direction as given one but with length of one. If--- given the zero vector, then return it.+-- | Vector in same direction as given one but with length of one.+-- Divides by zero for the zero vector. normalized :: (InnerSpace v, s ~ Scalar v, Floating s) => v -> v normalized v = v ^/ magnitude v+{-# INLINE normalized #-} -- | @project u v@ computes the projection of @v@ onto @u@. project :: (InnerSpace v, s ~ Scalar v, Fractional s) => v -> v -> v project u v = ((v <.> u) / magnitudeSq u) *^ u+{-# INLINE project #-} #define ScalarType(t) \ instance VectorSpace (t) where \@@ -215,3 +241,30 @@ -- mu <.> mv = fromMaybe zeroV (liftA2 (<.>) mu mv) -- (<.>) = (fmap.fmap) (fromMaybe zeroV) (liftA2 (<.>))+++instance VectorSpace a => VectorSpace (Gnrx.Rec0 a s) where+ type Scalar (Gnrx.Rec0 a s) = Scalar a+ μ *^ Gnrx.K1 v = Gnrx.K1 $ μ*^v+ {-# INLINE (*^) #-}+instance VectorSpace (f p) => VectorSpace (Gnrx.M1 i c f p) where+ type Scalar (Gnrx.M1 i c f p) = Scalar (f p)+ μ *^ Gnrx.M1 v = Gnrx.M1 $ μ*^v+ {-# INLINE (*^) #-}+instance (VectorSpace (f p), VectorSpace (g p), Scalar (f p) ~ Scalar (g p))+ => VectorSpace ((f :*: g) p) where+ type Scalar ((f:*:g) p) = Scalar (f p)+ μ *^ (x:*:y) = μ*^x :*: μ*^y+ {-# INLINE (*^) #-}++instance InnerSpace a => InnerSpace (Gnrx.Rec0 a s) where+ Gnrx.K1 v <.> Gnrx.K1 w = v<.>w+ {-# INLINE (<.>) #-}+instance InnerSpace (f p) => InnerSpace (Gnrx.M1 i c f p) where+ Gnrx.M1 v <.> Gnrx.M1 w = v<.>w+ {-# INLINE (<.>) #-}+instance ( InnerSpace (f p), InnerSpace (g p)+ , Scalar (f p) ~ Scalar (g p), Num (Scalar (f p)) )+ => InnerSpace ((f :*: g) p) where+ (x:*:y) <.> (ξ:*:υ) = x<.>ξ + y<.>υ+ {-# INLINE (<.>) #-}
+ src/Data/VectorSpace/Generic.hs view
@@ -0,0 +1,20 @@+-- |+-- Module : Data.VectorSpace.Generic+-- Copyright : (c) Conal Elliott and Justus Sagemüller 2017+-- License : BSD3+-- +-- Maintainer : conal@conal.net, (@) jsagemue $ uni-koeln.de+-- Stability : experimental+-- +-- Underpinnings of the type that represents vector / affine / etc. spaces+-- with GHC generics++module Data.VectorSpace.Generic where+++import qualified GHC.Generics as Gnrx++import Data.Void+++type VRep v = Gnrx.Rep v Void
vector-space.cabal view
@@ -1,6 +1,6 @@ Name: vector-space-Version: 0.10.4-Cabal-Version: >= 1.6+Version: 0.19+Cabal-Version: >= 1.10 Synopsis: Vector & affine spaces, linear maps, and derivatives Category: math Description:@@ -29,6 +29,7 @@ location: git://github.com/conal/vector-space.git Library+ default-language: Haskell2010 hs-Source-Dirs: src Extensions: Build-Depends: base<5, MemoTrie >= 0.5@@ -44,13 +45,11 @@ Data.Derivative Data.Cross Data.AffineSpace-+ Other-Modules: + Data.VectorSpace.Generic -- This library relies on type families working as well as in 6.10.- if impl(ghc < 6.10) {- buildable: False- }- ghc-options: -Wall -O2--- ghc-prof-options: -prof -auto-all ---- For ghc-options: -ddump-simpl-stats -ddump-rules -ddump-simpl -ddump-simpl-phases+ if impl(ghc < 6.10) { buildable: False }+ if !impl(ghc >= 7.6) { Build-Depends: ghc-prim >= 0.2 }+ if !impl(ghc >= 7.9) { Build-Depends: void >= 0.4 }+ if !impl(ghc >= 8.0) { Build-Depends: semigroups >= 0.16 }