Vec 0.9.7 → 0.9.8

raw patch · 4 files changed

+12/−5 lines, 4 filesdep ~QuickCheckPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: QuickCheck

API changes (from Hackage documentation)

- Data.Vec.Base: instance [overlap ok] (Access n a v) => Access (Succ n) a (a :. v)

- Data.Vec.Base: instance [overlap ok] (Append (a' :. v1) v2 v3) => Append (a :. (a' :. v1)) v2 (a :. v3)

- Data.Vec.Base: instance [overlap ok] (Arbitrary a) => Arbitrary (a :. ())

- Data.Vec.Base: instance [overlap ok] (Drop n (a :. v) v') => Drop (Succ n) (a :. (a :. v)) v'

- Data.Vec.Base: instance [overlap ok] (Fold (a' :. u) a) => Fold (a :. (a' :. u)) a

- Data.Vec.Base: instance [overlap ok] (Last (a' :. v) a) => Last (a :. (a' :. v)) a

- Data.Vec.Base: instance [overlap ok] (Length v n) => Length (a :. v) (Succ n)

- Data.Vec.Base: instance [overlap ok] (Map a b (a' :. u) (b' :. v)) => Map a b (a :. (a' :. u)) (b :. (b' :. v))

- Data.Vec.Base: instance [overlap ok] (Reverse' (a :. p) v v') => Reverse' p (a :. v) v'

- Data.Vec.Base: instance [overlap ok] (Snoc v a (a :. v)) => Snoc (a :. v) a (a :. (a :. v))

- Data.Vec.Base: instance [overlap ok] (Storable a) => Storable (a :. ())

- Data.Vec.Base: instance [overlap ok] (Take n v v') => Take (Succ n) (a :. v) (a :. v')

- Data.Vec.Base: instance [overlap ok] (Vec (Succ n) a (a' :. v)) => Vec (Succ (Succ n)) a (a :. (a' :. v))

- Data.Vec.Base: instance [overlap ok] (VecArrayRW (Double :. v)) => VecArrayRW (Double :. (Double :. v))

- Data.Vec.Base: instance [overlap ok] (VecArrayRW (Float :. v)) => VecArrayRW (Float :. (Float :. v))

- Data.Vec.Base: instance [overlap ok] (VecArrayRW (Int :. v)) => VecArrayRW (Int :. (Int :. v))

- Data.Vec.Base: instance [overlap ok] (VecArrayRW (Word8 :. v)) => VecArrayRW (Word8 :. (Word8 :. v))

- Data.Vec.Base: instance [overlap ok] (VecArrayRW (a :. v)) => IArray UArray (a :. v)

- Data.Vec.Base: instance [overlap ok] (VecArrayRW (a :. v)) => MArray (STUArray s) (a :. v) (ST s)

- Data.Vec.Base: instance [overlap ok] (VecList a (a' :. v)) => VecList a (a :. (a' :. v))

- Data.Vec.Base: instance [overlap ok] (ZipWith a b c (a' :. u) (b' :. v) (c' :. w)) => ZipWith a b c (a :. (a' :. u)) (b :. (b' :. v)) (c :. (c' :. w))

- Data.Vec.LinAlg: instance [overlap ok] (NearZero a) => BackSubstitute ((a :. r) :. ())

- Data.Vec.LinAlg: instance [overlap ok] (Transpose' vs vs') => Transpose' (() :. vs) vs'

- Data.Vec.Nat: instance [overlap ok] (Nat a) => Nat (Succ a)

- Data.Vec.Nat: instance [overlap ok] (Pred (Succ n) p) => Pred (Succ (Succ n)) (Succ p)

+ Data.Vec.Base: instance [overlap ok] (Length (a :. v) (Succ n), CoArbitrary a', CoArbitrary (a :. v)) => CoArbitrary (a' :. (a :. v))

+ Data.Vec.Base: instance [overlap ok] Access n a v => Access (Succ n) a (a :. v)

+ Data.Vec.Base: instance [overlap ok] Append (a' :. v1) v2 v3 => Append (a :. (a' :. v1)) v2 (a :. v3)

+ Data.Vec.Base: instance [overlap ok] Arbitrary a => Arbitrary (a :. ())

