free-vector-spaces 0.1.0.0 → 0.1.1.0

raw patch · 2 files changed

+91/−12 lines, 2 filesdep +vectorPVP ok

version bump matches the API change (PVP)

Dependencies added: vector

API changes (from Hackage documentation)

Files

• Data/VectorSpace/Free.hs +86/−10
• free-vector-spaces.cabal +5/−2

@@ -7,18 +7,26 @@ -- Stability   : experimental -- Portability : portable -- -{-# LANGUAGE TypeFamilies      #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE FlexibleContexts  #-}-{-# LANGUAGE CPP               #-}+{-# LANGUAGE TypeFamilies         #-}+{-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE FlexibleContexts     #-}+{-# LANGUAGE CPP                  #-} -module Data.VectorSpace.Free ( module Linear.V0-                             , module Linear.V1-                             , module Linear.V2-                             , module Linear.V3-                             , module Linear.V4+module Data.VectorSpace.Free (+                             -- * Supported types+                             -- | These come from the <http://hackage.haskell.org/package/linear/ linear> package.+                               V0+                             , V1+                             , V2+                             , V3+                             , V4+                             -- * The vector-space type classes+                             -- ** General+                             -- | These come from the <http://hackage.haskell.org/package/vector-space/ vector-space> package.                              , AffineSpace(..), AdditiveGroup(..)-                             , VectorSpace(..), InnerSpace(..) +                             , VectorSpace(..), InnerSpace(..), HasBasis(..)+                             -- ** Free+                             , FiniteFreeSpace(..)                              ) where  import Data.AffineSpace@@ -37,6 +45,8 @@  import Control.Lens +import qualified Data.Vector.Unboxed as UArr+ vDecomp :: FoldableWithIndex (L.E v) v => v s -> [(L.E v, s)] vDecomp = ifoldr (\b s l -> (b,s):l) [] @@ -104,3 +114,69 @@   trie f = V4T $ V4 (f L.ex) (f L.ey) (f L.ez) (f L.ew)   untrie (V4T v) (L.E i) = v^.i   enumerate (V4T (V4 x y z w)) = [(L.ex, x), (L.ey, y), (L.ez, z), (L.ew, w)]++++++class (VectorSpace v, Num (Scalar v)) => FiniteFreeSpace v where+  {-# MINIMAL freeDimension, toFullUnboxVect, unsafeFromFullUnboxVect #-}+  freeDimension :: Functor p => p v -> Int+  toFullUnboxVect :: UArr.Unbox (Scalar v) => v -> UArr.Vector (Scalar v)+  unsafeFromFullUnboxVect :: UArr.Unbox (Scalar v) => UArr.Vector (Scalar v) -> v+  fromUnboxVect :: UArr.Unbox (Scalar v) => UArr.Vector (Scalar v) -> v+  fromUnboxVect v = result+   where result = case UArr.length v of+           0        -> zeroV+           n | n<d  -> unsafeFromFullUnboxVect $ v UArr.++ UArr.replicate (d-n) 0+         d = freeDimension [result]+++instance FiniteFreeSpace Int where+  freeDimension _ = 1+  toFullUnboxVect = UArr.singleton+  unsafeFromFullUnboxVect v = UArr.unsafeIndex v 0+instance FiniteFreeSpace Float where+  freeDimension _ = 1+  toFullUnboxVect = UArr.singleton+  unsafeFromFullUnboxVect v = UArr.unsafeIndex v 0+instance FiniteFreeSpace Double where+  freeDimension _ = 1+  toFullUnboxVect = UArr.singleton+  unsafeFromFullUnboxVect v = UArr.unsafeIndex v 0++instance (FiniteFreeSpace u, FiniteFreeSpace v, Scalar u ~ Scalar v)+      => FiniteFreeSpace (u,v) where+  freeDimension puv = freeDimension (fmap fst puv) + freeDimension (fmap snd puv)+  toFullUnboxVect (u,v) = toFullUnboxVect u UArr.++ toFullUnboxVect v+  unsafeFromFullUnboxVect uv = (u,v)+   where u = unsafeFromFullUnboxVect uv+         v = unsafeFromFullUnboxVect $ UArr.drop du uv+         du = freeDimension [u]++instance Num s => FiniteFreeSpace (V0 s) where+  freeDimension _ = 0+  toFullUnboxVect _ = UArr.empty+  unsafeFromFullUnboxVect _ = zeroV+instance Num s => FiniteFreeSpace (V1 s) where+  freeDimension _ = 1+  toFullUnboxVect (V1 n) = UArr.singleton n+  unsafeFromFullUnboxVect v = V1 $ UArr.unsafeIndex v 0+instance Num s => FiniteFreeSpace (V2 s) where+  freeDimension _ = 2+  toFullUnboxVect (V2 x y) = UArr.fromListN 2 [x,y]+  unsafeFromFullUnboxVect v = V2 (UArr.unsafeIndex v 0)+                                 (UArr.unsafeIndex v 1)+instance Num s => FiniteFreeSpace (V3 s) where+  freeDimension _ = 3+  toFullUnboxVect (V3 x y z) = UArr.fromListN 3 [x,y,z]+  unsafeFromFullUnboxVect v = V3 (UArr.unsafeIndex v 0)+                                 (UArr.unsafeIndex v 1)+                                 (UArr.unsafeIndex v 2)+instance Num s => FiniteFreeSpace (V4 s) where+  freeDimension _ = 4+  toFullUnboxVect (V4 x y z w) = UArr.fromListN 3 [x,y,z,w]+  unsafeFromFullUnboxVect v = V4 (UArr.unsafeIndex v 0)+                                 (UArr.unsafeIndex v 1)+                                 (UArr.unsafeIndex v 2)+                                 (UArr.unsafeIndex v 3)

@@ -2,7 +2,7 @@ -- documentation, see http://haskell.org/cabal/users-guide/  name:                free-vector-spaces-version:             0.1.0.0+version:             0.1.1.0 synopsis:            Instantiate the classes from the vector-space package with types from linear description:         The <http://hackage.haskell.org/package/linear/ linear> package offers efficient                      vector types — where vector means /element of a free vector space/, i.e.@@ -10,10 +10,12 @@                      this  concept of free vectors with a canonical coordinate representation.                      .                      While this is practically speaking often useful, it is also+                     .                      * Questionable in terms of conceptual elegance. The idea of a vector has                        originally not much to do with number-arrays; in physics a vector is just                        a quantity with /magnitude and direction/. Only by fixing a basis can                        a coordinate representation arise from that.+                     .                      * Not as safe as we'd like. The typical linear-algebra languages like Matlab                        or Fortran are notorious for hard-to spot mistakes that often arise from the                         total reliance on coordinate representations (every vector/linear map is just@@ -52,7 +54,8 @@                        vector-space >=0.8 && <0.13,                        MemoTrie,                        linear >=1.18 && <1.23,-                       lens >= 4 && < 5+                       lens >= 4 && < 5,+                       vector   ghc-options:         -O2   -- hs-source-dirs:         default-language:    Haskell2010