license changes, reexport modules

4 files changed, 241 insertions, 278 deletions

diff --git a/packages/hmatrix/src/Numeric/Container.hs b/packages/hmatrix/src/Numeric/Container.hs
new file mode 100644
index 0000000..146780d
--- /dev/null
+++ b/packages/hmatrix/src/Numeric/Container.hs
@@ -0,0 +1,241 @@
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Numeric.Container
+-- Copyright   :  (c) Alberto Ruiz 2010-14
+-- License     :  BSD3
+-- Maintainer  :  Alberto Ruiz
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- Basic numeric operations on 'Vector' and 'Matrix', including conversion routines.
+--
+-- The 'Container' class is used to define optimized generic functions which work
+-- on 'Vector' and 'Matrix' with real or complex elements.
+--
+-- Some of these functions are also available in the instances of the standard
+-- numeric Haskell classes provided by "Numeric.LinearAlgebra".
+--
+-----------------------------------------------------------------------------
+{-# OPTIONS_HADDOCK hide #-}
+
+module Numeric.Container (
+    -- * Basic functions
+    module Data.Packed,
+    konst, build,
+    linspace,
+    diag, ident,
+    ctrans,
+    -- * Generic operations
+    Container(..),
+    -- * Matrix product
+    Product(..), udot, dot, (◇),
+    Mul(..),
+    Contraction(..),
+    optimiseMult,
+    mXm,mXv,vXm,LSDiv(..),
+    outer, kronecker,
+    -- * Element conversion
+    Convert(..),
+    Complexable(),
+    RealElement(),
+
+    RealOf, ComplexOf, SingleOf, DoubleOf,
+
+    IndexOf,
+    module Data.Complex
+) where
+
+import Data.Packed hiding (stepD, stepF, condD, condF, conjugateC, conjugateQ)
+import Data.Packed.Numeric
+import Data.Complex
+import Numeric.LinearAlgebra.Algorithms(Field,linearSolveSVD)
+import Data.Monoid(Monoid(mconcat))
+
+------------------------------------------------------------------
+
+{- | Creates a real vector containing a range of values:
+
+>>> linspace 5 (-3,7::Double)
+fromList [-3.0,-0.5,2.0,4.5,7.0]@
+
+>>> linspace 5 (8,2+i) :: Vector (Complex Double)
+fromList [8.0 :+ 0.0,6.5 :+ 0.25,5.0 :+ 0.5,3.5 :+ 0.75,2.0 :+ 1.0]
+
+Logarithmic spacing can be defined as follows:
+
+@logspace n (a,b) = 10 ** linspace n (a,b)@
+-}
+linspace :: (Container Vector e) => Int -> (e, e) -> Vector e
+linspace 0 (a,b) = fromList[(a+b)/2]
+linspace n (a,b) = addConstant a $ scale s $ fromList $ map fromIntegral [0 .. n-1]
+    where s = (b-a)/fromIntegral (n-1)
+
+--------------------------------------------------------
+
+class Contraction a b c | a b -> c
+  where
+    infixl 7 <.>
+    {- | Matrix product, matrix vector product, and dot product
+
+Examples:
+
+>>> let a = (3><4)   [1..]      :: Matrix Double
+>>> let v = fromList [1,0,2,-1] :: Vector Double
+>>> let u = fromList [1,2,3]    :: Vector Double
+
+>>> a
+(3><4)
+ [ 1.0,  2.0,  3.0,  4.0
+ , 5.0,  6.0,  7.0,  8.0
+ , 9.0, 10.0, 11.0, 12.0 ]
+
+matrix × matrix:
+
+>>> disp 2 (a <.> trans a)
+3x3
+ 30   70  110
+ 70  174  278
+110  278  446
+
+matrix × vector:
+
+>>> a <.> v
+fromList [3.0,11.0,19.0]
+
+dot product:
+
+>>> u <.> fromList[3,2,1::Double]
+10
+
+For complex vectors the first argument is conjugated:
+
+>>> fromList [1,i] <.> fromList[2*i+1,3]
+1.0 :+ (-1.0)
+
+>>> fromList [1,i,1-i] <.> complex a
+fromList [10.0 :+ 4.0,12.0 :+ 4.0,14.0 :+ 4.0,16.0 :+ 4.0]
+
+-}
+    (<.>) :: a -> b -> c
+
+
+instance (Product t, Container Vector t) => Contraction (Vector t) (Vector t) t where
+    u <.> v = conj u `udot` v
+
+instance Product t => Contraction (Matrix t) (Vector t) (Vector t) where
+    (<.>) = mXv
+
+instance (Container Vector t, Product t) => Contraction (Vector t) (Matrix t) (Vector t) where
+    (<.>) v m = (conj v) `vXm` m
+
+instance Product t => Contraction (Matrix t) (Matrix t) (Matrix t) where
+    (<.>) = mXm
+
+
+--------------------------------------------------------------------------------
+
+class Mul a b c | a b -> c where
+ infixl 7 <>
+ -- | Matrix-matrix, matrix-vector, and vector-matrix products.
+ (<>)  :: Product t => a t -> b t -> c t
+
+instance Mul Matrix Matrix Matrix where
+    (<>) = mXm
+
+instance Mul Matrix Vector Vector where
+    (<>) m v = flatten $ m <> asColumn v
+
+instance Mul Vector Matrix Vector where
+    (<>) v m = flatten $ asRow v <> m
+
+--------------------------------------------------------------------------------
+
+class LSDiv c where
+ infixl 7 <\>
+ -- | least squares solution of a linear system, similar to the \\ operator of Matlab\/Octave (based on linearSolveSVD)
+ (<\>)  :: Field t => Matrix t -> c t -> c t
+
+instance LSDiv Vector where
+    m <\> v = flatten (linearSolveSVD m (reshape 1 v))
+
+instance LSDiv Matrix where
+    (<\>) = linearSolveSVD
+
+--------------------------------------------------------------------------------
+
+class Konst e d c | d -> c, c -> d
+  where
+    -- |
+    -- >>> konst 7 3 :: Vector Float
+    -- fromList [7.0,7.0,7.0]
+    --
+    -- >>> konst i (3::Int,4::Int)
+    -- (3><4)
+    --  [ 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0
+    --  , 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0
+    --  , 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0 ]
+    --
+    konst :: e -> d -> c e
+
+instance Container Vector e => Konst e Int Vector
+  where
+    konst = konst'
+
+instance Container Vector e => Konst e (Int,Int) Matrix
+  where
+    konst = konst'
+
+--------------------------------------------------------------------------------
+
+class Build d f c e | d -> c, c -> d, f -> e, f -> d, f -> c, c e -> f, d e -> f
+  where
+    -- |
+    -- >>> build 5 (**2) :: Vector Double
+    -- fromList [0.0,1.0,4.0,9.0,16.0]
+    --
+    -- Hilbert matrix of order N:
+    --
+    -- >>> let hilb n = build (n,n) (\i j -> 1/(i+j+1)) :: Matrix Double
+    -- >>> putStr . dispf 2 $ hilb 3
+    -- 3x3
+    -- 1.00  0.50  0.33
+    -- 0.50  0.33  0.25
+    -- 0.33  0.25  0.20
+    --
+    build :: d -> f -> c e
+
+instance Container Vector e => Build Int (e -> e) Vector e
+  where
+    build = build'
+
+instance Container Matrix e => Build (Int,Int) (e -> e -> e) Matrix e
+  where
+    build = build'
+
+--------------------------------------------------------------------------------
+
+{- | alternative operator for '(\<.\>)'
+
+x25c7, white diamond
+
+-}
+(◇) :: Contraction a b c => a -> b -> c
+infixl 7 ◇
+(◇) = (<.>)
+
+-- | dot product: @cdot u v = 'udot' ('conj' u) v@
+dot :: (Container Vector t, Product t) => Vector t -> Vector t -> t
+dot u v = udot (conj u) v
+
+--------------------------------------------------------------------------------
+
+optimiseMult :: Monoid (Matrix t) => [Matrix t] -> Matrix t
+optimiseMult = mconcat
+
diff --git a/packages/hmatrix/src/Numeric/HMatrix.hs b/packages/hmatrix/src/Numeric/HMatrix.hs
deleted file mode 100644
index fcd3e02..0000000
--- a/packages/hmatrix/src/Numeric/HMatrix.hs
+++ /dev/null
@@ -1,139 +0,0 @@
------------------------------------------------------------------------------
-{- |
-Module      :  Numeric.HMatrix
-Copyright   :  (c) Alberto Ruiz 2006-14
-License     :  GPL
-
-Maintainer  :  Alberto Ruiz
-Stability   :  provisional
-
-This module reexports the most common Linear Algebra functions.
-
--}
------------------------------------------------------------------------------
-module Numeric.HMatrix (
-
-    -- * Basic types and data processing    
-    module Numeric.HMatrix.Data,
-    
-    -- | The standard numeric classes are defined elementwise:
-    --
-    -- >>> fromList [1,2,3] * fromList [3,0,-2 :: Double]
-    -- fromList [3.0,0.0,-6.0]
-    -- 
-    -- >>> (3><3) [1..9] * ident 3 :: Matrix Double
-    -- (3><3)
-    --  [ 1.0, 0.0, 0.0
-    --  , 0.0, 5.0, 0.0
-    --  , 0.0, 0.0, 9.0 ]
-    --
-    -- In arithmetic operations single-element vectors and matrices
-    -- (created from numeric literals or using 'scalar') automatically
-    -- expand to match the dimensions of the other operand:
-    -- 
-    -- >>> 5 + 2*ident 3 :: Matrix Double
-    -- (3><3)
-    --  [ 7.0, 5.0, 5.0
-    --  , 5.0, 7.0, 5.0
-    --  , 5.0, 5.0, 7.0 ]
-    --
-
-    -- * Products
-    (<.>),
-    
-    -- | The matrix product is also implemented in the "Data.Monoid" instance for Matrix, where
-    -- single-element matrices (created from numeric literals or using 'scalar')
-    -- are used for scaling.
-    --
-    -- >>> let m = (2><3)[1..] :: Matrix Double
-    -- >>> m <> 2 <> diagl[0.5,1,0]
-    -- (2><3)
-    -- [ 1.0,  4.0, 0.0
-    -- , 4.0, 10.0, 0.0 ]
-    --
-    -- mconcat uses 'optimiseMult' to get the optimal association order.
- 
-    (◇),
-    outer, kronecker, cross,
-    scale,
-    sumElements, prodElements, absSum,
-    
-    -- * Linear Systems
-    (<\>),
-    linearSolve,
-    linearSolveLS,
-    linearSolveSVD,
-    luSolve,
-    cholSolve,
-    
-    -- * Inverse and pseudoinverse
-    inv, pinv, pinvTol,
-
-    -- * Determinant and rank
-    rcond, rank, ranksv, 
-    det, invlndet,
-    
-    -- * Singular value decomposition
-    svd,
-    fullSVD,
-    thinSVD,
-    compactSVD,
-    singularValues,
-    leftSV, rightSV,
-    
-    -- * Eigensystems
-    eig, eigSH, eigSH',
-    eigenvalues, eigenvaluesSH, eigenvaluesSH',
-    geigSH',
-
-    -- * QR
-    qr, rq, qrRaw, qrgr,
-
-    -- * Cholesky
-    chol, cholSH, mbCholSH,
-
-    -- * Hessenberg
-    hess,
-
-    -- * Schur
-    schur,
-
-    -- * LU
-    lu, luPacked,
-    
-    -- * Matrix functions
-    expm,
-    sqrtm,
-    matFunc,
-
-    -- * Nullspace
-    nullspacePrec,
-    nullVector,
-    nullspaceSVD,
-    null1, null1sym,
-    
-    orth,
-
-    -- * Norms
-    norm1, norm2, normInf, pnorm, NormType(..),
-
-    -- * Correlation and Convolution
-    corr, conv, corrMin, corr2, conv2,
-
-    -- * Random arrays
-    rand, randn, RandDist(..), randomVector, gaussianSample, uniformSample,
-    
-    -- * Misc
-    meanCov, peps, relativeError, haussholder, optimiseMult, udot
-) where
-
-import Numeric.HMatrix.Data
-
---import Numeric.Matrix()
---import Numeric.Vector()
-import Numeric.Container
-import Numeric.LinearAlgebra.Algorithms
-import Numeric.LinearAlgebra.Util
-import Numeric.Random
-
-
diff --git a/packages/hmatrix/src/Numeric/HMatrix/Data.hs b/packages/hmatrix/src/Numeric/HMatrix/Data.hs
deleted file mode 100644
index 5d7ce4f..0000000
--- a/packages/hmatrix/src/Numeric/HMatrix/Data.hs
+++ /dev/null
@@ -1,70 +0,0 @@
---------------------------------------------------------------------------------
-{- |
-Module      :  Numeric.HMatrix.Data
-Copyright   :  (c) Alberto Ruiz 2014
-License     :  GPL
-
-Maintainer  :  Alberto Ruiz
-Stability   :  provisional
-
-Basic data processing.
-
--}
---------------------------------------------------------------------------------
-
-module Numeric.HMatrix.Data(
-
-    -- * Vector
-    -- | 1D arrays are storable vectors from the vector package.
-    
-    Vector, (|>), dim, (@>),
-    
-    -- * Matrix
-    Matrix, (><), size, (@@>), trans, ctrans,
-    
-    -- * Construction
-    scalar, konst, build, assoc, accum, linspace, -- ones, zeros,
-
-    -- * Diagonal
-    ident, diag, diagl, diagRect, takeDiag,
-
-    -- * Data manipulation
-    fromList, toList, subVector, takesV, vjoin,
-    flatten, reshape, asRow, asColumn, row, col,
-    fromRows, toRows, fromColumns, toColumns, fromLists, toLists, fromArray2D,
-    takeRows, dropRows, takeColumns, dropColumns, subMatrix, (?), (¿), fliprl, flipud,
-  
-    -- * Block matrix
-    fromBlocks, (¦), (——), diagBlock, repmat, toBlocks, toBlocksEvery,
-
-    -- * Mapping functions
-    conj, cmap, step, cond,
-    
-    -- * Find elements
-    find, maxIndex, minIndex, maxElement, minElement, atIndex,
-
-    -- * IO
-    disp, dispf, disps, dispcf, latexFormat, format,
-    loadMatrix, saveMatrix, fromFile, fileDimensions,
-    readMatrix,
-    fscanfVector, fprintfVector, freadVector, fwriteVector,
-
--- * Conversion
-    Convert(..),
-    
-    -- * Misc
-    arctan2,
-    rows, cols,
-    separable,
-
-    module Data.Complex
-
-) where
-
-import Data.Packed.Vector
-import Data.Packed.Matrix
-import Numeric.Container
-import Numeric.IO
-import Numeric.LinearAlgebra.Util
-import Data.Complex
-
diff --git a/packages/hmatrix/src/Numeric/HMatrix/Devel.hs b/packages/hmatrix/src/Numeric/HMatrix/Devel.hs
deleted file mode 100644
index b921f44..0000000
--- a/packages/hmatrix/src/Numeric/HMatrix/Devel.hs
+++ /dev/null
@@ -1,69 +0,0 @@
---------------------------------------------------------------------------------
-{- |
-Module      :  Numeric.HMatrix.Devel
-Copyright   :  (c) Alberto Ruiz 2014
-License     :  GPL
-
-Maintainer  :  Alberto Ruiz
-Stability   :  provisional
-
-The library can be easily extended using the tools in this module.
-
--}
---------------------------------------------------------------------------------
-
-module Numeric.HMatrix.Devel(
-    -- * FFI helpers
-    -- | Sample usage, to upload a perspective matrix to a shader.
-    --
-    -- @ glUniformMatrix4fv 0 1 (fromIntegral gl_TRUE) \`appMatrix\` perspective 0.01 100 (pi\/2) (4\/3)
-    -- @
-    module Data.Packed.Foreign,
-
-    -- * FFI tools
-    -- | Illustrative usage examples can be found
-    --   in the @examples\/devel@ folder included in the package.
-    module Data.Packed.Development,
-
-    -- * ST
-    -- | In-place manipulation inside the ST monad.
-    -- See examples\/inplace.hs in the distribution.
-    
-    -- ** Mutable Vectors
-    STVector, newVector, thawVector, freezeVector, runSTVector,
-    readVector, writeVector, modifyVector, liftSTVector,
-    -- ** Mutable Matrices
-    STMatrix, newMatrix, thawMatrix, freezeMatrix, runSTMatrix,
-    readMatrix, writeMatrix, modifyMatrix, liftSTMatrix,
-    -- ** Unsafe functions
-    newUndefinedVector,
-    unsafeReadVector, unsafeWriteVector,
-    unsafeThawVector, unsafeFreezeVector,
-    newUndefinedMatrix,
-    unsafeReadMatrix, unsafeWriteMatrix,
-    unsafeThawMatrix, unsafeFreezeMatrix,
-
-    -- * Special maps and zips
-    mapVectorWithIndex, zipVector, zipVectorWith, unzipVector, unzipVectorWith,
-    mapVectorM, mapVectorM_, mapVectorWithIndexM, mapVectorWithIndexM_,
-    foldLoop, foldVector, foldVectorG, foldVectorWithIndex,
-    mapMatrixWithIndex, mapMatrixWithIndexM, mapMatrixWithIndexM_,
-    liftMatrix, liftMatrix2, liftMatrix2Auto,
-
-    -- * Auxiliary classes
-    Element, Container, Product, Contraction, LSDiv,
-    Complexable(), RealElement(),
-    RealOf, ComplexOf, SingleOf, DoubleOf,
-    IndexOf,
-    Field, Normed
-) where
-
-import Data.Packed.Foreign
-import Data.Packed.Development
-import Data.Packed.ST
-import Numeric.Container(Container,Contraction,LSDiv,Product,
-                         Complexable(),RealElement(),
-                         RealOf, ComplexOf, SingleOf, DoubleOf, IndexOf)
-import Data.Packed
-import Numeric.LinearAlgebra.Algorithms(Field,Normed)
-