+ Data.Vec.Base: instance [overlap ok] CoArbitrary a => CoArbitrary (a :. ())

+ Data.Vec.Base: instance [overlap ok] Drop n (a :. v) v' => Drop (Succ n) (a :. (a :. v)) v'

+ Data.Vec.Base: instance [overlap ok] Fold (a' :. u) a => Fold (a :. (a' :. u)) a

+ Data.Vec.Base: instance [overlap ok] Last (a' :. v) a => Last (a :. (a' :. v)) a

+ Data.Vec.Base: instance [overlap ok] Length v n => Length (a :. v) (Succ n)

+ Data.Vec.Base: instance [overlap ok] Map a b (a' :. u) (b' :. v) => Map a b (a :. (a' :. u)) (b :. (b' :. v))

+ Data.Vec.Base: instance [overlap ok] Reverse' (a :. p) v v' => Reverse' p (a :. v) v'

+ Data.Vec.Base: instance [overlap ok] Snoc v a (a :. v) => Snoc (a :. v) a (a :. (a :. v))

+ Data.Vec.Base: instance [overlap ok] Storable a => Storable (a :. ())

+ Data.Vec.Base: instance [overlap ok] Take n v v' => Take (Succ n) (a :. v) (a :. v')

+ Data.Vec.Base: instance [overlap ok] Vec (Succ n) a (a' :. v) => Vec (Succ (Succ n)) a (a :. (a' :. v))

+ Data.Vec.Base: instance [overlap ok] VecArrayRW (Double :. v) => VecArrayRW (Double :. (Double :. v))

+ Data.Vec.Base: instance [overlap ok] VecArrayRW (Float :. v) => VecArrayRW (Float :. (Float :. v))

+ Data.Vec.Base: instance [overlap ok] VecArrayRW (Int :. v) => VecArrayRW (Int :. (Int :. v))

+ Data.Vec.Base: instance [overlap ok] VecArrayRW (Word8 :. v) => VecArrayRW (Word8 :. (Word8 :. v))

+ Data.Vec.Base: instance [overlap ok] VecArrayRW (a :. v) => IArray UArray (a :. v)

+ Data.Vec.Base: instance [overlap ok] VecArrayRW (a :. v) => MArray (STUArray s) (a :. v) (ST s)

+ Data.Vec.Base: instance [overlap ok] VecList a (a' :. v) => VecList a (a :. (a' :. v))

+ Data.Vec.Base: instance [overlap ok] ZipWith a b c (a' :. u) (b' :. v) (c' :. w) => ZipWith a b c (a :. (a' :. u)) (b :. (b' :. v)) (c :. (c' :. w))

+ Data.Vec.LinAlg: instance [overlap ok] NearZero a => BackSubstitute ((a :. r) :. ())

+ Data.Vec.LinAlg: instance [overlap ok] Transpose' vs vs' => Transpose' (() :. vs) vs'

+ Data.Vec.Nat: instance [overlap ok] Nat a => Nat (Succ a)

+ Data.Vec.Nat: instance [overlap ok] Pred (Succ n) p => Pred (Succ (Succ n)) (Succ p)

+ Data.Vec.Packed: instance [overlap ok] (CoArbitrary v, PackedVec v) => CoArbitrary (Packed v)

- Data.Vec.Base: append :: (Append v1 v2 v3) => v1 -> v2 -> v3

+ Data.Vec.Base: append :: Append v1 v2 v3 => v1 -> v2 -> v3

