| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
QC
Description
- Module : QC
- Description : Quantum Computing
- Copyright : (c) Mihai Sebastian Ardelean, 2018
- License : BSD3
- Maintainer : ardeleanasm@gmail.com
- Portability : POSIX
This module is used to import needed modules for Quantum Computing.
Synopsis
- module Quantum.Qubits
- module Quantum.Gates
- module Quantum.MeasurementPerformer
- module Operations.QuantumOperations
- phase :: RealFloat a => Complex a -> a
- magnitude :: RealFloat a => Complex a -> a
- polar :: RealFloat a => Complex a -> (a, a)
- cis :: Floating a => a -> Complex a
- mkPolar :: Floating a => a -> a -> Complex a
- conjugate :: Num a => Complex a -> Complex a
- imagPart :: Complex a -> a
- realPart :: Complex a -> a
- data Complex a = !a :+ !a
- orth :: Field t => Matrix t -> Matrix t
- nullspace :: Field t => Matrix t -> Matrix t
- linearSolve :: Field t => Matrix t -> Matrix t -> Maybe (Matrix t)
- (<>) :: Numeric t => Matrix t -> Matrix t -> Matrix t
- cgSolve' :: Bool -> R -> R -> Int -> GMatrix -> Vector R -> Vector R -> [CGState]
- cgSolve :: Bool -> GMatrix -> Vector R -> Vector R
- data CGState = CGState {}
- data Mod (n :: Nat) t
- type (./.) x (n :: Nat) = Mod n x
- luSolve' :: (Fractional t, Container Vector t) => LU t -> Matrix t -> Matrix t
- luPacked' :: (Container Vector t, Fractional t, Normed (Vector t), Num (Vector t)) => Matrix t -> LU t
- dispShort :: Int -> Int -> Int -> Matrix Double -> IO ()
- dispBlanks :: Int -> Matrix Double -> IO ()
- dispDots :: Int -> Matrix Double -> IO ()
- null1sym :: Herm R -> Vector R
- null1 :: Matrix R -> Vector R
- rowOuters :: Matrix Double -> Matrix Double -> Matrix Double
- pairwiseD2 :: Matrix Double -> Matrix Double -> Matrix Double
- size :: Container c t => c t -> IndexOf c
- normalize :: (Normed (Vector t), Num (Vector t), Field t) => Vector t -> Vector t
- magnit :: (Element t, Normed (Vector t)) => R -> t -> Bool
- norm_nuclear :: Field t => Matrix t -> R
- norm_Frob :: (Normed (Vector t), Element t) => Matrix t -> R
- cross :: Product t => Vector t -> Vector t -> Vector t
- (¿) :: Element t => Matrix t -> [Int] -> Matrix t
- (?) :: Element t => Matrix t -> [Int] -> Matrix t
- col :: [Double] -> Matrix Double
- row :: [Double] -> Matrix Double
- (===) :: Element t => Matrix t -> Matrix t -> Matrix t
- (|||) :: Element t => Matrix t -> Matrix t -> Matrix t
- diagl :: [Double] -> Matrix Double
- disp :: Int -> Matrix Double -> IO ()
- matrix :: Int -> [R] -> Matrix R
- vector :: [R] -> Vector R
- iC :: C
- class Normed a where
- class Indexable c t | c -> t, t -> c where
- separable :: Element t => (Vector t -> Vector t) -> Matrix t -> Matrix t
- conv2 :: (Num (Matrix a), Product a, Container Vector a) => Matrix a -> Matrix a -> Matrix a
- corr2 :: Product a => Matrix a -> Matrix a -> Matrix a
- corrMin :: (Container Vector t, RealElement t, Product t) => Vector t -> Vector t -> Vector t
- conv :: (Container Vector t, Product t, Num t) => Vector t -> Vector t -> Vector t
- corr :: (Container Vector t, Product t) => Vector t -> Vector t -> Vector t
- remap :: Element t => Matrix I -> Matrix I -> Matrix t -> Matrix t
- sortIndex :: (Ord t, Element t) => Vector t -> Vector I
- sortVector :: (Ord t, Element t) => Vector t -> Vector t
- meanCov :: Matrix Double -> (Vector Double, Herm Double)
- optimiseMult :: Monoid (Matrix t) => [Matrix t] -> Matrix t
- dot :: Numeric t => Vector t -> Vector t -> t
- (<\>) :: (LSDiv c, Field t) => Matrix t -> c t -> c t
- (<#) :: Numeric t => Vector t -> Matrix t -> Vector t
- (#>) :: Numeric t => Matrix t -> Vector t -> Vector t
- (<.>) :: Numeric t => Vector t -> Vector t -> t
- linspace :: (Fractional e, Container Vector e) => Int -> (e, e) -> Vector e
- class LSDiv (c :: * -> *)
- class Build d f (c :: * -> *) e | d -> c, c -> d, f -> e, f -> d, f -> c, c e -> f, d e -> f where
- randn :: Int -> Int -> IO (Matrix Double)
- rand :: Int -> Int -> IO (Matrix Double)
- uniformSample :: Seed -> Int -> [(Double, Double)] -> Matrix Double
- gaussianSample :: Seed -> Int -> Vector Double -> Herm Double -> Matrix Double
- trustSym :: Matrix t -> Herm t
- mTm :: Numeric t => Matrix t -> Herm t
- sym :: Field t => Matrix t -> Herm t
- unSym :: Herm t -> Matrix t
- geigSH :: Field t => Herm t -> Herm t -> (Vector Double, Matrix t)
- relativeError :: Num a => (a -> Double) -> a -> a -> Double
- luFact :: Numeric t => LU t -> (Matrix t, Matrix t, Matrix t, t)
- sqrtm :: Field t => Matrix t -> Matrix t
- expm :: Field t => Matrix t -> Matrix t
- matFunc :: (Complex Double -> Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)
- rank :: Field t => Matrix t -> Int
- rcond :: Field t => Matrix t -> Double
- haussholder :: Field a => a -> Vector a -> Matrix a
- orthSVD :: Field t => Either Double Int -> Matrix t -> (Matrix t, Vector Double) -> Matrix t
- nullspaceSVD :: Field t => Either Double Int -> Matrix t -> (Vector Double, Matrix t) -> Matrix t
- peps :: RealFloat x => x
- ranksv :: Double -> Int -> [Double] -> Int
- pinvTol :: Field t => Double -> Matrix t -> Matrix t
- pinv :: Field t => Matrix t -> Matrix t
- inv :: Field t => Matrix t -> Matrix t
- lu :: Field t => Matrix t -> (Matrix t, Matrix t, Matrix t, t)
- det :: Field t => Matrix t -> t
- invlndet :: Field t => Matrix t -> (Matrix t, (t, t))
- mbChol :: Field t => Herm t -> Maybe (Matrix t)
- chol :: Field t => Herm t -> Matrix t
- schur :: Field t => Matrix t -> (Matrix t, Matrix t)
- hess :: Field t => Matrix t -> (Matrix t, Matrix t)
- thinRQ :: Field t => Matrix t -> (Matrix t, Matrix t)
- rq :: Field t => Matrix t -> (Matrix t, Matrix t)
- qrgr :: Field t => Int -> QR t -> Matrix t
- qrRaw :: Field t => Matrix t -> QR t
- thinQR :: Field t => Matrix t -> (Matrix t, Matrix t)
- qr :: Field t => Matrix t -> (Matrix t, Matrix t)
- eigenvaluesSH :: Field t => Herm t -> Vector Double
- eigSH :: Field t => Herm t -> (Vector Double, Matrix t)
- eigenvalues :: Field t => Matrix t -> Vector (Complex Double)
- eig :: Field t => Matrix t -> (Vector (Complex Double), Matrix (Complex Double))
- ldlSolve :: Field t => LDL t -> Matrix t -> Matrix t
- ldlPacked :: Field t => Herm t -> LDL t
- linearSolveLS :: Field t => Matrix t -> Matrix t -> Matrix t
- linearSolveSVD :: Field t => Matrix t -> Matrix t -> Matrix t
- triDiagSolve :: Field t => Vector t -> Vector t -> Vector t -> Matrix t -> Matrix t
- triSolve :: Field t => UpLo -> Matrix t -> Matrix t -> Matrix t
- cholSolve :: Field t => Matrix t -> Matrix t -> Matrix t
- luSolve :: Field t => LU t -> Matrix t -> Matrix t
- luPacked :: Field t => Matrix t -> LU t
- leftSV :: Field t => Matrix t -> (Matrix t, Vector Double)
- rightSV :: Field t => Matrix t -> (Vector Double, Matrix t)
- compactSVDTol :: Field t => Double -> Matrix t -> (Matrix t, Vector Double, Matrix t)
- compactSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)
- singularValues :: Field t => Matrix t -> Vector Double
- thinSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)
- svd :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)
- class (Numeric t, Convert t, Normed Matrix t, Normed Vector t, Floating t, Linear t Vector, Linear t Matrix, Additive (Vector t), Additive (Matrix t), RealOf t ~ Double) => Field t
- data LU t = LU (Matrix t) [Int]
- data LDL t = LDL (Matrix t) [Int]
- data QR t = QR (Matrix t) (Vector t)
- data Herm t
- toDense :: AssocMatrix -> Matrix Double
- (!#>) :: GMatrix -> Vector Double -> Vector Double
- mkDiagR :: Int -> Int -> Vector Double -> GMatrix
- mkSparse :: AssocMatrix -> GMatrix
- mkDense :: Matrix Double -> GMatrix
- type AssocMatrix = [((Int, Int), Double)]
- data GMatrix
- ident :: (Num a, Element a) => Int -> Matrix a
- diag :: (Num a, Element a) => Vector a -> Matrix a
- kronecker :: Product t => Matrix t -> Matrix t -> Matrix t
- outer :: Product t => Vector t -> Vector t -> Matrix t
- udot :: Product e => Vector e -> Vector e -> e
- accum :: Container c e => c e -> (e -> e -> e) -> [(IndexOf c, e)] -> c e
- assoc :: Container c e => IndexOf c -> e -> [(IndexOf c, e)] -> c e
- find :: Container c e => (e -> Bool) -> c e -> [IndexOf c]
- cond :: (Ord e, Container c e, Container c x) => c e -> c e -> c x -> c x -> c x -> c x
- step :: (Ord e, Container c e) => c e -> c e
- prodElements :: Container c e => c e -> e
- sumElements :: Container c e => c e -> e
- maxElement :: Container c e => c e -> e
- minElement :: Container c e => c e -> e
- maxIndex :: Container c e => c e -> IndexOf c
- minIndex :: Container c e => c e -> IndexOf c
- atIndex :: Container c e => c e -> IndexOf c -> e
- cmap :: (Element b, Container c e) => (e -> b) -> c e -> c b
- toZ :: Container c e => c e -> c Z
- fromZ :: Container c e => c Z -> c e
- toInt :: Container c e => c e -> c I
- fromInt :: Container c e => c I -> c e
- cmod :: (Integral e, Container c e) => e -> c e -> c e
- arctan2 :: (Fractional e, Container c e) => c e -> c e -> c e
- conj :: Container c e => c e -> c e
- scalar :: Container c e => e -> c e
- type family IndexOf (c :: * -> *) :: *
- class Element e => Container (c :: * -> *) e
- class Konst e d (c :: * -> *) | d -> c, c -> d where
- class (Container Vector t, Container Matrix t, Konst t Int Vector, Konst t (Int, Int) Matrix, CTrans t, Product t, Additive (Vector t), Additive (Matrix t), Linear t Vector, Linear t Matrix) => Numeric t
- class (Num e, Element e) => Product e
- class Convert t where
- type family RealOf x :: *
- type ComplexOf x = Complex (RealOf x)
- type family SingleOf x :: *
- type family DoubleOf x :: *
- class Transposable m mt | m -> mt, mt -> m where
- class Additive c where
- class Linear t (c :: * -> *) where
- class Testable t where
- data UpLo
- class (Element t, Element (Complex t), RealFloat t) => RealElement t
- class Complexable (c :: * -> *)
- toBlocksEvery :: Element t => Int -> Int -> Matrix t -> [[Matrix t]]
- toBlocks :: Element t => [Int] -> [Int] -> Matrix t -> [[Matrix t]]
- repmat :: Element t => Matrix t -> Int -> Int -> Matrix t
- fromArray2D :: Storable e => Array (Int, Int) e -> Matrix e
- asColumn :: Storable a => Vector a -> Matrix a
- asRow :: Storable a => Vector a -> Matrix a
- fromLists :: Element t => [[t]] -> Matrix t
- dropColumns :: Element t => Int -> Matrix t -> Matrix t
- takeColumns :: Element t => Int -> Matrix t -> Matrix t
- dropRows :: Element t => Int -> Matrix t -> Matrix t
- takeRows :: Element t => Int -> Matrix t -> Matrix t
- (><) :: Storable a => Int -> Int -> [a] -> Matrix a
- takeDiag :: Element t => Matrix t -> Vector t
- diagRect :: Storable t => t -> Vector t -> Int -> Int -> Matrix t
- fliprl :: Element t => Matrix t -> Matrix t
- flipud :: Element t => Matrix t -> Matrix t
- diagBlock :: (Element t, Num t) => [Matrix t] -> Matrix t
- fromBlocks :: Element t => [[Matrix t]] -> Matrix t
- (??) :: Element t => Matrix t -> (Extractor, Extractor) -> Matrix t
- data Extractor
- loadMatrix' :: FilePath -> IO (Maybe (Matrix Double))
- loadMatrix :: FilePath -> IO (Matrix Double)
- dispcf :: Int -> Matrix (Complex Double) -> String
- latexFormat :: String -> String -> String
- dispf :: Int -> Matrix Double -> String
- disps :: Int -> Matrix Double -> String
- format :: Element t => String -> (t -> String) -> Matrix t -> String
- saveMatrix :: FilePath -> String -> Matrix Double -> IO ()
- subMatrix :: Element a => (Int, Int) -> (Int, Int) -> Matrix a -> Matrix a
- reshape :: Storable t => Int -> Vector t -> Matrix t
- toColumns :: Element t => Matrix t -> [Vector t]
- fromColumns :: Element t => [Vector t] -> Matrix t
- toRows :: Element t => Matrix t -> [Vector t]
- fromRows :: Element t => [Vector t] -> Matrix t
- toLists :: Element t => Matrix t -> [[t]]
- flatten :: Element t => Matrix t -> Vector t
- cols :: Matrix t -> Int
- rows :: Matrix t -> Int
- data Matrix t
- class Storable a => Element a
- range :: Int -> Vector I
- roundVector :: Vector Double -> Vector Double
- randomVector :: Seed -> RandDist -> Int -> Vector Double
- type Seed = Int
- data RandDist
- takesV :: Storable t => [Int] -> Vector t -> [Vector t]
- vjoin :: Storable t => [Vector t] -> Vector t
- subVector :: Storable t => Int -> Int -> Vector t -> Vector t
- idxs :: [Int] -> Vector I
- toList :: Storable a => Vector a -> [a]
- type I = CInt
- type Z = Int64
- type R = Double
- type C = Complex Double
- data Vector a
- fromList :: Storable a => [a] -> Vector a
Documentation
module Quantum.Qubits
module Quantum.Gates
module Quantum.MeasurementPerformer
module Operations.QuantumOperations
mkPolar :: Floating a => a -> a -> Complex a #
Form a complex number from polar components of magnitude and phase.
Complex numbers are an algebraic type.
For a complex number z, abs zz,
but oriented in the positive real direction, whereas signum zz, but unit magnitude.
The Foldable and Traversable instances traverse the real part first.
Constructors
| !a :+ !a infix 6 | forms a complex number from its real and imaginary rectangular components. |
Instances
orth :: Field t => Matrix t -> Matrix t #
return an orthonormal basis of the range space of a matrix. See also orthSVD.
nullspace :: Field t => Matrix t -> Matrix t #
return an orthonormal basis of the null space of a matrix. See also nullspaceSVD.
linearSolve :: Field t => Matrix t -> Matrix t -> Maybe (Matrix t) #
Solve a linear system (for square coefficient matrix and several right-hand sides) using the LU decomposition, returning Nothing for a singular system. For underconstrained or overconstrained systems use linearSolveLS or linearSolveSVD.
a = (2><2) [ 1.0, 2.0 , 3.0, 5.0 ]
b = (2><3) [ 6.0, 1.0, 10.0 , 15.0, 3.0, 26.0 ]
>>>linearSolve a bJust (2><3) [ -1.4802973661668753e-15, 0.9999999999999997, 1.999999999999997 , 3.000000000000001, 1.6653345369377348e-16, 4.000000000000002 ]
>>>let Just x = it>>>disp 5 x2x3 -0.00000 1.00000 2.00000 3.00000 0.00000 4.00000
>>>a <> x(2><3) [ 6.0, 1.0, 10.0 , 15.0, 3.0, 26.0 ]
(<>) :: Numeric t => Matrix t -> Matrix t -> Matrix t infixr 8 #
dense matrix product
>>>let a = (3><5) [1..]>>>a(3><5) [ 1.0, 2.0, 3.0, 4.0, 5.0 , 6.0, 7.0, 8.0, 9.0, 10.0 , 11.0, 12.0, 13.0, 14.0, 15.0 ]
>>>let b = (5><2) [1,3, 0,2, -1,5, 7,7, 6,0]>>>b(5><2) [ 1.0, 3.0 , 0.0, 2.0 , -1.0, 5.0 , 7.0, 7.0 , 6.0, 0.0 ]
>>>a <> b(3><2) [ 56.0, 50.0 , 121.0, 135.0 , 186.0, 220.0 ]
Arguments
| :: Bool | symmetric |
| -> R | relative tolerance for the residual (e.g. 1E-4) |
| -> R | relative tolerance for δx (e.g. 1E-3) |
| -> Int | maximum number of iterations |
| -> GMatrix | coefficient matrix |
| -> Vector R | initial solution |
| -> Vector R | right-hand side |
| -> [CGState] | solution |
Solve a sparse linear system using the conjugate gradient method with default parameters.
Arguments
| :: Bool | is symmetric |
| -> GMatrix | coefficient matrix |
| -> Vector R | right-hand side |
| -> Vector R | solution |
Solve a sparse linear system using the conjugate gradient method with default parameters.
Wrapper with a phantom integer for statically checked modular arithmetic.
Instances
luPacked' :: (Container Vector t, Fractional t, Normed (Vector t), Num (Vector t)) => Matrix t -> LU t #
Experimental implementation of luPacked
for any Fractional element type, including Mod n I and Mod n Z.
>>>let m = ident 5 + (5><5) [0..] :: Matrix (Z ./. 17)(5><5) [ 1, 1, 2, 3, 4 , 5, 7, 7, 8, 9 , 10, 11, 13, 13, 14 , 15, 16, 0, 2, 2 , 3, 4, 5, 6, 8 ]
>>>let (l,u,p,s) = luFact $ luPacked' m>>>l(5><5) [ 1, 0, 0, 0, 0 , 6, 1, 0, 0, 0 , 12, 7, 1, 0, 0 , 7, 10, 7, 1, 0 , 8, 2, 6, 11, 1 ]>>>u(5><5) [ 15, 16, 0, 2, 2 , 0, 13, 7, 13, 14 , 0, 0, 15, 0, 11 , 0, 0, 0, 15, 15 , 0, 0, 0, 0, 1 ]
rowOuters :: Matrix Double -> Matrix Double -> Matrix Double #
outer products of rows
>>>a(3><2) [ 1.0, 2.0 , 10.0, 20.0 , 100.0, 200.0 ]>>>b(3><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 , 7.0, 8.0, 9.0 ]
>>>rowOuters a (b ||| 1)(3><8) [ 1.0, 2.0, 3.0, 1.0, 2.0, 4.0, 6.0, 2.0 , 40.0, 50.0, 60.0, 10.0, 80.0, 100.0, 120.0, 20.0 , 700.0, 800.0, 900.0, 100.0, 1400.0, 1600.0, 1800.0, 200.0 ]
pairwiseD2 :: Matrix Double -> Matrix Double -> Matrix Double #
Matrix of pairwise squared distances of row vectors (using the matrix product trick in blog.smola.org)
size :: Container c t => c t -> IndexOf c #
>>>size $ vector [1..10]10>>>size $ (2><5)[1..10::Double](2,5)
normalize :: (Normed (Vector t), Num (Vector t), Field t) => Vector t -> Vector t #
Obtains a vector in the same direction with 2-norm=1
magnit :: (Element t, Normed (Vector t)) => R -> t -> Bool #
Check if the absolute value or complex magnitude is greater than a given threshold
>>>magnit 1E-6 (1E-12 :: R)False>>>magnit 1E-6 (3+iC :: C)True>>>magnit 0 (3 :: I ./. 5)True
norm_nuclear :: Field t => Matrix t -> R #
Sum of singular values (Schatten p-norm with p=1)
norm_Frob :: (Normed (Vector t), Element t) => Matrix t -> R #
Frobenius norm (Schatten p-norm with p=2)
(¿) :: Element t => Matrix t -> [Int] -> Matrix t infixl 9 #
extract columns
(unicode 0x00bf, inverted question mark, Alt-Gr ?)
>>>(3><4) [1..] ¿ [3,0](3><2) [ 4.0, 1.0 , 8.0, 5.0 , 12.0, 9.0 ]
(?) :: Element t => Matrix t -> [Int] -> Matrix t infixl 9 #
extract rows
>>>(20><4) [1..] ? [2,1,1](3><4) [ 9.0, 10.0, 11.0, 12.0 , 5.0, 6.0, 7.0, 8.0 , 5.0, 6.0, 7.0, 8.0 ]
col :: [Double] -> Matrix Double #
create a single column real matrix from a list
>>>col [7,-2,4](3><1) [ 7.0 , -2.0 , 4.0 ]
row :: [Double] -> Matrix Double #
create a single row real matrix from a list
>>>row [2,3,1,8](1><4) [ 2.0, 3.0, 1.0, 8.0 ]
(|||) :: Element t => Matrix t -> Matrix t -> Matrix t infixl 3 #
horizontal concatenation
>>>ident 3 ||| konst 7 (3,4)(3><7) [ 1.0, 0.0, 0.0, 7.0, 7.0, 7.0, 7.0 , 0.0, 1.0, 0.0, 7.0, 7.0, 7.0, 7.0 , 0.0, 0.0, 1.0, 7.0, 7.0, 7.0, 7.0 ]
diagl :: [Double] -> Matrix Double #
create a real diagonal matrix from a list
>>>diagl [1,2,3](3><3) [ 1.0, 0.0, 0.0 , 0.0, 2.0, 0.0 , 0.0, 0.0, 3.0 ]
disp :: Int -> Matrix Double -> IO () #
print a real matrix with given number of digits after the decimal point
>>>disp 5 $ ident 2 / 32x2 0.33333 0.00000 0.00000 0.33333
Create a real matrix.
>>>matrix 5 [1..15](3><5) [ 1.0, 2.0, 3.0, 4.0, 5.0 , 6.0, 7.0, 8.0, 9.0, 10.0 , 11.0, 12.0, 13.0, 14.0, 15.0 ]
p-norm for vectors, operator norm for matrices
class Indexable c t | c -> t, t -> c where #
Alternative indexing function.
>>>vector [1..10] ! 34.0
On a matrix it gets the k-th row as a vector:
>>>matrix 5 [1..15] ! 1fromList [6.0,7.0,8.0,9.0,10.0]
>>>matrix 5 [1..15] ! 1 ! 39.0
Minimal complete definition
Instances
| Indexable (Vector Double) Double | |
| Indexable (Vector Float) Float | |
| Indexable (Vector I) I | |
| Indexable (Vector Z) Z | |
| Element t => Indexable (Matrix t) (Vector t) | |
| Indexable (Vector (Complex Double)) (Complex Double) | |
| Indexable (Vector (Complex Float)) (Complex Float) | |
| (Storable t, Indexable (Vector t) t) => Indexable (Vector (Mod m t)) (Mod m t) | |
separable :: Element t => (Vector t -> Vector t) -> Matrix t -> Matrix t #
matrix computation implemented as separated vector operations by rows and columns.
Arguments
| :: (Num (Matrix a), Product a, Container Vector a) | |
| => Matrix a | kernel |
| -> Matrix a | |
| -> Matrix a |
2D convolution
>>>disp 5 $ conv2 (konst 1 (3,3)) (ident 10 :: Matrix Double)12x12 1 1 1 0 0 0 0 0 0 0 0 0 1 2 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 3 2 1 0 0 0 0 0 0 0 0 1 2 2 1 0 0 0 0 0 0 0 0 0 1 1 1
corr2 :: Product a => Matrix a -> Matrix a -> Matrix a #
2D correlation (without padding)
>>>disp 5 $ corr2 (konst 1 (3,3)) (ident 10 :: Matrix Double)8x8 3 2 1 0 0 0 0 0 2 3 2 1 0 0 0 0 1 2 3 2 1 0 0 0 0 1 2 3 2 1 0 0 0 0 1 2 3 2 1 0 0 0 0 1 2 3 2 1 0 0 0 0 1 2 3 2 0 0 0 0 0 1 2 3
conv :: (Container Vector t, Product t, Num t) => Vector t -> Vector t -> Vector t #
convolution (corr with reversed kernel and padded input, equivalent to polynomial product)
>>>conv (fromList[1,1]) (fromList [-1,1])fromList [-1.0,0.0,1.0]
correlation
>>>corr (fromList[1,2,3]) (fromList [1..10])fromList [14.0,20.0,26.0,32.0,38.0,44.0,50.0,56.0]
remap :: Element t => Matrix I -> Matrix I -> Matrix t -> Matrix t #
Extract elements from positions given in matrices of rows and columns.
>>>r(3><3) [ 1, 1, 1 , 1, 2, 2 , 1, 2, 3 ]>>>c(3><3) [ 0, 1, 5 , 2, 2, 1 , 4, 4, 1 ]>>>m(4><6) [ 0, 1, 2, 3, 4, 5 , 6, 7, 8, 9, 10, 11 , 12, 13, 14, 15, 16, 17 , 18, 19, 20, 21, 22, 23 ]
>>>remap r c m(3><3) [ 6, 7, 11 , 8, 14, 13 , 10, 16, 19 ]
The indexes are autoconformable.
>>>c'(3><1) [ 1 , 2 , 4 ]>>>remap r c' m(3><3) [ 7, 7, 7 , 8, 14, 14 , 10, 16, 22 ]
sortIndex :: (Ord t, Element t) => Vector t -> Vector I #
>>>m <- randn 4 10>>>disp 2 m4x10 -0.31 0.41 0.43 -0.19 -0.17 -0.23 -0.17 -1.04 -0.07 -1.24 0.26 0.19 0.14 0.83 -1.54 -0.09 0.37 -0.63 0.71 -0.50 -0.11 -0.10 -1.29 -1.40 -1.04 -0.89 -0.68 0.35 -1.46 1.86 1.04 -0.29 0.19 -0.75 -2.20 -0.01 1.06 0.11 -2.09 -1.58
>>>disp 2 $ m ?? (All, Pos $ sortIndex (m!1))4x10 -0.17 -1.04 -1.24 -0.23 0.43 0.41 -0.31 -0.17 -0.07 -0.19 -1.54 -0.63 -0.50 -0.09 0.14 0.19 0.26 0.37 0.71 0.83 -1.04 0.35 1.86 -0.89 -1.29 -0.10 -0.11 -0.68 -1.46 -1.40 -2.20 0.11 -1.58 -0.01 0.19 -0.29 1.04 1.06 -2.09 -0.75
meanCov :: Matrix Double -> (Vector Double, Herm Double) #
Compute mean vector and covariance matrix of the rows of a matrix.
>>>meanCov $ gaussianSample 666 1000 (fromList[4,5]) (diagl[2,3])(fromList [4.010341078059521,5.0197204699640405], (2><2) [ 1.9862461923890056, -1.0127225830525157e-2 , -1.0127225830525157e-2, 3.0373954915729318 ])
(<\>) :: (LSDiv c, Field t) => Matrix t -> c t -> c t infixl 7 #
Least squares solution of a linear system, similar to the \ operator of Matlab/Octave (based on linearSolveSVD)
a = (3><2) [ 1.0, 2.0 , 2.0, 4.0 , 2.0, -1.0 ]
v = vector [13.0,27.0,1.0]
>>>let x = a <\> v>>>xfromList [3.0799999999999996,5.159999999999999]
>>>a #> xfromList [13.399999999999999,26.799999999999997,1.0]
It also admits multiple right-hand sides stored as columns in a matrix.
(#>) :: Numeric t => Matrix t -> Vector t -> Vector t infixr 8 #
dense matrix-vector product
>>>let m = (2><3) [1..]>>>m(2><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 ]
>>>let v = vector [10,20,30]
>>>m #> vfromList [140.0,320.0]
(<.>) :: Numeric t => Vector t -> Vector t -> t infixr 8 #
An infix synonym for dot
>>>vector [1,2,3,4] <.> vector [-2,0,1,1]5.0
>>>let 𝑖 = 0:+1 :: C>>>fromList [1+𝑖,1] <.> fromList [1,1+𝑖]2.0 :+ 0.0
linspace :: (Fractional e, Container Vector e) => Int -> (e, e) -> Vector e #
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)
Minimal complete definition
linSolve
class Build d f (c :: * -> *) e | d -> c, c -> d, f -> e, f -> d, f -> c, c e -> f, d e -> f where #
Minimal complete definition
Methods
>>>build 5 (**2) :: Vector DoublefromList [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 33x3 1.00 0.50 0.33 0.50 0.33 0.25 0.33 0.25 0.20
randn :: Int -> Int -> IO (Matrix Double) #
pseudorandom matrix with normal elements
>>>disp 3 =<< randn 3 53x5 0.386 -1.141 0.491 -0.510 1.512 0.069 -0.919 1.022 -0.181 0.745 0.313 -0.670 -0.097 -1.575 -0.583
Arguments
| :: Seed | |
| -> Int | number of rows |
| -> [(Double, Double)] | ranges for each column |
| -> Matrix Double | result |
Obtains a matrix whose rows are pseudorandom samples from a multivariate uniform distribution.
Arguments
| :: Seed | |
| -> Int | number of rows |
| -> Vector Double | mean vector |
| -> Herm Double | covariance matrix |
| -> Matrix Double | result |
Obtains a matrix whose rows are pseudorandom samples from a multivariate Gaussian distribution.
sym :: Field t => Matrix t -> Herm t #
Compute the complex Hermitian or real symmetric part of a square matrix ((x + tr x)/2).
Extract the general matrix from a Herm structure, forgetting its symmetric or Hermitian property.
Generalized symmetric positive definite eigensystem Av = lBv, for A and B symmetric, B positive definite.
relativeError :: Num a => (a -> Double) -> a -> a -> Double #
luFact :: Numeric t => LU t -> (Matrix t, Matrix t, Matrix t, t) #
Compute the explicit LU decomposition from the compact one obtained by luPacked.
sqrtm :: Field t => Matrix t -> Matrix t #
Matrix square root. Currently it uses a simple iterative algorithm described in Wikipedia. It only works with invertible matrices that have a real solution.
m = (2><2) [4,9
,0,4] :: Matrix Double>>>sqrtm m(2><2) [ 2.0, 2.25 , 0.0, 2.0 ]
For diagonalizable matrices you can try matFunc sqrt:
>>>matFunc sqrt ((2><2) [1,0,0,-1])(2><2) [ 1.0 :+ 0.0, 0.0 :+ 0.0 , 0.0 :+ 0.0, 0.0 :+ 1.0 ]
expm :: Field t => Matrix t -> Matrix t #
Matrix exponential. It uses a direct translation of Algorithm 11.3.1 in Golub & Van Loan, based on a scaled Pade approximation.
matFunc :: (Complex Double -> Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double) #
Generic matrix functions for diagonalizable matrices. For instance:
logm = matFunc log
rcond :: Field t => Matrix t -> Double #
Reciprocal of the 2-norm condition number of a matrix, computed from the singular values.
haussholder :: Field a => a -> Vector a -> Matrix a #
Arguments
| :: Field t | |
| => Either Double Int | Left "numeric" zero (eg. 1* |
| -> Matrix t | input matrix m |
| -> (Matrix t, Vector Double) |
|
| -> Matrix t | orth |
The range space a matrix from its precomputed SVD decomposition.
Arguments
| :: Field t | |
| => Either Double Int | Left "numeric" zero (eg. 1* |
| -> Matrix t | input matrix m |
| -> (Vector Double, Matrix t) |
|
| -> Matrix t | nullspace |
The nullspace of a matrix from its precomputed SVD decomposition.
Arguments
| :: Double | numeric zero (e.g. 1* |
| -> Int | maximum dimension of the matrix |
| -> [Double] | singular values |
| -> Int | rank of m |
Numeric rank of a matrix from its singular values.
pinvTol :: Field t => Double -> Matrix t -> Matrix t #
pinvTol r computes the pseudoinverse of a matrix with tolerance tol=r*g*eps*(max rows cols), where g is the greatest singular value.
m = (3><3) [ 1, 0, 0
, 0, 1, 0
, 0, 0, 1e-10] :: Matrix Double
>>>pinv m1. 0. 0. 0. 1. 0. 0. 0. 10000000000.
>>>pinvTol 1E8 m1. 0. 0. 0. 1. 0. 0. 0. 1.
pinv :: Field t => Matrix t -> Matrix t #
Pseudoinverse of a general matrix with default tolerance (pinvTol 1, similar to GNU-Octave).
lu :: Field t => Matrix t -> (Matrix t, Matrix t, Matrix t, t) #
Explicit LU factorization of a general matrix.
If (l,u,p,s) = lu m then m == p <> l <> u, where l is lower triangular,
u is upper triangular, p is a permutation matrix and s is the signature of the permutation.
det :: Field t => Matrix t -> t #
Determinant of a square matrix. To avoid possible overflow or underflow use invlndet.
Joint computation of inverse and logarithm of determinant of a square matrix.
chol :: Field t => Herm t -> Matrix t #
Cholesky factorization of a positive definite hermitian or symmetric matrix.
If c = chol m then c is upper triangular and m == tr c <> c.
schur :: Field t => Matrix t -> (Matrix t, Matrix t) #
Schur factorization.
If (u,s) = schur m then m == u <> s <> tr u, where u is unitary
and s is a Shur matrix. A complex Schur matrix is upper triangular. A real Schur matrix is
upper triangular in 2x2 blocks.
"Anything that the Jordan decomposition can do, the Schur decomposition can do better!" (Van Loan)
hess :: Field t => Matrix t -> (Matrix t, Matrix t) #
Hessenberg factorization.
If (p,h) = hess m then m == p <> h <> tr p, where p is unitary
and h is in upper Hessenberg form (it has zero entries below the first subdiagonal).
thinRQ :: Field t => Matrix t -> (Matrix t, Matrix t) #
A version of rq which returns only the min (rows m) (cols m) columns of r and rows of q.
rq :: Field t => Matrix t -> (Matrix t, Matrix t) #
RQ factorization.
If (r,q) = rq m then m == r <> q, where q is unitary and r is upper triangular.
Note: the current implementation is very slow for large matrices. thinRQ is much faster.
qrgr :: Field t => Int -> QR t -> Matrix t #
generate a matrix with k orthogonal columns from the compact QR decomposition obtained by qrRaw.
thinQR :: Field t => Matrix t -> (Matrix t, Matrix t) #
A version of qr which returns only the min (rows m) (cols m) columns of q and rows of r.
qr :: Field t => Matrix t -> (Matrix t, Matrix t) #
QR factorization.
If (q,r) = qr m then m == q <> r, where q is unitary and r is upper triangular.
Note: the current implementation is very slow for large matrices. thinQR is much faster.
eigenvaluesSH :: Field t => Herm t -> Vector Double #
Eigenvalues (in descending order) of a complex hermitian or real symmetric matrix.
eigSH :: Field t => Herm t -> (Vector Double, Matrix t) #
Eigenvalues and eigenvectors (as columns) of a complex hermitian or real symmetric matrix, in descending order.
If (s,v) = eigSH m then m == v <> diag s <> tr v
a = (3><3) [ 1.0, 2.0, 3.0 , 2.0, 4.0, 5.0 , 3.0, 5.0, 6.0 ]
>>>let (l, v) = eigSH a
>>>lfromList [11.344814282762075,0.17091518882717918,-0.5157294715892575]
>>>disp 3 $ v <> diag l <> tr v3x3 1.000 2.000 3.000 2.000 4.000 5.000 3.000 5.000 6.000
eigenvalues :: Field t => Matrix t -> Vector (Complex Double) #
Eigenvalues (not ordered) of a general square matrix.
eig :: Field t => Matrix t -> (Vector (Complex Double), Matrix (Complex Double)) #
Eigenvalues (not ordered) and eigenvectors (as columns) of a general square matrix.
If (s,v) = eig m then m <> v == v <> diag s
a = (3><3) [ 3, 0, -2 , 4, 5, -1 , 3, 1, 0 ] :: Matrix Double
>>>let (l, v) = eig a
>>>putStr . dispcf 3 . asRow $ l1x3 1.925+1.523i 1.925-1.523i 4.151
>>>putStr . dispcf 3 $ v3x3 -0.455+0.365i -0.455-0.365i 0.181 0.603 0.603 -0.978 0.033+0.543i 0.033-0.543i -0.104
>>>putStr . dispcf 3 $ complex a <> v3x3 -1.432+0.010i -1.432-0.010i 0.753 1.160+0.918i 1.160-0.918i -4.059 -0.763+1.096i -0.763-1.096i -0.433
>>>putStr . dispcf 3 $ v <> diag l3x3 -1.432+0.010i -1.432-0.010i 0.753 1.160+0.918i 1.160-0.918i -4.059 -0.763+1.096i -0.763-1.096i -0.433
ldlSolve :: Field t => LDL t -> Matrix t -> Matrix t #
Solution of a linear system (for several right hand sides) from a precomputed LDL factorization obtained by ldlPacked.
Note: this can be slower than the general solver based on the LU decomposition.
ldlPacked :: Field t => Herm t -> LDL t #
Obtains the LDL decomposition of a matrix in a compact data structure suitable for ldlSolve.
linearSolveLS :: Field t => Matrix t -> Matrix t -> Matrix t #
Least squared error solution of an overconstrained linear system, or the minimum norm solution of an underconstrained system. For rank-deficient systems use linearSolveSVD.
linearSolveSVD :: Field t => Matrix t -> Matrix t -> Matrix t #
Minimum norm solution of a general linear least squares problem Ax=B using the SVD. Admits rank-deficient systems but it is slower than linearSolveLS. The effective rank of A is determined by treating as zero those singular valures which are less than eps times the largest singular value.
Arguments
| :: Field t | |
| => Vector t | lower diagonal: \(n - 1\) elements |
| -> Vector t | diagonal: \(n\) elements |
| -> Vector t | upper diagonal: \(n - 1\) elements |
| -> Matrix t | right hand sides |
| -> Matrix t | solution |
Solve a tridiagonal linear system. Suppose you wish to solve \(Ax = b\) where
\[ A = \begin{bmatrix} 1.0 & 4.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\ 3.0 & 1.0 & 4.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\ 0.0 & 3.0 & 1.0 & 4.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 \\ 0.0 & 0.0 & 3.0 & 1.0 & 4.0 & 0.0 & 0.0 & 0.0 & 0.0 \\ 0.0 & 0.0 & 0.0 & 3.0 & 1.0 & 4.0 & 0.0 & 0.0 & 0.0 \\ 0.0 & 0.0 & 0.0 & 0.0 & 3.0 & 1.0 & 4.0 & 0.0 & 0.0 \\ 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 3.0 & 1.0 & 4.0 & 0.0 \\ 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 3.0 & 1.0 & 4.0 \\ 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 0.0 & 3.0 & 1.0 \end{bmatrix} \quad b = \begin{bmatrix} 1.0 & 1.0 & 1.0 \\ 1.0 & -1.0 & 2.0 \\ 1.0 & 1.0 & 3.0 \\ 1.0 & -1.0 & 4.0 \\ 1.0 & 1.0 & 5.0 \\ 1.0 & -1.0 & 6.0 \\ 1.0 & 1.0 & 7.0 \\ 1.0 & -1.0 & 8.0 \\ 1.0 & 1.0 & 9.0 \end{bmatrix} \]
then
dL = fromList [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0]
d = fromList [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
dU = fromList [4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0]
b = (9><3)
[
1.0, 1.0, 1.0,
1.0, -1.0, 2.0,
1.0, 1.0, 3.0,
1.0, -1.0, 4.0,
1.0, 1.0, 5.0,
1.0, -1.0, 6.0,
1.0, 1.0, 7.0,
1.0, -1.0, 8.0,
1.0, 1.0, 9.0
]
x = triDiagSolve dL d dU b
Arguments
| :: Field t | |
| => Matrix t | Cholesky decomposition of the coefficient matrix |
| -> Matrix t | right hand sides |
| -> Matrix t | solution |
Solve a symmetric or Hermitian positive definite linear system using a precomputed Cholesky decomposition obtained by chol.
luSolve :: Field t => LU t -> Matrix t -> Matrix t #
Solution of a linear system (for several right hand sides) from the precomputed LU factorization obtained by luPacked.
luPacked :: Field t => Matrix t -> LU t #
Obtains the LU decomposition of a matrix in a compact data structure suitable for luSolve.
leftSV :: Field t => Matrix t -> (Matrix t, Vector Double) #
Singular values and all left singular vectors (as columns).
rightSV :: Field t => Matrix t -> (Vector Double, Matrix t) #
Singular values and all right singular vectors (as columns).
compactSVDTol :: Field t => Double -> Matrix t -> (Matrix t, Vector Double, Matrix t) #
compactSVDTol r is similar to compactSVD (for which r=1), but uses tolerance tol=r*g*eps*(max rows cols) to distinguish nonzero singular values, where g is the greatest singular value. If g<r*eps, then only one singular value is returned.
compactSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t) #
Similar to thinSVD, returning only the nonzero singular values and the corresponding singular vectors.
a = (5><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 , 7.0, 8.0, 9.0 , 10.0, 11.0, 12.0 , 13.0, 14.0, 15.0 ] :: Matrix Double
>>>let (u,s,v) = compactSVD a
>>>disp 3 u5x2 -0.101 0.768 -0.249 0.488 -0.396 0.208 -0.543 -0.072 -0.690 -0.352
>>>sfromList [35.18264833189422,1.4769076999800903]
>>>disp 3 u5x2 -0.101 0.768 -0.249 0.488 -0.396 0.208 -0.543 -0.072 -0.690 -0.352
>>>disp 3 $ u <> diag s <> tr v5x3 1.000 2.000 3.000 4.000 5.000 6.000 7.000 8.000 9.000 10.000 11.000 12.000 13.000 14.000 15.000
thinSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t) #
A version of svd which returns only the min (rows m) (cols m) singular vectors of m.
If (u,s,v) = thinSVD m then m == u <> diag s <> tr v.
a = (5><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 , 7.0, 8.0, 9.0 , 10.0, 11.0, 12.0 , 13.0, 14.0, 15.0 ] :: Matrix Double
>>>let (u,s,v) = thinSVD a
>>>disp 3 u5x3 -0.101 0.768 0.614 -0.249 0.488 -0.503 -0.396 0.208 -0.405 -0.543 -0.072 -0.140 -0.690 -0.352 0.433
>>>sfromList [35.18264833189422,1.4769076999800903,1.089145439970417e-15]
>>>disp 3 v3x3 -0.519 -0.751 0.408 -0.576 -0.046 -0.816 -0.632 0.659 0.408
>>>disp 3 $ u <> diag s <> tr v5x3 1.000 2.000 3.000 4.000 5.000 6.000 7.000 8.000 9.000 10.000 11.000 12.000 13.000 14.000 15.000
svd :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t) #
Full singular value decomposition.
a = (5><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 , 7.0, 8.0, 9.0 , 10.0, 11.0, 12.0 , 13.0, 14.0, 15.0 ] :: Matrix Double
>>>let (u,s,v) = svd a
>>>disp 3 u5x5 -0.101 0.768 0.614 0.028 -0.149 -0.249 0.488 -0.503 0.172 0.646 -0.396 0.208 -0.405 -0.660 -0.449 -0.543 -0.072 -0.140 0.693 -0.447 -0.690 -0.352 0.433 -0.233 0.398
>>>sfromList [35.18264833189422,1.4769076999800903,1.089145439970417e-15]
>>>disp 3 v3x3 -0.519 -0.751 0.408 -0.576 -0.046 -0.816 -0.632 0.659 0.408
>>>let d = diagRect 0 s 5 3>>>disp 3 d5x3 35.183 0.000 0.000 0.000 1.477 0.000 0.000 0.000 0.000 0.000 0.000 0.000
>>>disp 3 $ u <> d <> tr v5x3 1.000 2.000 3.000 4.000 5.000 6.000 7.000 8.000 9.000 10.000 11.000 12.000 13.000 14.000 15.000
class (Numeric t, Convert t, Normed Matrix t, Normed Vector t, Floating t, Linear t Vector, Linear t Matrix, Additive (Vector t), Additive (Matrix t), RealOf t ~ Double) => Field t #
Generic linear algebra functions for double precision real and complex matrices.
(Single precision data can be converted using single and double).
Minimal complete definition
svd', thinSVD', sv', luPacked', luSolve', mbLinearSolve', linearSolve', cholSolve', triSolve', triDiagSolve', ldlPacked', ldlSolve', linearSolveSVD', linearSolveLS', eig', eigSH'', eigOnly, eigOnlySH, cholSH', mbCholSH', qr', qrgr', hess', schur'
Instances
LU decomposition of a matrix in a compact format.
LDL decomposition of a complex Hermitian or real symmetric matrix in a compact format.
QR decomposition of a matrix in compact form. (The orthogonal matrix is not explicitly formed.)
A matrix that, by construction, it is known to be complex Hermitian or real symmetric.
It can be created using sym, mTm, or trustSym, and the matrix can be extracted using unSym.
toDense :: AssocMatrix -> Matrix Double #
(!#>) :: GMatrix -> Vector Double -> Vector Double infixr 8 #
general matrix - vector product
>>>let m = mkSparse [((0,999),1.0),((1,1999),2.0)]>>>m !#> vector [1..2000]fromList [1000.0,4000.0]
mkSparse :: AssocMatrix -> GMatrix #
type AssocMatrix = [((Int, Int), Double)] #
General matrix with specialized internal representations for dense, sparse, diagonal, banded, and constant elements.
>>>let m = mkSparse [((0,999),1.0),((1,1999),2.0)]>>>mSparseR {gmCSR = CSR {csrVals = fromList [1.0,2.0], csrCols = fromList [1000,2000], csrRows = fromList [1,2,3], csrNRows = 2, csrNCols = 2000}, nRows = 2, nCols = 2000}
>>>let m = mkDense (mat 2 [1..4])>>>mDense {gmDense = (2><2) [ 1.0, 2.0 , 3.0, 4.0 ], nRows = 2, nCols = 2}
kronecker :: Product t => Matrix t -> Matrix t -> Matrix t #
Kronecker product of two matrices.
m1=(2><3) [ 1.0, 2.0, 0.0 , 0.0, -1.0, 3.0 ] m2=(4><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 , 7.0, 8.0, 9.0 , 10.0, 11.0, 12.0 ]
>>>kronecker m1 m2(8><9) [ 1.0, 2.0, 3.0, 2.0, 4.0, 6.0, 0.0, 0.0, 0.0 , 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 0.0, 0.0, 0.0 , 7.0, 8.0, 9.0, 14.0, 16.0, 18.0, 0.0, 0.0, 0.0 , 10.0, 11.0, 12.0, 20.0, 22.0, 24.0, 0.0, 0.0, 0.0 , 0.0, 0.0, 0.0, -1.0, -2.0, -3.0, 3.0, 6.0, 9.0 , 0.0, 0.0, 0.0, -4.0, -5.0, -6.0, 12.0, 15.0, 18.0 , 0.0, 0.0, 0.0, -7.0, -8.0, -9.0, 21.0, 24.0, 27.0 , 0.0, 0.0, 0.0, -10.0, -11.0, -12.0, 30.0, 33.0, 36.0 ]
outer :: Product t => Vector t -> Vector t -> Matrix t #
Outer product of two vectors.
>>>fromList [1,2,3] `outer` fromList [5,2,3](3><3) [ 5.0, 2.0, 3.0 , 10.0, 4.0, 6.0 , 15.0, 6.0, 9.0 ]
Arguments
| :: Container c e | |
| => c e | initial structure |
| -> (e -> e -> e) | update function |
| -> [(IndexOf c, e)] | association list |
| -> c e | result |
Modify a structure using an update function
>>>accum (ident 5) (+) [((1,1),5),((0,3),3)] :: Matrix Double(5><5) [ 1.0, 0.0, 0.0, 3.0, 0.0 , 0.0, 6.0, 0.0, 0.0, 0.0 , 0.0, 0.0, 1.0, 0.0, 0.0 , 0.0, 0.0, 0.0, 1.0, 0.0 , 0.0, 0.0, 0.0, 0.0, 1.0 ]
computation of histogram:
>>>accum (konst 0 7) (+) (map (flip (,) 1) [4,5,4,1,5,2,5]) :: Vector DoublefromList [0.0,1.0,1.0,0.0,2.0,3.0,0.0]
Arguments
| :: Container c e | |
| => IndexOf c | size |
| -> e | default value |
| -> [(IndexOf c, e)] | association list |
| -> c e | result |
Create a structure from an association list
>>>assoc 5 0 [(3,7),(1,4)] :: Vector DoublefromList [0.0,4.0,0.0,7.0,0.0]
>>>assoc (2,3) 0 [((0,2),7),((1,0),2*i-3)] :: Matrix (Complex Double)(2><3) [ 0.0 :+ 0.0, 0.0 :+ 0.0, 7.0 :+ 0.0 , (-3.0) :+ 2.0, 0.0 :+ 0.0, 0.0 :+ 0.0 ]
find :: Container c e => (e -> Bool) -> c e -> [IndexOf c] #
Find index of elements which satisfy a predicate
>>>find (>0) (ident 3 :: Matrix Double)[(0,0),(1,1),(2,2)]
Element by element version of case compare a b of {LT -> l; EQ -> e; GT -> g}.
Arguments with any dimension = 1 are automatically expanded:
>>>cond ((1><4)[1..]) ((3><1)[1..]) 0 100 ((3><4)[1..]) :: Matrix Double(3><4) [ 100.0, 2.0, 3.0, 4.0 , 0.0, 100.0, 7.0, 8.0 , 0.0, 0.0, 100.0, 12.0 ]
>>>let chop x = cond (abs x) 1E-6 0 0 x
step :: (Ord e, Container c e) => c e -> c e #
A more efficient implementation of cmap (\x -> if x>0 then 1 else 0)
>>>step $ linspace 5 (-1,1::Double)5 |> [0.0,0.0,0.0,1.0,1.0]
prodElements :: Container c e => c e -> e #
the product of elements
sumElements :: Container c e => c e -> e #
the sum of elements
maxElement :: Container c e => c e -> e #
value of maximum element
minElement :: Container c e => c e -> e #
value of minimum element
atIndex :: Container c e => c e -> IndexOf c -> e #
generic indexing function
>>>vector [1,2,3] `atIndex` 12.0
>>>matrix 3 [0..8] `atIndex` (2,0)6.0
cmap :: (Element b, Container c e) => (e -> b) -> c e -> c b #
like fmap (cannot implement instance Functor because of Element class constraint)
fromInt :: Container c e => c I -> c e #
>>>fromInt ((2><2) [0..3]) :: Matrix (Complex Double)(2><2) [ 0.0 :+ 0.0, 1.0 :+ 0.0 , 2.0 :+ 0.0, 3.0 :+ 0.0 ]
cmod :: (Integral e, Container c e) => e -> c e -> c e #
mod for integer arrays
>>>cmod 3 (range 5)fromList [0,1,2,0,1]
arctan2 :: (Fractional e, Container c e) => c e -> c e -> c e #
scalar :: Container c e => e -> c e #
create a structure with a single element
>>>let v = fromList [1..3::Double]>>>v / scalar (norm2 v)fromList [0.2672612419124244,0.5345224838248488,0.8017837257372732]
class Element e => Container (c :: * -> *) e #
Basic element-by-element functions for numeric containers
Minimal complete definition
conj', size', scalar', scale', addConstant, add', sub, mul, equal, cmap', konst', build', atIndex', minIndex', maxIndex', minElement', maxElement', sumElements', prodElements', step', ccompare', cselect', find', assoc', accum', scaleRecip, divide, arctan2', cmod', fromInt', toInt', fromZ', toZ'
Instances
class Konst e d (c :: * -> *) | d -> c, c -> d where #
Minimal complete definition
Methods
>>>konst 7 3 :: Vector FloatfromList [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 ]
class (Container Vector t, Container Matrix t, Konst t Int Vector, Konst t (Int, Int) Matrix, CTrans t, Product t, Additive (Vector t), Additive (Matrix t), Linear t Vector, Linear t Matrix) => Numeric t #
Instances
| Numeric Double | |
Defined in Internal.Numeric | |
| Numeric Float | |
Defined in Internal.Numeric | |
| Numeric I | |
Defined in Internal.Numeric | |
| Numeric Z | |
Defined in Internal.Numeric | |
| Numeric (Complex Double) | |
Defined in Internal.Numeric | |
| Numeric (Complex Float) | |
Defined in Internal.Numeric | |
| KnownNat m => Numeric (Mod m I) | |
Defined in Internal.Modular | |
| KnownNat m => Numeric (Mod m Z) | |
Defined in Internal.Modular | |
class (Num e, Element e) => Product e #
Matrix product and related functions
Minimal complete definition
multiply, absSum, norm1, norm2, normInf
Instances
| Product Double | |
| Product Float | |
| Product I | |
| Product Z | |
| Product (Complex Double) | |
Defined in Internal.Numeric Methods multiply :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double) absSum :: Vector (Complex Double) -> RealOf (Complex Double) norm1 :: Vector (Complex Double) -> RealOf (Complex Double) norm2 :: Vector (Complex Double) -> RealOf (Complex Double) normInf :: Vector (Complex Double) -> RealOf (Complex Double) | |
| Product (Complex Float) | |
| KnownNat m => Product (Mod m I) | |
| KnownNat m => Product (Mod m Z) | |
Methods
real :: Complexable c => c (RealOf t) -> c t #
complex :: Complexable c => c t -> c (ComplexOf t) #
single :: Complexable c => c t -> c (SingleOf t) #
double :: Complexable c => c t -> c (DoubleOf t) #
toComplex :: (Complexable c, RealElement t) => (c t, c t) -> c (Complex t) #
fromComplex :: (Complexable c, RealElement t) => c (Complex t) -> (c t, c t) #
Instances
Instances
| type RealOf Double | |
Defined in Internal.Numeric | |
| type RealOf Float | |
Defined in Internal.Numeric | |
| type RealOf I | |
Defined in Internal.Numeric | |
| type RealOf Z | |
Defined in Internal.Numeric | |
| type RealOf (Complex Double) | |
Defined in Internal.Numeric | |
| type RealOf (Complex Float) | |
Defined in Internal.Numeric | |
| type RealOf (Mod n Z) | |
Defined in Internal.Modular | |
| type RealOf (Mod n I) | |
Defined in Internal.Modular | |
class Transposable m mt | m -> mt, mt -> m where #
Instances
| Transposable CSR CSC | |
| Transposable GMatrix GMatrix | |
| Transposable CSC CSR | |
| (CTrans t, Container Vector t) => Transposable (Matrix t) (Matrix t) | |
Minimal complete definition
class Linear t (c :: * -> *) where #
Minimal complete definition
Instances
| Container Vector t => Linear t Vector | |
Defined in Internal.Numeric | |
| Field t => Linear t Herm | |
Defined in Internal.Algorithms | |
| Container Matrix t => Linear t Matrix | |
Defined in Internal.Numeric | |
Minimal complete definition
class (Element t, Element (Complex t), RealFloat t) => RealElement t #
Supported real types
Instances
| RealElement Double | |
Defined in Internal.Conversion | |
| RealElement Float | |
Defined in Internal.Conversion | |
class Complexable (c :: * -> *) #
Structures that may contain complex numbers
Minimal complete definition
toComplex', fromComplex', comp', single', double'
Instances
| Complexable Matrix | |
Defined in Internal.Conversion Methods toComplex' :: RealElement e => (Matrix e, Matrix e) -> Matrix (Complex e) fromComplex' :: RealElement e => Matrix (Complex e) -> (Matrix e, Matrix e) comp' :: RealElement e => Matrix e -> Matrix (Complex e) | |
| Complexable Vector | |
Defined in Internal.Conversion Methods toComplex' :: RealElement e => (Vector e, Vector e) -> Vector (Complex e) fromComplex' :: RealElement e => Vector (Complex e) -> (Vector e, Vector e) comp' :: RealElement e => Vector e -> Vector (Complex e) | |
toBlocksEvery :: Element t => Int -> Int -> Matrix t -> [[Matrix t]] #
Fully partition a matrix into blocks of the same size. If the dimensions are not a multiple of the given size the last blocks will be smaller.
toBlocks :: Element t => [Int] -> [Int] -> Matrix t -> [[Matrix t]] #
Partition a matrix into blocks with the given numbers of rows and columns. The remaining rows and columns are discarded.
repmat :: Element t => Matrix t -> Int -> Int -> Matrix t #
creates matrix by repetition of a matrix a given number of rows and columns
>>>repmat (ident 2) 2 3(4><6) [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 , 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 ]
asColumn :: Storable a => Vector a -> Matrix a #
creates a 1-column matrix from a vector
>>>asColumn (fromList [1..5])(5><1) [ 1.0 , 2.0 , 3.0 , 4.0 , 5.0 ]
asRow :: Storable a => Vector a -> Matrix a #
creates a 1-row matrix from a vector
>>>asRow (fromList [1..5])(1><5) [ 1.0, 2.0, 3.0, 4.0, 5.0 ]
fromLists :: Element t => [[t]] -> Matrix t #
Creates a Matrix from a list of lists (considered as rows).
>>>fromLists [[1,2],[3,4],[5,6]](3><2) [ 1.0, 2.0 , 3.0, 4.0 , 5.0, 6.0 ]
(><) :: Storable a => Int -> Int -> [a] -> Matrix a #
Create a matrix from a list of elements
>>>(2><3) [2, 4, 7+2*iC, -3, 11, 0](2><3) [ 2.0 :+ 0.0, 4.0 :+ 0.0, 7.0 :+ 2.0 , (-3.0) :+ (-0.0), 11.0 :+ 0.0, 0.0 :+ 0.0 ]
The input list is explicitly truncated, so that it can safely be used with lists that are too long (like infinite lists).
>>>(2><3)[1..](2><3) [ 1.0, 2.0, 3.0 , 4.0, 5.0, 6.0 ]
This is the format produced by the instances of Show (Matrix a), which can also be used for input.
diagRect :: Storable t => t -> Vector t -> Int -> Int -> Matrix t #
creates a rectangular diagonal matrix:
>>>diagRect 7 (fromList [10,20,30]) 4 5 :: Matrix Double(4><5) [ 10.0, 7.0, 7.0, 7.0, 7.0 , 7.0, 20.0, 7.0, 7.0, 7.0 , 7.0, 7.0, 30.0, 7.0, 7.0 , 7.0, 7.0, 7.0, 7.0, 7.0 ]
diagBlock :: (Element t, Num t) => [Matrix t] -> Matrix t #
create a block diagonal matrix
>>>disp 2 $ diagBlock [konst 1 (2,2), konst 2 (3,5), col [5,7]]7x8 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 2 2 2 2 2 0 0 0 2 2 2 2 2 0 0 0 2 2 2 2 2 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 7
>>>diagBlock [(0><4)[], konst 2 (2,3)] :: Matrix Double(2><7) [ 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0 , 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0 ]
fromBlocks :: Element t => [[Matrix t]] -> Matrix t #
Create a matrix from blocks given as a list of lists of matrices.
Single row-column components are automatically expanded to match the corresponding common row and column:
disp = putStr . dispf 2
>>>disp $ fromBlocks [[ident 5, 7, row[10,20]], [3, diagl[1,2,3], 0]]8x10 1 0 0 0 0 7 7 7 10 20 0 1 0 0 0 7 7 7 10 20 0 0 1 0 0 7 7 7 10 20 0 0 0 1 0 7 7 7 10 20 0 0 0 0 1 7 7 7 10 20 3 3 3 3 3 1 0 0 0 0 3 3 3 3 3 0 2 0 0 0 3 3 3 3 3 0 0 3 0 0
(??) :: Element t => Matrix t -> (Extractor, Extractor) -> Matrix t infixl 9 #
General matrix slicing.
>>>m(4><5) [ 0, 1, 2, 3, 4 , 5, 6, 7, 8, 9 , 10, 11, 12, 13, 14 , 15, 16, 17, 18, 19 ]
>>>m ?? (Take 3, DropLast 2)(3><3) [ 0, 1, 2 , 5, 6, 7 , 10, 11, 12 ]
>>>m ?? (Pos (idxs[2,1]), All)(2><5) [ 10, 11, 12, 13, 14 , 5, 6, 7, 8, 9 ]
>>>m ?? (PosCyc (idxs[-7,80]), Range 4 (-2) 0)(2><3) [ 9, 7, 5 , 4, 2, 0 ]
Specification of indexes for the operator ??.
loadMatrix :: FilePath -> IO (Matrix Double) #
load a matrix from an ASCII file formatted as a 2D table.
dispcf :: Int -> Matrix (Complex Double) -> String #
Pretty print a complex matrix with at most n decimal digits.
Arguments
| :: String | type of braces: "matrix", "bmatrix", "pmatrix", etc. |
| -> String | Formatted matrix, with elements separated by spaces and newlines |
| -> String |
Tool to display matrices with latex syntax.
>>>latexFormat "bmatrix" (dispf 2 $ ident 2)"\\begin{bmatrix}\n1 & 0\n\\\\\n0 & 1\n\\end{bmatrix}"
dispf :: Int -> Matrix Double -> String #
Show a matrix with a given number of decimal places.
>>>dispf 2 (1/3 + ident 3)"3x3\n1.33 0.33 0.33\n0.33 1.33 0.33\n0.33 0.33 1.33\n"
>>>putStr . dispf 2 $ (3><4)[1,1.5..]3x4 1.00 1.50 2.00 2.50 3.00 3.50 4.00 4.50 5.00 5.50 6.00 6.50
>>>putStr . unlines . tail . lines . dispf 2 . asRow $ linspace 10 (0,1)0.00 0.11 0.22 0.33 0.44 0.56 0.67 0.78 0.89 1.00
disps :: Int -> Matrix Double -> String #
Show a matrix with "autoscaling" and a given number of decimal places.
>>>putStr . disps 2 $ 120 * (3><4) [1..]3x4 E3 0.12 0.24 0.36 0.48 0.60 0.72 0.84 0.96 1.08 1.20 1.32 1.44
format :: Element t => String -> (t -> String) -> Matrix t -> String #
Creates a string from a matrix given a separator and a function to show each entry. Using this function the user can easily define any desired display function:
import Text.Printf(printf)
disp = putStr . format " " (printf "%.2f")
save a matrix as a 2D ASCII table
Arguments
| :: Element a | |
| => (Int, Int) | (r0,c0) starting position |
| -> (Int, Int) | (rt,ct) dimensions of submatrix |
| -> Matrix a | input matrix |
| -> Matrix a | result |
reference to a rectangular slice of a matrix (no data copy)
reshape :: Storable t => Int -> Vector t -> Matrix t #
Creates a matrix from a vector by grouping the elements in rows with the desired number of columns. (GNU-Octave groups by columns. To do it you can define reshapeF r = tr' . reshape r
where r is the desired number of rows.)
>>>reshape 4 (fromList [1..12])(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 ]
toColumns :: Element t => Matrix t -> [Vector t] #
Creates a list of vectors from the columns of a matrix
fromColumns :: Element t => [Vector t] -> Matrix t #
Creates a matrix from a list of vectors, as columns
fromRows :: Element t => [Vector t] -> Matrix t #
Create a matrix from a list of vectors. All vectors must have the same dimension, or dimension 1, which is are automatically expanded.
flatten :: Element t => Matrix t -> Vector t #
Creates a vector by concatenation of rows. If the matrix is ColumnMajor, this operation requires a transpose.
>>>flatten (ident 3)fromList [1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0]
Matrix representation suitable for BLAS/LAPACK computations.
Instances
class Storable a => Element a #
Supported matrix elements.
Minimal complete definition
constantD, extractR, setRect, sortI, sortV, compareV, selectV, remapM, rowOp, gemm, reorderV
Instances
Obtains a vector of pseudorandom elements (use randomIO to get a random seed).
Constructors
| Uniform | uniform distribution in [0,1) |
| Gaussian | normal distribution with mean zero and standard deviation one |
Instances
| Enum RandDist | |
Defined in Internal.Vectorized | |
takesV :: Storable t => [Int] -> Vector t -> [Vector t] #
Extract consecutive subvectors of the given sizes.
>>>takesV [3,4] (linspace 10 (1,10::Double))[fromList [1.0,2.0,3.0],fromList [4.0,5.0,6.0,7.0]]
vjoin :: Storable t => [Vector t] -> Vector t #
concatenate a list of vectors
>>>vjoin [fromList [1..5::Double], konst 1 3]fromList [1.0,2.0,3.0,4.0,5.0,1.0,1.0,1.0]
Arguments
| :: Storable t | |
| => Int | index of the starting element |
| -> Int | number of elements to extract |
| -> Vector t | source |
| -> Vector t | result |
takes a number of consecutive elements from a Vector
>>>subVector 2 3 (fromList [1..10])fromList [3.0,4.0,5.0]
Storable-based vectors