hmatrix 0.10.0.0 → 0.10.0.1
raw patch · 20 files changed
+71/−54 lines, 20 filesPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
- Numeric.LinearAlgebra.Tests: instance (Monad m) => Monad (MaybeT m)
+ Numeric.LinearAlgebra.Tests: instance Monad m => Monad (MaybeT m)
- Data.Packed.Development: cmat :: (Element t) => Matrix t -> Matrix t
+ Data.Packed.Development: cmat :: Element t => Matrix t -> Matrix t
- Data.Packed.Development: createMatrix :: (Storable a) => MatrixOrder -> Int -> Int -> IO (Matrix a)
+ Data.Packed.Development: createMatrix :: Storable a => MatrixOrder -> Int -> Int -> IO (Matrix a)
- Data.Packed.Development: createVector :: (Storable a) => Int -> IO (Vector a)
+ Data.Packed.Development: createVector :: Storable a => Int -> IO (Vector a)
- Data.Packed.Development: fmat :: (Element t) => Matrix t -> Matrix t
+ Data.Packed.Development: fmat :: Element t => Matrix t -> Matrix t
- Data.Packed.Development: mat :: (Storable t) => Matrix t -> (((CInt -> CInt -> Ptr t -> t1) -> t1) -> IO b) -> IO b
+ Data.Packed.Development: mat :: Storable t => Matrix t -> (((CInt -> CInt -> Ptr t -> t1) -> t1) -> IO b) -> IO b
- Data.Packed.Development: unsafeFromForeignPtr :: (Storable a) => ForeignPtr a -> Int -> Int -> Vector a
+ Data.Packed.Development: unsafeFromForeignPtr :: Storable a => ForeignPtr a -> Int -> Int -> Vector a
- Data.Packed.Development: unsafeToForeignPtr :: (Storable a) => Vector a -> (ForeignPtr a, Int, Int)
+ Data.Packed.Development: unsafeToForeignPtr :: Storable a => Vector a -> (ForeignPtr a, Int, Int)
- Data.Packed.Development: vec :: (Storable t) => Vector t -> (((CInt -> Ptr t -> t1) -> t1) -> IO b) -> IO b
+ Data.Packed.Development: vec :: Storable t => Vector t -> (((CInt -> Ptr t -> t1) -> t1) -> IO b) -> IO b
- Data.Packed.Matrix: (><) :: (Storable a) => Int -> Int -> [a] -> Matrix a
+ Data.Packed.Matrix: (><) :: Storable a => Int -> Int -> [a] -> Matrix a
- Data.Packed.Matrix: (@@>) :: (Storable t) => Matrix t -> (Int, Int) -> t
+ Data.Packed.Matrix: (@@>) :: Storable t => Matrix t -> (Int, Int) -> t
- Data.Packed.Matrix: asColumn :: (Storable a) => Vector a -> Matrix a
+ Data.Packed.Matrix: asColumn :: Storable a => Vector a -> Matrix a
- Data.Packed.Matrix: asRow :: (Storable a) => Vector a -> Matrix a
+ Data.Packed.Matrix: asRow :: Storable a => Vector a -> Matrix a
- Data.Packed.Matrix: buildMatrix :: (Element a) => Int -> Int -> ((Int, Int) -> a) -> Matrix a
+ Data.Packed.Matrix: buildMatrix :: Element a => Int -> Int -> ((Int, Int) -> a) -> Matrix a
- Data.Packed.Matrix: class (Storable a) => Element a
+ Data.Packed.Matrix: class Storable a => Element a
- Data.Packed.Matrix: diagRect :: (Storable t) => t -> Vector t -> Int -> Int -> Matrix t
+ Data.Packed.Matrix: diagRect :: Storable t => t -> Vector t -> Int -> Int -> Matrix t
- Data.Packed.Matrix: dropColumns :: (Element t) => Int -> Matrix t -> Matrix t
+ Data.Packed.Matrix: dropColumns :: Element t => Int -> Matrix t -> Matrix t
- Data.Packed.Matrix: dropRows :: (Element t) => Int -> Matrix t -> Matrix t
+ Data.Packed.Matrix: dropRows :: Element t => Int -> Matrix t -> Matrix t
- Data.Packed.Matrix: extractRows :: (Element t) => [Int] -> Matrix t -> Matrix t
+ Data.Packed.Matrix: extractRows :: Element t => [Int] -> Matrix t -> Matrix t
- Data.Packed.Matrix: flatten :: (Element t) => Matrix t -> Vector t
+ Data.Packed.Matrix: flatten :: Element t => Matrix t -> Vector t
- Data.Packed.Matrix: fliprl :: (Element t) => Matrix t -> Matrix t
+ Data.Packed.Matrix: fliprl :: Element t => Matrix t -> Matrix t
- Data.Packed.Matrix: flipud :: (Element t) => Matrix t -> Matrix t
+ Data.Packed.Matrix: flipud :: Element t => Matrix t -> Matrix t
- Data.Packed.Matrix: fromArray2D :: (Storable e) => Array (Int, Int) e -> Matrix e
+ Data.Packed.Matrix: fromArray2D :: Storable e => Array (Int, Int) e -> Matrix e
- Data.Packed.Matrix: fromBlocks :: (Element t) => [[Matrix t]] -> Matrix t
+ Data.Packed.Matrix: fromBlocks :: Element t => [[Matrix t]] -> Matrix t
- Data.Packed.Matrix: fromColumns :: (Element t) => [Vector t] -> Matrix t
+ Data.Packed.Matrix: fromColumns :: Element t => [Vector t] -> Matrix t
- Data.Packed.Matrix: fromLists :: (Element t) => [[t]] -> Matrix t
+ Data.Packed.Matrix: fromLists :: Element t => [[t]] -> Matrix t
- Data.Packed.Matrix: fromRows :: (Element t) => [Vector t] -> Matrix t
+ Data.Packed.Matrix: fromRows :: Element t => [Vector t] -> Matrix t
- Data.Packed.Matrix: repmat :: (Element t) => Matrix t -> Int -> Int -> Matrix t
+ Data.Packed.Matrix: repmat :: Element t => Matrix t -> Int -> Int -> Matrix t
- Data.Packed.Matrix: reshape :: (Storable t) => Int -> Vector t -> Matrix t
+ Data.Packed.Matrix: reshape :: Storable t => Int -> Vector t -> Matrix t
- Data.Packed.Matrix: subMatrix :: (Element a) => (Int, Int) -> (Int, Int) -> Matrix a -> Matrix a
+ Data.Packed.Matrix: subMatrix :: Element a => (Int, Int) -> (Int, Int) -> Matrix a -> Matrix a
- Data.Packed.Matrix: takeColumns :: (Element t) => Int -> Matrix t -> Matrix t
+ Data.Packed.Matrix: takeColumns :: Element t => Int -> Matrix t -> Matrix t
- Data.Packed.Matrix: takeDiag :: (Element t) => Matrix t -> Vector t
+ Data.Packed.Matrix: takeDiag :: Element t => Matrix t -> Vector t
- Data.Packed.Matrix: takeRows :: (Element t) => Int -> Matrix t -> Matrix t
+ Data.Packed.Matrix: takeRows :: Element t => Int -> Matrix t -> Matrix t
- Data.Packed.Matrix: toBlocks :: (Element t) => [Int] -> [Int] -> Matrix t -> [[Matrix t]]
+ Data.Packed.Matrix: toBlocks :: Element t => [Int] -> [Int] -> Matrix t -> [[Matrix t]]
- Data.Packed.Matrix: toBlocksEvery :: (Element t) => Int -> Int -> Matrix t -> [[Matrix t]]
+ Data.Packed.Matrix: toBlocksEvery :: Element t => Int -> Int -> Matrix t -> [[Matrix t]]
- Data.Packed.Matrix: toColumns :: (Element t) => Matrix t -> [Vector t]
+ Data.Packed.Matrix: toColumns :: Element t => Matrix t -> [Vector t]
- Data.Packed.Matrix: toLists :: (Element t) => Matrix t -> [[t]]
+ Data.Packed.Matrix: toLists :: Element t => Matrix t -> [[t]]
- Data.Packed.Matrix: toRows :: (Element t) => Matrix t -> [Vector t]
+ Data.Packed.Matrix: toRows :: Element t => Matrix t -> [Vector t]
- Data.Packed.ST: freezeMatrix :: (Storable t) => STMatrix s1 t -> ST s2 (Matrix t)
+ Data.Packed.ST: freezeMatrix :: Storable t => STMatrix s1 t -> ST s2 (Matrix t)
- Data.Packed.ST: freezeVector :: (Storable t) => STVector s1 t -> ST s2 (Vector t)
+ Data.Packed.ST: freezeVector :: Storable t => STVector s1 t -> ST s2 (Vector t)
- Data.Packed.ST: liftSTMatrix :: (Storable t) => (Matrix t -> a) -> STMatrix s1 t -> ST s2 a
+ Data.Packed.ST: liftSTMatrix :: Storable t => (Matrix t -> a) -> STMatrix s1 t -> ST s2 a
- Data.Packed.ST: liftSTVector :: (Storable t) => (Vector t -> a) -> STVector s1 t -> ST s2 a
+ Data.Packed.ST: liftSTVector :: Storable t => (Vector t -> a) -> STVector s1 t -> ST s2 a
- Data.Packed.ST: modifyMatrix :: (Storable t) => STMatrix s t -> Int -> Int -> (t -> t) -> ST s ()
+ Data.Packed.ST: modifyMatrix :: Storable t => STMatrix s t -> Int -> Int -> (t -> t) -> ST s ()
- Data.Packed.ST: modifyVector :: (Storable t) => STVector s t -> Int -> (t -> t) -> ST s ()
+ Data.Packed.ST: modifyVector :: Storable t => STVector s t -> Int -> (t -> t) -> ST s ()
- Data.Packed.ST: newMatrix :: (Storable t) => t -> Int -> Int -> ST s (STMatrix s t)
+ Data.Packed.ST: newMatrix :: Storable t => t -> Int -> Int -> ST s (STMatrix s t)
- Data.Packed.ST: newUndefinedMatrix :: (Storable t) => MatrixOrder -> Int -> Int -> ST s (STMatrix s t)
+ Data.Packed.ST: newUndefinedMatrix :: Storable t => MatrixOrder -> Int -> Int -> ST s (STMatrix s t)
- Data.Packed.ST: newUndefinedVector :: (Storable t) => Int -> ST s (STVector s t)
+ Data.Packed.ST: newUndefinedVector :: Storable t => Int -> ST s (STVector s t)
- Data.Packed.ST: newVector :: (Storable t) => t -> Int -> ST s (STVector s t)
+ Data.Packed.ST: newVector :: Storable t => t -> Int -> ST s (STVector s t)
- Data.Packed.ST: readMatrix :: (Storable t) => STMatrix s t -> Int -> Int -> ST s t
+ Data.Packed.ST: readMatrix :: Storable t => STMatrix s t -> Int -> Int -> ST s t
- Data.Packed.ST: readVector :: (Storable t) => STVector s t -> Int -> ST s t
+ Data.Packed.ST: readVector :: Storable t => STVector s t -> Int -> ST s t
- Data.Packed.ST: runSTMatrix :: (Storable t) => (forall s. ST s (STMatrix s t)) -> Matrix t
+ Data.Packed.ST: runSTMatrix :: Storable t => (forall s. ST s (STMatrix s t)) -> Matrix t
- Data.Packed.ST: runSTVector :: (Storable t) => (forall s. ST s (STVector s t)) -> Vector t
+ Data.Packed.ST: runSTVector :: Storable t => (forall s. ST s (STVector s t)) -> Vector t
- Data.Packed.ST: thawMatrix :: (Storable t) => Matrix t -> ST s (STMatrix s t)
+ Data.Packed.ST: thawMatrix :: Storable t => Matrix t -> ST s (STMatrix s t)
- Data.Packed.ST: thawVector :: (Storable t) => Vector t -> ST s (STVector s t)
+ Data.Packed.ST: thawVector :: Storable t => Vector t -> ST s (STVector s t)
- Data.Packed.ST: unsafeFreezeMatrix :: (Storable t) => STMatrix s1 t -> ST s2 (Matrix t)
+ Data.Packed.ST: unsafeFreezeMatrix :: Storable t => STMatrix s1 t -> ST s2 (Matrix t)
- Data.Packed.ST: unsafeFreezeVector :: (Storable t) => STVector s1 t -> ST s2 (Vector t)
+ Data.Packed.ST: unsafeFreezeVector :: Storable t => STVector s1 t -> ST s2 (Vector t)
- Data.Packed.ST: unsafeReadMatrix :: (Storable t) => STMatrix s t -> Int -> Int -> ST s t
+ Data.Packed.ST: unsafeReadMatrix :: Storable t => STMatrix s t -> Int -> Int -> ST s t
- Data.Packed.ST: unsafeReadVector :: (Storable t) => STVector s t -> Int -> ST s t
+ Data.Packed.ST: unsafeReadVector :: Storable t => STVector s t -> Int -> ST s t
- Data.Packed.ST: unsafeThawMatrix :: (Storable t) => Matrix t -> ST s (STMatrix s t)
+ Data.Packed.ST: unsafeThawMatrix :: Storable t => Matrix t -> ST s (STMatrix s t)
- Data.Packed.ST: unsafeThawVector :: (Storable t) => Vector t -> ST s (STVector s t)
+ Data.Packed.ST: unsafeThawVector :: Storable t => Vector t -> ST s (STVector s t)
- Data.Packed.ST: unsafeWriteMatrix :: (Storable t) => STMatrix s t -> Int -> Int -> t -> ST s ()
+ Data.Packed.ST: unsafeWriteMatrix :: Storable t => STMatrix s t -> Int -> Int -> t -> ST s ()
- Data.Packed.ST: unsafeWriteVector :: (Storable t) => STVector s t -> Int -> t -> ST s ()
+ Data.Packed.ST: unsafeWriteVector :: Storable t => STVector s t -> Int -> t -> ST s ()
- Data.Packed.ST: writeMatrix :: (Storable t) => STMatrix s t -> Int -> Int -> t -> ST s ()
+ Data.Packed.ST: writeMatrix :: Storable t => STMatrix s t -> Int -> Int -> t -> ST s ()
- Data.Packed.ST: writeVector :: (Storable t) => STVector s t -> Int -> t -> ST s ()
+ Data.Packed.ST: writeVector :: Storable t => STVector s t -> Int -> t -> ST s ()
- Data.Packed.Vector: (@>) :: (Storable t) => Vector t -> Int -> t
+ Data.Packed.Vector: (@>) :: Storable t => Vector t -> Int -> t
- Data.Packed.Vector: (|>) :: (Storable a) => Int -> [a] -> Vector a
+ Data.Packed.Vector: (|>) :: Storable a => Int -> [a] -> Vector a
- Data.Packed.Vector: buildVector :: (Storable a) => Int -> (Int -> a) -> Vector a
+ Data.Packed.Vector: buildVector :: Storable a => Int -> (Int -> a) -> Vector a
- Data.Packed.Vector: dim :: (Storable t) => Vector t -> Int
+ Data.Packed.Vector: dim :: Storable t => Vector t -> Int
- Data.Packed.Vector: foldVector :: (Storable a) => (a -> b -> b) -> b -> Vector a -> b
+ Data.Packed.Vector: foldVector :: Storable a => (a -> b -> b) -> b -> Vector a -> b
- Data.Packed.Vector: foldVectorG :: (Storable a) => (Int -> (Int -> a) -> t -> t) -> t -> Vector a -> t
+ Data.Packed.Vector: foldVectorG :: Storable a => (Int -> (Int -> a) -> t -> t) -> t -> Vector a -> t
- Data.Packed.Vector: foldVectorWithIndex :: (Storable a) => (Int -> a -> b -> b) -> b -> Vector a -> b
+ Data.Packed.Vector: foldVectorWithIndex :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
- Data.Packed.Vector: fromList :: (Storable a) => [a] -> Vector a
+ Data.Packed.Vector: fromList :: Storable a => [a] -> Vector a
- Data.Packed.Vector: join :: (Storable t) => [Vector t] -> Vector t
+ Data.Packed.Vector: join :: Storable t => [Vector t] -> Vector t
- Data.Packed.Vector: subVector :: (Storable t) => Int -> Int -> Vector t -> Vector t
+ Data.Packed.Vector: subVector :: Storable t => Int -> Int -> Vector t -> Vector t
- Data.Packed.Vector: takesV :: (Storable t) => [Int] -> Vector t -> [Vector t]
+ Data.Packed.Vector: takesV :: Storable t => [Int] -> Vector t -> [Vector t]
- Data.Packed.Vector: toList :: (Storable a) => Vector a -> [a]
+ Data.Packed.Vector: toList :: Storable a => Vector a -> [a]
- Numeric.Container: (*/) :: (Container c a) => c a -> a -> c a
+ Numeric.Container: (*/) :: Container c a => c a -> a -> c a
- Numeric.Container: (.*) :: (Container c e) => e -> c e -> c e
+ Numeric.Container: (.*) :: Container c e => e -> c e -> c e
- Numeric.Container: (<->) :: (Joinable a b, Element t) => a t -> b t -> Matrix t
+ Numeric.Container: (<->) :: (Element t, Joinable a b) => a t -> b t -> Matrix t
- Numeric.Container: (<.>) :: (Product t) => Vector t -> Vector t -> t
+ Numeric.Container: (<.>) :: Product t => Vector t -> Vector t -> t
- Numeric.Container: (<\>) :: (Field a) => Matrix a -> Vector a -> Vector a
+ Numeric.Container: (<\>) :: Field a => Matrix a -> Vector a -> Vector a
- Numeric.Container: (<|>) :: (Joinable a b, Element t) => a t -> b t -> Matrix t
+ Numeric.Container: (<|>) :: (Element t, Joinable a b) => a t -> b t -> Matrix t
- Numeric.Container: absSum :: (Product e) => Vector e -> RealOf e
+ Numeric.Container: absSum :: Product e => Vector e -> RealOf e
- Numeric.Container: add :: (Container c e) => c e -> c e -> c e
+ Numeric.Container: add :: Container c e => c e -> c e -> c e
- Numeric.Container: addConstant :: (Container c e) => e -> c e -> c e
+ Numeric.Container: addConstant :: Container c e => e -> c e -> c e
- Numeric.Container: arctan2 :: (Container c e) => c e -> c e -> c e
+ Numeric.Container: arctan2 :: Container c e => c e -> c e -> c e
- Numeric.Container: atIndex :: (Container c e) => c e -> IndexOf c -> e
+ Numeric.Container: atIndex :: Container c e => c e -> IndexOf c -> e
- Numeric.Container: build :: (Container c e) => IndexOf c -> (ArgOf c e) -> c e
+ Numeric.Container: build :: Container c e => IndexOf c -> (ArgOf c e) -> c e
- Numeric.Container: build' :: (Build f) => BoundsOf f -> f -> ContainerOf f
+ Numeric.Container: build' :: Build f => BoundsOf f -> f -> ContainerOf f
- Numeric.Container: class (Element e) => Product e
+ Numeric.Container: class Element e => Product e
- Numeric.Container: conj :: (Container c e) => c e -> c e
+ Numeric.Container: conj :: Container c e => c e -> c e
- Numeric.Container: constant :: (Element a) => a -> Int -> Vector a
+ Numeric.Container: constant :: Element a => a -> Int -> Vector a
- Numeric.Container: divide :: (Container c e) => c e -> c e -> c e
+ Numeric.Container: divide :: Container c e => c e -> c e -> c e
- Numeric.Container: dot :: (Product e) => Vector e -> Vector e -> e
+ Numeric.Container: dot :: Product e => Vector e -> Vector e -> e
- Numeric.Container: equal :: (Container c e) => c e -> c e -> Bool
+ Numeric.Container: equal :: Container c e => c e -> c e -> Bool
- Numeric.Container: format :: (Element t) => String -> (t -> String) -> Matrix t -> String
+ Numeric.Container: format :: Element t => String -> (t -> String) -> Matrix t -> String
- Numeric.Container: konst :: (Container c e) => e -> IndexOf c -> c e
+ Numeric.Container: konst :: Container c e => e -> IndexOf c -> c e
- Numeric.Container: kronecker :: (Product t) => Matrix t -> Matrix t -> Matrix t
+ Numeric.Container: kronecker :: Product t => Matrix t -> Matrix t -> Matrix t
- Numeric.Container: mXm :: (Product t) => Matrix t -> Matrix t -> Matrix t
+ Numeric.Container: mXm :: Product t => Matrix t -> Matrix t -> Matrix t
- Numeric.Container: mXv :: (Product t) => Matrix t -> Vector t -> Vector t
+ Numeric.Container: mXv :: Product t => Matrix t -> Vector t -> Vector t
- Numeric.Container: maxElement :: (Container c e) => c e -> e
+ Numeric.Container: maxElement :: Container c e => c e -> e
- Numeric.Container: maxIndex :: (Container c e) => c e -> IndexOf c
+ Numeric.Container: maxIndex :: Container c e => c e -> IndexOf c
- Numeric.Container: minElement :: (Container c e) => c e -> e
+ Numeric.Container: minElement :: Container c e => c e -> e
- Numeric.Container: minIndex :: (Container c e) => c e -> IndexOf c
+ Numeric.Container: minIndex :: Container c e => c e -> IndexOf c
- Numeric.Container: mul :: (Container c e) => c e -> c e -> c e
+ Numeric.Container: mul :: Container c e => c e -> c e -> c e
- Numeric.Container: multiply :: (Product e) => Matrix e -> Matrix e -> Matrix e
+ Numeric.Container: multiply :: Product e => Matrix e -> Matrix e -> Matrix e
- Numeric.Container: norm1 :: (Product e) => Vector e -> RealOf e
+ Numeric.Container: norm1 :: Product e => Vector e -> RealOf e
- Numeric.Container: norm2 :: (Product e) => Vector e -> RealOf e
+ Numeric.Container: norm2 :: Product e => Vector e -> RealOf e
- Numeric.Container: normInf :: (Product e) => Vector e -> RealOf e
+ Numeric.Container: normInf :: Product e => Vector e -> RealOf e
- Numeric.Container: optimiseMult :: (Product t) => [Matrix t] -> Matrix t
+ Numeric.Container: optimiseMult :: Product t => [Matrix t] -> Matrix t
- Numeric.Container: outer :: (Product t) => Vector t -> Vector t -> Matrix t
+ Numeric.Container: outer :: Product t => Vector t -> Vector t -> Matrix t
- Numeric.Container: prodElements :: (Container c e) => c e -> e
+ Numeric.Container: prodElements :: Container c e => c e -> e
- Numeric.Container: scalar :: (Container c e) => e -> c e
+ Numeric.Container: scalar :: Container c e => e -> c e
- Numeric.Container: scale :: (Container c e) => e -> c e -> c e
+ Numeric.Container: scale :: Container c e => e -> c e -> c e
- Numeric.Container: scaleRecip :: (Container c e) => e -> c e -> c e
+ Numeric.Container: scaleRecip :: Container c e => e -> c e -> c e
- Numeric.Container: sub :: (Container c e) => c e -> c e -> c e
+ Numeric.Container: sub :: Container c e => c e -> c e -> c e
- Numeric.Container: sumElements :: (Container c e) => c e -> e
+ Numeric.Container: sumElements :: Container c e => c e -> e
- Numeric.Container: vXm :: (Product t) => Vector t -> Matrix t -> Vector t
+ Numeric.Container: vXm :: Product t => Vector t -> Matrix t -> Vector t
- Numeric.Container: vecdisp :: (Element t) => (Matrix t -> String) -> Vector t -> String
+ Numeric.Container: vecdisp :: Element t => (Matrix t -> String) -> Vector t -> String
- Numeric.LinearAlgebra.Algorithms: chol :: (Field t) => Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: chol :: Field t => Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: cholSH :: (Field t) => Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: cholSH :: Field t => Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: cholSolve :: (Field t) => Matrix t -> Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: cholSolve :: Field t => Matrix t -> Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: class (RealFloat (RealOf t)) => Normed c t
+ Numeric.LinearAlgebra.Algorithms: class RealFloat (RealOf t) => Normed c t
- Numeric.LinearAlgebra.Algorithms: compactSVD :: (Field t) => Matrix t -> (Matrix t, Vector Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: compactSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: det :: (Field t) => Matrix t -> t
+ Numeric.LinearAlgebra.Algorithms: det :: Field t => Matrix t -> t
- Numeric.LinearAlgebra.Algorithms: economy :: (Element t2, Element t1, Element t) => (Matrix t -> (Matrix t1, Vector Double, Matrix t2)) -> Matrix t -> (Matrix t1, Vector Double, Matrix t2)
+ Numeric.LinearAlgebra.Algorithms: economy :: (Element t2, Element t, Element t1) => (Matrix t -> (Matrix t1, Vector Double, Matrix t2)) -> Matrix t -> (Matrix t1, Vector Double, Matrix t2)
- Numeric.LinearAlgebra.Algorithms: eig :: (Field t) => Matrix t -> (Vector (Complex Double), Matrix (Complex Double))
+ Numeric.LinearAlgebra.Algorithms: eig :: Field t => Matrix t -> (Vector (Complex Double), Matrix (Complex Double))
- Numeric.LinearAlgebra.Algorithms: eigSH :: (Field t) => Matrix t -> (Vector Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: eigSH :: Field t => Matrix t -> (Vector Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: eigSH' :: (Field t) => Matrix t -> (Vector Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: eigSH' :: Field t => Matrix t -> (Vector Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: eigenvalues :: (Field t) => Matrix t -> Vector (Complex Double)
+ Numeric.LinearAlgebra.Algorithms: eigenvalues :: Field t => Matrix t -> Vector (Complex Double)
- Numeric.LinearAlgebra.Algorithms: eigenvaluesSH :: (Field t) => Matrix t -> Vector Double
+ Numeric.LinearAlgebra.Algorithms: eigenvaluesSH :: Field t => Matrix t -> Vector Double
- Numeric.LinearAlgebra.Algorithms: eigenvaluesSH' :: (Field t) => Matrix t -> Vector Double
+ Numeric.LinearAlgebra.Algorithms: eigenvaluesSH' :: Field t => Matrix t -> Vector Double
- Numeric.LinearAlgebra.Algorithms: expm :: (Field t) => Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: expm :: Field t => Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: full :: (Storable t3, Num t3) => (Matrix t -> (t1, Vector t3, t2)) -> Matrix t -> (t1, Matrix t3, t2)
+ Numeric.LinearAlgebra.Algorithms: full :: (Num a, Storable a) => (Matrix t -> (t1, Vector a, t2)) -> Matrix t -> (t1, Matrix a, t2)
- Numeric.LinearAlgebra.Algorithms: fullSVD :: (Field t) => Matrix t -> (Matrix t, Matrix Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: fullSVD :: Field t => Matrix t -> (Matrix t, Matrix Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: haussholder :: (Field a) => a -> Vector a -> Matrix a
+ Numeric.LinearAlgebra.Algorithms: haussholder :: Field a => a -> Vector a -> Matrix a
- Numeric.LinearAlgebra.Algorithms: hess :: (Field t) => Matrix t -> (Matrix t, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: hess :: Field t => Matrix t -> (Matrix t, Matrix t)
- Numeric.LinearAlgebra.Algorithms: inv :: (Field t) => Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: inv :: Field t => Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: leftSV :: (Field t) => Matrix t -> (Matrix t, Vector Double)
+ Numeric.LinearAlgebra.Algorithms: leftSV :: Field t => Matrix t -> (Matrix t, Vector Double)
- Numeric.LinearAlgebra.Algorithms: linearSolve :: (Field t) => Matrix t -> Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: linearSolve :: Field t => Matrix t -> Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: linearSolveLS :: (Field t) => Matrix t -> Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: linearSolveLS :: Field t => Matrix t -> Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: linearSolveSVD :: (Field t) => Matrix t -> Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: linearSolveSVD :: Field t => Matrix t -> Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: lu :: (Field t) => Matrix t -> (Matrix t, Matrix t, Matrix t, t)
+ Numeric.LinearAlgebra.Algorithms: lu :: Field t => Matrix t -> (Matrix t, Matrix t, Matrix t, t)
- Numeric.LinearAlgebra.Algorithms: luPacked :: (Field t) => Matrix t -> (Matrix t, [Int])
+ Numeric.LinearAlgebra.Algorithms: luPacked :: Field t => Matrix t -> (Matrix t, [Int])
- Numeric.LinearAlgebra.Algorithms: luSolve :: (Field t) => (Matrix t, [Int]) -> Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: luSolve :: Field t => (Matrix t, [Int]) -> Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: mbCholSH :: (Field t) => Matrix t -> Maybe (Matrix t)
+ Numeric.LinearAlgebra.Algorithms: mbCholSH :: Field t => Matrix t -> Maybe (Matrix t)
- Numeric.LinearAlgebra.Algorithms: nullVector :: (Field t) => Matrix t -> Vector t
+ Numeric.LinearAlgebra.Algorithms: nullVector :: Field t => Matrix t -> Vector t
- Numeric.LinearAlgebra.Algorithms: nullspacePrec :: (Field t) => Double -> Matrix t -> [Vector t]
+ Numeric.LinearAlgebra.Algorithms: nullspacePrec :: Field t => Double -> Matrix t -> [Vector t]
- Numeric.LinearAlgebra.Algorithms: nullspaceSVD :: (Field t) => Either Double Int -> Matrix t -> (Vector Double, Matrix t) -> [Vector t]
+ Numeric.LinearAlgebra.Algorithms: nullspaceSVD :: Field t => Either Double Int -> Matrix t -> (Vector Double, Matrix t) -> [Vector t]
- Numeric.LinearAlgebra.Algorithms: peps :: (RealFloat x) => x
+ Numeric.LinearAlgebra.Algorithms: peps :: RealFloat x => x
- Numeric.LinearAlgebra.Algorithms: pinv :: (Field t) => Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: pinv :: Field t => Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: pnorm :: (Normed c t) => NormType -> c t -> RealOf t
+ Numeric.LinearAlgebra.Algorithms: pnorm :: Normed c t => NormType -> c t -> RealOf t
- Numeric.LinearAlgebra.Algorithms: qr :: (Field t) => Matrix t -> (Matrix t, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: qr :: Field t => Matrix t -> (Matrix t, Matrix t)
- Numeric.LinearAlgebra.Algorithms: rank :: (Field t) => Matrix t -> Int
+ Numeric.LinearAlgebra.Algorithms: rank :: Field t => Matrix t -> Int
- Numeric.LinearAlgebra.Algorithms: rcond :: (Field t) => Matrix t -> Double
+ Numeric.LinearAlgebra.Algorithms: rcond :: Field t => Matrix t -> Double
- Numeric.LinearAlgebra.Algorithms: rightSV :: (Field t) => Matrix t -> (Vector Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: rightSV :: Field t => Matrix t -> (Vector Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: rq :: (Field t) => Matrix t -> (Matrix t, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: rq :: Field t => Matrix t -> (Matrix t, Matrix t)
- Numeric.LinearAlgebra.Algorithms: schur :: (Field t) => Matrix t -> (Matrix t, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: schur :: Field t => Matrix t -> (Matrix t, Matrix t)
- Numeric.LinearAlgebra.Algorithms: singularValues :: (Field t) => Matrix t -> Vector Double
+ Numeric.LinearAlgebra.Algorithms: singularValues :: Field t => Matrix t -> Vector Double
- Numeric.LinearAlgebra.Algorithms: sqrtm :: (Field t) => Matrix t -> Matrix t
+ Numeric.LinearAlgebra.Algorithms: sqrtm :: Field t => Matrix t -> Matrix t
- Numeric.LinearAlgebra.Algorithms: svd :: (Field t) => Matrix t -> (Matrix t, Vector Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: svd :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: thinSVD :: (Field t) => Matrix t -> (Matrix t, Vector Double, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: thinSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)
- Numeric.LinearAlgebra.Algorithms: unpackHess :: (Field t) => (Matrix t -> (Matrix t, Vector t)) -> Matrix t -> (Matrix t, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: unpackHess :: Field t => (Matrix t -> (Matrix t, Vector t)) -> Matrix t -> (Matrix t, Matrix t)
- Numeric.LinearAlgebra.Algorithms: unpackQR :: (Field t) => (Matrix t, Vector t) -> (Matrix t, Matrix t)
+ Numeric.LinearAlgebra.Algorithms: unpackQR :: Field t => (Matrix t, Vector t) -> (Matrix t, Matrix t)
- Numeric.LinearAlgebra.Tests: qCheck :: (Testable prop) => Int -> prop -> IO ()
+ Numeric.LinearAlgebra.Tests: qCheck :: Testable prop => Int -> prop -> IO ()
Files
- THANKS +3/−1
- configure.hs +6/−2
- hmatrix.cabal +11/−3
- lib/Data/Packed/Internal/Matrix.hs +5/−3
- lib/Data/Packed/Matrix.hs +10/−11
- lib/Data/Packed/Random.hs +1/−1
- lib/Data/Packed/ST.hs +3/−2
- lib/Data/Packed/Vector.hs +10/−5
- lib/Graphics/Plot.hs +5/−5
- lib/Numeric/Chain.hs +7/−7
- lib/Numeric/Container.hs +2/−2
- lib/Numeric/ContainerBoot.hs +0/−1
- lib/Numeric/GSL/Fourier.hs +1/−1
- lib/Numeric/GSL/Minimization.hs +1/−1
- lib/Numeric/GSL/Polynomials.hs +1/−1
- lib/Numeric/GSL/Vector.hs +0/−1
- lib/Numeric/LinearAlgebra/Algorithms.hs +2/−3
- lib/Numeric/LinearAlgebra/Tests/Instances.hs +1/−1
- lib/Numeric/LinearAlgebra/Tests/Properties.hs +2/−2
- lib/Numeric/Matrix.hs +0/−1
THANKS view
@@ -77,5 +77,7 @@ - Max Suica simplified the installation on Windows and improved the instructions. -- John Billings reported an incompatibility with QuickCheck>=2.1.1+- John Billings first reported an incompatibility with QuickCheck>=2.1.1++- Alexey Khudyakov cleaned up PRAGMAS and fixed some hlint suggestions.
configure.hs view
@@ -98,10 +98,14 @@ cs x = x main = do+ info <- maybeGetPersistBuildConfig "dist"+ case info of+ Nothing -> putStrLn "Please run \"cabal clean\" first." >> exitFailure+ Just bInfo -> mainOk bInfo+ +mainOk bInfo = do putStr "Checking foreign libraries..."- args <- getArgs- Just bInfo <- maybeGetPersistBuildConfig "dist" let Just lib = library . localPkgDescr $ bInfo buildInfo = libBuildInfo lib
hmatrix.cabal view
@@ -1,5 +1,5 @@ Name: hmatrix-Version: 0.10.0.0+Version: 0.10.0.1 License: GPL License-file: LICENSE Author: Alberto Ruiz@@ -78,13 +78,16 @@ description: Use Data.Vector.Storable type from "vector" package. default: False +flag binary+ description: Define Binary instances+ default: True+ library Build-Depends: base >= 4 && < 5, array, storable-complex,- process,- binary+ process Extensions: ForeignFunctionInterface, CPP@@ -131,6 +134,10 @@ Build-Depends: vector >= 0.7 cpp-options: -DVECTOR + if flag(binary)+ Build-Depends: binary+ cpp-options: -DBINARY+ if flag(tests) Build-Depends: QuickCheck, HUnit, random exposed-modules: Numeric.LinearAlgebra.Tests@@ -176,3 +183,4 @@ source-repository head type: darcs location: http://code.haskell.org/hmatrix+
lib/Data/Packed/Internal/Matrix.hs view
@@ -1,5 +1,7 @@-{-# OPTIONS_GHC -fglasgow-exts #-}-{-# LANGUAGE CPP, BangPatterns #-}+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE BangPatterns #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Packed.Internal.Matrix@@ -158,7 +160,7 @@ -- | extracts the rows of a matrix as a list of vectors toRows :: Element t => Matrix t -> [Vector t] toRows m = toRows' 0 where- v = flatten $ m+ v = flatten m r = rows m c = cols m toRows' k | k == r*c = []
lib/Data/Packed/Matrix.hs view
@@ -2,17 +2,16 @@ {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE CPP #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Packed.Matrix -- Copyright : (c) Alberto Ruiz 2007-10--- License : GPL-style+-- License : GPL -- -- Maintainer : Alberto Ruiz <aruiz@um.es> -- Stability : provisional--- Portability : portable -- -- A Matrix representation suitable for numerical computations using LAPACK and GSL. --@@ -44,17 +43,15 @@ import qualified Data.Packed.ST as ST import Data.List(transpose,intersperse) import Data.Array+import Foreign.Storable +------------------------------------------------------------------- +#ifdef BINARY+ import Data.Binary-import Foreign.Storable import Control.Monad(replicateM)---import Control.Arrow((***))---import GHC.Float(double2Float,float2Double) ---------------------------------------------------------------------- instance (Binary a, Element a, Storable a) => Binary (Matrix a) where put m = do let r = rows m@@ -68,6 +65,8 @@ xs <- replicateM r $ replicateM c get return $ fromLists xs +#endif+ ------------------------------------------------------------------- instance (Show a, Element a) => (Show (Matrix a)) where@@ -270,7 +269,7 @@ -} buildMatrix :: Element a => Int -> Int -> ((Int, Int) -> a) -> Matrix a buildMatrix rc cc f =- fromLists $ map (\x -> map f x)+ fromLists $ map (map f) $ map (\ ri -> map (\ ci -> (ri, ci)) [0 .. (cc - 1)]) [0 .. (rc - 1)] -----------------------------------------------------@@ -284,7 +283,7 @@ -- | rearranges the rows of a matrix according to the order given in a list of integers. extractRows :: Element t => [Int] -> Matrix t -> Matrix t-extractRows l m = fromRows $ extract (toRows $ m) l+extractRows l m = fromRows $ extract (toRows m) l where extract l' is = [l'!!i |i<-is] {- | creates matrix by repetition of a matrix a given number of rows and columns
lib/Data/Packed/Random.hs view
@@ -63,4 +63,4 @@ med = konst k r `vXm` x meds = konst 1 r `outer` med xc = x `sub` meds- cov = flip scale (trans xc `mXm` xc) (recip (fromIntegral (r-1)))+ cov = scale (recip (fromIntegral (r-1))) (trans xc `mXm` xc)
lib/Data/Packed/ST.hs view
@@ -1,5 +1,6 @@-{-# OPTIONS -XTypeOperators -XRank2Types -XFlexibleContexts -XBangPatterns #-}-+{-# LANGUAGE TypeOperators #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE BangPatterns #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Packed.ST
lib/Data/Packed/Vector.hs view
@@ -1,13 +1,13 @@ {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE CPP #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Packed.Vector--- Copyright : (c) Alberto Ruiz 2007--- License : GPL-style+-- Copyright : (c) Alberto Ruiz 2007-10+-- License : GPL -- -- Maintainer : Alberto Ruiz <aruiz@um.es> -- Stability : provisional--- Portability : portable -- -- 1D arrays suitable for numeric computations using external libraries. --@@ -26,12 +26,15 @@ ) where import Data.Packed.Internal.Vector-import Data.Binary import Foreign.Storable-import Control.Monad(replicateM) ------------------------------------------------------------------- +#ifdef BINARY++import Data.Binary+import Control.Monad(replicateM)+ -- a 64K cache, with a Double taking 13 bytes in Bytestring, -- implies a chunk size of 5041 chunk :: Int@@ -59,6 +62,8 @@ d <- get vs <- mapM getVector $ chunks d return $! join vs++#endif -------------------------------------------------------------------
lib/Graphics/Plot.hs view
@@ -45,7 +45,7 @@ mesh :: Matrix Double -> IO () mesh m = gnuplotX (command++dat) where command = "splot "++datafollows++" matrix with lines\n"- dat = prep $ toLists $ m+ dat = prep $ toLists m {- | Draws the surface represented by the function f in the desired ranges and number of points, internally using 'mesh'. @@ -104,7 +104,7 @@ maxgray = 255.0 maxval = maxElement m minval = minElement m- scale' = if (maxval == minval) + scale' = if maxval == minval then 0.0 else maxgray / (maxval - minval) f x = show ( round ( scale' *(x - minval) ) :: Int )@@ -124,7 +124,7 @@ datafollows = "\\\"-\\\"" -prep = (++"e\n\n") . unlines . map (unwords . (map show))+prep = (++"e\n\n") . unlines . map (unwords . map show) gnuplotpdf :: String -> String -> [([[Double]], String)] -> IO ()@@ -158,7 +158,7 @@ "\\end{document}" - pr = (++"e\n") . unlines . map (unwords . (map show))+ pr = (++"e\n") . unlines . map (unwords . map show) gnuplot cmd = do writeFile "gnuplotcommand" cmd@@ -172,7 +172,7 @@ draw = concat (intersperse ", " (map ("\"-\" "++) defs)) ++ "\n" ++ concatMap pr dats - pr = (++"e\n") . unlines . map (unwords . (map show))+ pr = (++"e\n") . unlines . map (unwords . map show) prelude = "set title \""++title++"\";"
lib/Numeric/Chain.hs view
@@ -98,11 +98,11 @@ minimum_cost sci fu = foldl (smaller_cost fu) sci (fulcrum_order fu) smaller_cost :: (Int,Int) -> (Sizes,Cost,Indexes) -> ((Int,Int),(Int,Int)) -> (Sizes,Cost,Indexes)-smaller_cost (r,c) (mz,cost,ixes) ix@((lr,lc),(rr,rc)) = let op_cost = (fromJust ((cost A.! lr) A.! lc))- + (fromJust ((cost A.! rr) A.! rc))- + ((fst $ mz A.! (lr-lc+1))- *(snd $ mz A.! lc)- *(snd $ mz A.! rr))+smaller_cost (r,c) (mz,cost,ixes) ix@((lr,lc),(rr,rc)) = let op_cost = fromJust ((cost A.! lr) A.! lc)+ + fromJust ((cost A.! rr) A.! rc)+ + fst (mz A.! (lr-lc+1))+ * snd (mz A.! lc)+ * snd (mz A.! rr) cost' = (cost A.! r) A.! c in case cost' of Nothing -> let cost'' = update cost (r,c) (Just op_cost)@@ -118,10 +118,10 @@ fulcrum_order (r,c) = let fs' = zip (repeat r) [1..(c-1)] in map (partner (r,c)) fs' -partner (r,c) (a,b) = (((r-b),(c-b)),(a,b))+partner (r,c) (a,b) = ((r-b, c-b), (a,b)) order 0 = []-order n = (order (n-1)) ++ (zip (repeat n) [1..n])+order n = order (n-1) ++ zip (repeat n) [1..n] chain_paren :: Product a => (Int,Int) -> Indexes -> Matrices a -> Matrix a chain_paren (r,c) ixes ma = let ((lr,lc),(rr,rc)) = fromJust $ (ixes A.! r) A.! c
lib/Numeric/Container.hs view
@@ -117,10 +117,10 @@ (<>) = mXm instance Mul Matrix Vector Vector where- (<>) m v = flatten $ m <> (asColumn v)+ (<>) m v = flatten $ m <> asColumn v instance Mul Vector Matrix Vector where- (<>) v m = flatten $ (asRow v) <> m+ (<>) v m = flatten $ asRow v <> m --------------------------------------------------------
lib/Numeric/ContainerBoot.hs view
@@ -2,7 +2,6 @@ {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE UndecidableInstances #-} -----------------------------------------------------------------------------
lib/Numeric/GSL/Fourier.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts #-}+{-# LANGUAGE ForeignFunctionInterface #-} ----------------------------------------------------------------------------- {- | Module : Numeric.GSL.Fourier
lib/Numeric/GSL/Minimization.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts #-}+{-# LANGUAGE ForeignFunctionInterface #-} ----------------------------------------------------------------------------- {- | Module : Numeric.GSL.Minimization
lib/Numeric/GSL/Polynomials.hs view
@@ -1,4 +1,4 @@-{-# OPTIONS_GHC -fglasgow-exts #-}+{-# LANGUAGE ForeignFunctionInterface #-} ----------------------------------------------------------------------------- {- | Module : Numeric.GSL.Polynomials
lib/Numeric/GSL/Vector.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS_GHC -fglasgow-exts #-} ----------------------------------------------------------------------------- -- | -- Module : Numeric.GSL.Vector
lib/Numeric/LinearAlgebra/Algorithms.hs view
@@ -392,7 +392,7 @@ -- | 1 + 0.5*peps == 1, 1 + 0.6*peps /= 1 peps :: RealFloat x => x-peps = x where x = 2.0**(fromIntegral $ 1-floatDigits x)+peps = x where x = 2.0 ** fromIntegral (1 - floatDigits x) -- | The imaginary unit: @i = 0.0 :+ 1.0@@@ -553,8 +553,7 @@ geps delta = head [ k | (k,g) <- epslist, g<delta] expGolub m = iterate msq f !! j- where j = max 0 $ floor $ log2 $ pnorm Infinity m- log2 x = log x / log 2+ where j = max 0 $ floor $ logBase 2 $ pnorm Infinity m a = m */ fromIntegral ((2::Int)^j) q = geps eps -- 7 steps eye = ident (rows m)
lib/Numeric/LinearAlgebra/Tests/Instances.hs view
@@ -84,7 +84,7 @@ #if MIN_VERSION_QuickCheck(2,0,0) -- shrink any one of the components- shrink a = map ((rows a) >< (cols a))+ shrink a = map (rows a >< cols a) . shrinkListElementwise . concat . toLists $ a
lib/Numeric/LinearAlgebra/Tests/Properties.hs view
@@ -159,7 +159,7 @@ m = fromBlocks [[m'],[m']] r = rank m' -svdProp5a m = and (map (s1|~|) [s2,s3,s4,s5,s6]) where+svdProp5a m = all (s1|~|) [s2,s3,s4,s5,s6] where s1 = svR m s2 = svRd m (_,s3,_) = svdR m@@ -167,7 +167,7 @@ (_,s5,_) = thinSVDR m (_,s6,_) = thinSVDRd m -svdProp5b m = and (map (s1|~|) [s2,s3,s4,s5,s6]) where+svdProp5b m = all (s1|~|) [s2,s3,s4,s5,s6] where s1 = svC m s2 = svCd m (_,s3,_) = svdC m
lib/Numeric/Matrix.hs view
@@ -3,7 +3,6 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE FunctionalDependencies #-} ----------------------------------------------------------------------------- -- |