- Data.Vec.Base: drop :: (Drop n v v') => n -> v -> v'

+ Data.Vec.Base: drop :: Drop n v v' => n -> v -> v'

- Data.Vec.Base: fold :: (Fold v a) => (a -> a -> a) -> v -> a

+ Data.Vec.Base: fold :: Fold v a => (a -> a -> a) -> v -> a

- Data.Vec.Base: foldl :: (Fold v a) => (b -> a -> b) -> b -> v -> b

+ Data.Vec.Base: foldl :: Fold v a => (b -> a -> b) -> b -> v -> b

- Data.Vec.Base: foldr :: (Fold v a) => (a -> b -> b) -> b -> v -> b

+ Data.Vec.Base: foldr :: Fold v a => (a -> b -> b) -> b -> v -> b

- Data.Vec.Base: fromList :: (VecList a v) => [a] -> v

+ Data.Vec.Base: fromList :: VecList a v => [a] -> v

- Data.Vec.Base: get :: (Access n a v) => n -> v -> a

+ Data.Vec.Base: get :: Access n a v => n -> v -> a

- Data.Vec.Base: getElem :: (VecList a v) => Int -> v -> a

+ Data.Vec.Base: getElem :: VecList a v => Int -> v -> a

- Data.Vec.Base: head :: (Head v a) => v -> a

+ Data.Vec.Base: head :: Head v a => v -> a

- Data.Vec.Base: init# :: (VecArrayRW v) => v

+ Data.Vec.Base: init# :: VecArrayRW v => v

- Data.Vec.Base: last :: (Last v a) => v -> a

+ Data.Vec.Base: last :: Last v a => v -> a

- Data.Vec.Base: length :: (Length v n) => v -> Int

+ Data.Vec.Base: length :: Length v n => v -> Int

- Data.Vec.Base: map :: (Map a b u v) => (a -> b) -> u -> v

+ Data.Vec.Base: map :: Map a b u v => (a -> b) -> u -> v

- Data.Vec.Base: mkVec :: (Vec n a v) => n -> a -> v

+ Data.Vec.Base: mkVec :: Vec n a v => n -> a -> v

- Data.Vec.Base: reverse :: (Reverse' () v v') => v -> v'

+ Data.Vec.Base: reverse :: Reverse' () v v' => v -> v'

- Data.Vec.Base: reverse' :: (Reverse' p v v') => p -> v -> v'

+ Data.Vec.Base: reverse' :: Reverse' p v v' => p -> v -> v'

- Data.Vec.Base: set :: (Access n a v) => n -> a -> v -> v

+ Data.Vec.Base: set :: Access n a v => n -> a -> v -> v

- Data.Vec.Base: setElem :: (VecList a v) => Int -> a -> v -> v

+ Data.Vec.Base: setElem :: VecList a v => Int -> a -> v -> v

- Data.Vec.Base: showVec :: (ShowVec v) => v -> String

+ Data.Vec.Base: showVec :: ShowVec v => v -> String

- Data.Vec.Base: sizeOf# :: (Storable a) => a -> Int#

+ Data.Vec.Base: sizeOf# :: Storable a => a -> Int#

- Data.Vec.Base: snoc :: (Snoc v a v') => v -> a -> v'

+ Data.Vec.Base: snoc :: Snoc v a v' => v -> a -> v'

- Data.Vec.Base: tail :: (Tail v v_) => v -> v_

+ Data.Vec.Base: tail :: Tail v v_ => v -> v_

- Data.Vec.Base: take :: (Take n v v') => n -> v -> v'

+ Data.Vec.Base: take :: Take n v v' => n -> v -> v'

- Data.Vec.Base: toList :: (Fold v a) => v -> [a]

+ Data.Vec.Base: toList :: Fold v a => v -> [a]

- Data.Vec.Base: vaIndex# :: (VecArrayRW v) => ByteArray# -> Int# -> v

+ Data.Vec.Base: vaIndex# :: VecArrayRW v => ByteArray# -> Int# -> v

- Data.Vec.Base: vaLength# :: (VecArrayRW v) => v -> Int#

+ Data.Vec.Base: vaLength# :: VecArrayRW v => v -> Int#

- Data.Vec.Base: vaRead# :: (VecArrayRW v) => MutableByteArray# s# -> Int# -> State# s# -> (# State# s#, v #)

+ Data.Vec.Base: vaRead# :: VecArrayRW v => MutableByteArray# s# -> Int# -> State# s# -> (# State# s#, v #)

- Data.Vec.Base: vaSizeOf# :: (VecArrayRW v) => v -> Int#

+ Data.Vec.Base: vaSizeOf# :: VecArrayRW v => v -> Int#

- Data.Vec.Base: vaWrite# :: (VecArrayRW v) => MutableByteArray# s# -> Int# -> v -> State# s# -> State# s#

+ Data.Vec.Base: vaWrite# :: VecArrayRW v => MutableByteArray# s# -> Int# -> v -> State# s# -> State# s#

- Data.Vec.Base: vec :: (Vec n a v) => a -> v

+ Data.Vec.Base: vec :: Vec n a v => a -> v

- Data.Vec.Base: zipWith :: (ZipWith a b c u v w) => (a -> b -> c) -> u -> v -> w

+ Data.Vec.Base: zipWith :: ZipWith a b c u v w => (a -> b -> c) -> u -> v -> w

- Data.Vec.LinAlg: cross :: (Num a) => Vec3 a -> Vec3 a -> Vec3 a

+ Data.Vec.LinAlg: cross :: Num a => Vec3 a -> Vec3 a -> Vec3 a

- Data.Vec.LinAlg: gaussElim :: (GaussElim a m) => m -> (m, a)

+ Data.Vec.LinAlg: gaussElim :: GaussElim a m => m -> (m, a)

- Data.Vec.LinAlg: row :: (Access n a v) => n -> v -> a

+ Data.Vec.LinAlg: row :: Access n a v => n -> v -> a

- Data.Vec.LinAlg: transpose :: (Transpose a b) => a -> b

+ Data.Vec.LinAlg: transpose :: Transpose a b => a -> b

- Data.Vec.Nat: nat :: (Nat n) => n -> Int

+ Data.Vec.Nat: nat :: Nat n => n -> Int

- Data.Vec.Packed: pack :: (PackedVec v) => v -> Packed v

+ Data.Vec.Packed: pack :: PackedVec v => v -> Packed v

- Data.Vec.Packed: unpack :: (PackedVec v) => Packed v -> v

+ Data.Vec.Packed: unpack :: PackedVec v => Packed v -> v

Files

Data/Vec.hs +3/−1
Data/Vec/Base.hs +4/−2
Data/Vec/Packed.hs +3/−0
Vec.cabal +2/−2

Data/Vec.hs view

@@ -29,7 +29,9 @@  Scott E. Dillard <sedillard@gmail.com> -darcs : <http://graphics.cs.ucdavis.edu/~sdillard/Vec>+The darcs repository is at <http://graphics.cs.ucdavis.edu/~sdillard/Vec>++Some examples can be found at <http://graphics.cs.ucdavis.edu/~sdillard/Vec/examples>  /Synopsis/

Data/Vec/Base.hs view

@@ -562,14 +562,16 @@  instance Arbitrary a => Arbitrary (a:.()) where   arbitrary = arbitrary >>= return . (:.())++instance CoArbitrary a => CoArbitrary (a:.()) where   coarbitrary (a:._) = variant 0 . coarbitrary a  instance (Length (a:.v) (Succ n), Arbitrary a', Arbitrary (a:.v)) => Arbitrary (a':.a:.v) where   arbitrary = arbitrary >>= \a ->                arbitrary >>= \v -> return (a:.v);-  coarbitrary (a:.v) = variant (length v) . coarbitrary a . coarbitrary v -+instance (Length (a:.v) (Succ n), CoArbitrary a', CoArbitrary (a:.v)) => CoArbitrary (a':.a:.v) where+  coarbitrary (a:.v) = variant (length v) . coarbitrary a . coarbitrary v  --- UArray instances

Data/Vec/Packed.hs view

@@ -270,6 +270,9 @@ instance (Arbitrary v, PackedVec v) => Arbitrary (Packed v)   where   arbitrary = arbitrary >>= return . pack++instance (CoArbitrary v, PackedVec v) => CoArbitrary (Packed v)+  where   coarbitrary v = coarbitrary (unpack v)

Vec.cabal view

@@ -1,5 +1,5 @@ Name:                Vec-Version:             0.9.7+Version:             0.9.8 License:             BSD3 License-file:        LICENSE Author:              Scott E. Dillard@@ -20,7 +20,7 @@ Category:            Data,Math  library-    Build-Depends:      base<=5,QuickCheck<2,array,ghc-prim+    Build-Depends:      base<=5,QuickCheck>=2&&<3,array,ghc-prim      Exposed-modules:    Data.Vec                          Data.Vec.Base,