Copyright	(c) Alberto Ruiz 2015
License	BSD3
Maintainer	Alberto Ruiz
Stability	provisional
Safe Haskell	None
Language	Haskell98

Numeric.LinearAlgebra.Data

Contents

Elements
Vector
Matrix
Dimensions
Conversion from/to lists
Conversions vector/matrix
Indexing
Construction
Diagonal
Vector extraction
Matrix extraction
Block matrix
Mapping functions
Find elements
Sparse
IO
Element conversion
Misc

Description

This module provides functions for creation and manipulation of vectors and matrices, IO, and other utilities.

Synopsis

Elements

type R = Double #

type C = Complex Double #

type I = CInt #

type Z = Int64 #

type (./.) x n = Mod n x infixr 5 #

Vector

1D arrays are storable vectors directly reexported from the vector package.

fromList :: Storable a => [a] -> Vector a #

O(n) Convert a list to a vector

toList :: Storable a => Vector a -> [a] #

(|>) :: Storable a => Int -> [a] -> Vector a infixl 9 #

Create a vector from a list of elements and explicit dimension. The input list is truncated if it is too long, so it may safely be used, for instance, with infinite lists.

>>> 5 |> [1..]
fromList [1.0,2.0,3.0,4.0,5.0]

vector :: [R] -> Vector R #

Create a real vector.

>>> vector [1..5]
fromList [1.0,2.0,3.0,4.0,5.0]

range :: Int -> Vector I #

>>> range 5
fromList [0,1,2,3,4]

idxs :: [Int] -> Vector I #

Create a vector of indexes, useful for matrix extraction using '(??)'

Matrix

The main data type of hmatrix is a 2D dense array defined on top of a storable vector. The internal representation is suitable for direct interface with standard numeric libraries.

(><) :: 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.

matrix #

Arguments

:: Int	number of columns
-> [R]	elements in row order
-> Matrix R

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 ]

tr :: Transposable m mt => m -> mt #

conjugate transpose

tr' :: Transposable m mt => m -> mt #

transpose

Dimensions

size :: Container c t => c t -> IndexOf c #

>>> size $ vector [1..10]
10
>>> size $ (2><5)[1..10::Double]
(2,5)

rows :: Matrix t -> Int #

cols :: Matrix t -> Int #

Conversion from/to lists

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 ]

toLists :: Element t => Matrix t -> [[t]] #

the inverse of fromLists

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 ]

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 ]

Conversions vector/matrix

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]

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 ]

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 ]

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 ]

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.

toRows :: Element t => Matrix t -> [Vector t] #

extracts the rows of a matrix as a list of vectors

fromColumns :: Element t => [Vector t] -> Matrix t #

Creates a matrix from a list of vectors, as columns

toColumns :: Element t => Matrix t -> [Vector t] #

Creates a list of vectors from the columns of a matrix

Indexing

atIndex :: Container c e => c e -> IndexOf c -> e #

generic indexing function

>>> vector [1,2,3] `atIndex` 1
2.0

>>> matrix 3 [0..8] `atIndex` (2,0)
6.0

class Indexable c t | c -> t, t -> c where #

Alternative indexing function.

>>> vector [1..10] ! 3
4.0

On a matrix it gets the k-th row as a vector:

>>> matrix 5 [1..15] ! 1
fromList [6.0,7.0,8.0,9.0,10.0]

>>> matrix 5 [1..15] ! 1 ! 3
9.0

Minimal complete definition

(!)

Methods

(!) :: c -> Int -> t infixl 9 #

Instances

Indexable (Vector Double) Double #
Methods (!) :: Vector Double -> Int -> Double #
Indexable (Vector Float) Float #
Methods (!) :: Vector Float -> Int -> Float #
Indexable (Vector Z) Z #
Methods (!) :: Vector Z -> Int -> Z #
Indexable (Vector I) I #
Methods (!) :: Vector I -> Int -> I #
Indexable (Vector (Complex Double)) (Complex Double) #
Methods (!) :: Vector (Complex Double) -> Int -> Complex Double #
Indexable (Vector (Complex Float)) (Complex Float) #
Methods (!) :: Vector (Complex Float) -> Int -> Complex Float #
Element t => Indexable (Matrix t) (Vector t) #
Methods (!) :: Matrix t -> Int -> Vector t #
(Storable t, Indexable (Vector t) t) => Indexable (Vector (Mod m t)) (Mod m t) #
Methods (!) :: Vector (Mod m t) -> Int -> Mod m t #

Construction

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 Konst e d c | d -> c, c -> d where #

Minimal complete definition

konst

Methods

konst :: e -> d -> c e #

>>> 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 ]

Instances

Container Vector e => Konst e Int Vector #
Methods konst :: e -> Int -> Vector e #
(Num e, Container Vector e) => Konst e (Int, Int) Matrix #
Methods konst :: e -> (Int, Int) -> Matrix e #

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

build

Methods

build :: d -> f -> c e #

>>> 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

Instances

Container Vector e => Build Int (e -> e) Vector e #
Methods build :: Int -> (e -> e) -> Vector e #
Container Matrix e => Build (Int, Int) (e -> e -> e) Matrix e #
Methods build :: (Int, Int) -> (e -> e -> e) -> Matrix e #

assoc #

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 Double
fromList [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 ]

accum #

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 Double
fromList [0.0,1.0,1.0,0.0,2.0,3.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)

Diagonal

ident :: (Num a, Element a) => Int -> Matrix a #

creates the identity matrix of given dimension

diag :: (Num a, Element a) => Vector a -> Matrix a #

Creates a square matrix with a given diagonal.

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 ]

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 ]

takeDiag :: Element t => Matrix t -> Vector t #

extracts the diagonal from a rectangular matrix

Vector extraction

subVector #

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]

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]

Matrix extraction

data Extractor #

Specification of indexes for the operator ??.

Constructors

All
Range Int Int Int
Pos (Vector I)
PosCyc (Vector I)
Take Int
TakeLast Int
Drop Int
DropLast Int

Instances

Show Extractor #
Methods showsPrec :: Int -> Extractor -> ShowS # show :: Extractor -> String # showList :: [Extractor] -> ShowS #

(??) :: 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 ]

(?) :: 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 ]

¿ :: 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 ]

fliprl :: Element t => Matrix t -> Matrix t #

Reverse columns

flipud :: Element t => Matrix t -> Matrix t #

Reverse rows

subMatrix #

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)

takeRows :: Element t => Int -> Matrix t -> Matrix t #

dropRows :: Element t => Int -> Matrix t -> Matrix t #

takeColumns :: Element t => Int -> Matrix t -> Matrix t #

dropColumns :: Element t => Int -> Matrix t -> Matrix t #

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 ]

Block matrix

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 -> 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 ]

(===) :: Element t => Matrix t -> Matrix t -> Matrix t infixl 2 #

vertical concatenation

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 ]

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 ]

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.

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.

Mapping functions

conj :: Container c e => c e -> c e #

complex conjugate

cmap :: (Element b, Container c e) => (e -> b) -> c e -> c b #

like fmap (cannot implement instance Functor because of Element class constraint)

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]

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]

cond #

Arguments

:: (Ord e, Container c e, Container c x)
=> c e	a
-> c e	b
-> c x	l
-> c x	e
-> c x	g
-> c x	result

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

Find elements

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)]

maxIndex :: Container c e => c e -> IndexOf c #

index of maximum element

minIndex :: Container c e => c e -> IndexOf c #

index of minimum element

maxElement :: Container c e => c e -> e #

value of maximum element

minElement :: Container c e => c e -> e #

value of minimum element

sortVector :: (Ord t, Element t) => Vector t -> Vector t #

sortIndex :: (Ord t, Element t) => Vector t -> Vector I #

>>> m <- randn 4 10
>>> disp 2 m
4x10
-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

Sparse

type AssocMatrix = [((Int, Int), Double)] #

toDense :: AssocMatrix -> Matrix Double #

mkSparse :: AssocMatrix -> GMatrix #

mkDiagR :: Int -> Int -> Vector Double -> GMatrix #

mkDense :: Matrix Double -> GMatrix #

IO

disp :: Int -> Matrix Double -> IO () #

print a real matrix with given number of digits after the decimal point

>>> disp 5 $ ident 2 / 3
2x2
0.33333  0.00000
0.00000  0.33333

loadMatrix :: FilePath -> IO (Matrix Double) #

load a matrix from an ASCII file formatted as a 2D table.

loadMatrix' :: FilePath -> IO (Maybe (Matrix Double)) #

saveMatrix #

Arguments

:: FilePath
-> String	"printf" format (e.g. "%.2f", "%g", etc.)
-> Matrix Double
-> IO ()

save a matrix as a 2D ASCII table

latexFormat #

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

dispcf :: Int -> Matrix (Complex Double) -> String #

Pretty print a complex matrix with at most n decimal digits.

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")

dispDots :: Int -> Matrix Double -> IO () #

dispBlanks :: Int -> Matrix Double -> IO () #

dispShort :: Int -> Int -> Int -> Matrix Double -> IO () #

Element conversion

class Convert t where #

Minimal complete definition

real, complex, single, double, toComplex, fromComplex

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

Convert Double #
Methods real :: Complexable c => c (RealOf Double) -> c Double # complex :: Complexable c => c Double -> c (ComplexOf Double) # single :: Complexable c => c Double -> c (SingleOf Double) # double :: Complexable c => c Double -> c (DoubleOf Double) # toComplex :: (Complexable c, RealElement Double) => (c Double, c Double) -> c (Complex Double) # fromComplex :: (Complexable c, RealElement Double) => c (Complex Double) -> (c Double, c Double) #
Convert Float #
Methods real :: Complexable c => c (RealOf Float) -> c Float # complex :: Complexable c => c Float -> c (ComplexOf Float) # single :: Complexable c => c Float -> c (SingleOf Float) # double :: Complexable c => c Float -> c (DoubleOf Float) # toComplex :: (Complexable c, RealElement Float) => (c Float, c Float) -> c (Complex Float) # fromComplex :: (Complexable c, RealElement Float) => c (Complex Float) -> (c Float, c Float) #
Convert (Complex Double) #
Methods real :: Complexable c => c (RealOf (Complex Double)) -> c (Complex Double) # complex :: Complexable c => c (Complex Double) -> c (ComplexOf (Complex Double)) # single :: Complexable c => c (Complex Double) -> c (SingleOf (Complex Double)) # double :: Complexable c => c (Complex Double) -> c (DoubleOf (Complex Double)) # toComplex :: (Complexable c, RealElement (Complex Double)) => (c (Complex Double), c (Complex Double)) -> c (Complex (Complex Double)) # fromComplex :: (Complexable c, RealElement (Complex Double)) => c (Complex (Complex Double)) -> (c (Complex Double), c (Complex Double)) #
Convert (Complex Float) #
Methods real :: Complexable c => c (RealOf (Complex Float)) -> c (Complex Float) # complex :: Complexable c => c (Complex Float) -> c (ComplexOf (Complex Float)) # single :: Complexable c => c (Complex Float) -> c (SingleOf (Complex Float)) # double :: Complexable c => c (Complex Float) -> c (DoubleOf (Complex Float)) # toComplex :: (Complexable c, RealElement (Complex Float)) => (c (Complex Float), c (Complex Float)) -> c (Complex (Complex Float)) # fromComplex :: (Complexable c, RealElement (Complex Float)) => c (Complex (Complex Float)) -> (c (Complex Float), c (Complex Float)) #

roundVector :: Vector Double -> Vector Double #

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 ]

toInt :: Container c e => c e -> c I #

fromZ :: Container c e => c Z -> c e #

toZ :: Container c e => c e -> c Z #

Misc

arctan2 :: (Fractional e, Container c e) => c e -> c e -> c e #

separable :: Element t => (Vector t -> Vector t) -> Matrix t -> Matrix t #

matrix computation implemented as separated vector operations by rows and columns.

fromArray2D :: Storable e => Array (Int, Int) e -> Matrix e #

module Data.Complex

data Mod n t #

Wrapper with a phantom integer for statically checked modular arithmetic.

Instances

KnownNat m => Container Vector (Mod m Z) #
Methods conj' :: Vector (Mod m Z) -> Vector (Mod m Z) size' :: Vector (Mod m Z) -> IndexOf Vector scalar' :: Mod m Z -> Vector (Mod m Z) scale' :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) addConstant :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) add' :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) sub :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) mul :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) equal :: Vector (Mod m Z) -> Vector (Mod m Z) -> Bool cmap' :: Element b => (Mod m Z -> b) -> Vector (Mod m Z) -> Vector b konst' :: Mod m Z -> IndexOf Vector -> Vector (Mod m Z) build' :: IndexOf Vector -> ArgOf Vector (Mod m Z) -> Vector (Mod m Z) atIndex' :: Vector (Mod m Z) -> IndexOf Vector -> Mod m Z minIndex' :: Vector (Mod m Z) -> IndexOf Vector maxIndex' :: Vector (Mod m Z) -> IndexOf Vector minElement' :: Vector (Mod m Z) -> Mod m Z maxElement' :: Vector (Mod m Z) -> Mod m Z sumElements' :: Vector (Mod m Z) -> Mod m Z prodElements' :: Vector (Mod m Z) -> Mod m Z step' :: Vector (Mod m Z) -> Vector (Mod m Z) ccompare' :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector I cselect' :: Vector I -> Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) find' :: (Mod m Z -> Bool) -> Vector (Mod m Z) -> [IndexOf Vector] assoc' :: IndexOf Vector -> Mod m Z -> [(IndexOf Vector, Mod m Z)] -> Vector (Mod m Z) accum' :: Vector (Mod m Z) -> (Mod m Z -> Mod m Z -> Mod m Z) -> [(IndexOf Vector, Mod m Z)] -> Vector (Mod m Z) scaleRecip :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) divide :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) arctan2' :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) cmod' :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) fromInt' :: Vector I -> Vector (Mod m Z) toInt' :: Vector (Mod m Z) -> Vector I fromZ' :: Vector Z -> Vector (Mod m Z) toZ' :: Vector (Mod m Z) -> Vector Z
KnownNat m => Container Vector (Mod m I) #
Methods conj' :: Vector (Mod m I) -> Vector (Mod m I) size' :: Vector (Mod m I) -> IndexOf Vector scalar' :: Mod m I -> Vector (Mod m I) scale' :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) addConstant :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) add' :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) sub :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) mul :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) equal :: Vector (Mod m I) -> Vector (Mod m I) -> Bool cmap' :: Element b => (Mod m I -> b) -> Vector (Mod m I) -> Vector b konst' :: Mod m I -> IndexOf Vector -> Vector (Mod m I) build' :: IndexOf Vector -> ArgOf Vector (Mod m I) -> Vector (Mod m I) atIndex' :: Vector (Mod m I) -> IndexOf Vector -> Mod m I minIndex' :: Vector (Mod m I) -> IndexOf Vector maxIndex' :: Vector (Mod m I) -> IndexOf Vector minElement' :: Vector (Mod m I) -> Mod m I maxElement' :: Vector (Mod m I) -> Mod m I sumElements' :: Vector (Mod m I) -> Mod m I prodElements' :: Vector (Mod m I) -> Mod m I step' :: Vector (Mod m I) -> Vector (Mod m I) ccompare' :: Vector (Mod m I) -> Vector (Mod m I) -> Vector I cselect' :: Vector I -> Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) find' :: (Mod m I -> Bool) -> Vector (Mod m I) -> [IndexOf Vector] assoc' :: IndexOf Vector -> Mod m I -> [(IndexOf Vector, Mod m I)] -> Vector (Mod m I) accum' :: Vector (Mod m I) -> (Mod m I -> Mod m I -> Mod m I) -> [(IndexOf Vector, Mod m I)] -> Vector (Mod m I) scaleRecip :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) divide :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) arctan2' :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) cmod' :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) fromInt' :: Vector I -> Vector (Mod m I) toInt' :: Vector (Mod m I) -> Vector I fromZ' :: Vector Z -> Vector (Mod m I) toZ' :: Vector (Mod m I) -> Vector Z
KnownNat m => Num (Vector (Mod m Z)) #
Methods (+) :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) # (-) :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) # (*) :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) # negate :: Vector (Mod m Z) -> Vector (Mod m Z) # abs :: Vector (Mod m Z) -> Vector (Mod m Z) # signum :: Vector (Mod m Z) -> Vector (Mod m Z) # fromInteger :: Integer -> Vector (Mod m Z) #
KnownNat m => Num (Vector (Mod m I)) #
Methods (+) :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) # (-) :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) # (*) :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) # negate :: Vector (Mod m I) -> Vector (Mod m I) # abs :: Vector (Mod m I) -> Vector (Mod m I) # signum :: Vector (Mod m I) -> Vector (Mod m I) # fromInteger :: Integer -> Vector (Mod m I) #
KnownNat m => Testable (Matrix (Mod m I)) #
Methods checkT :: Matrix (Mod m I) -> (Bool, IO ()) # ioCheckT :: Matrix (Mod m I) -> IO (Bool, IO ()) #
KnownNat m => Normed (Vector (Mod m Z)) #
Methods norm_0 :: Vector (Mod m Z) -> R # norm_1 :: Vector (Mod m Z) -> R # norm_2 :: Vector (Mod m Z) -> R # norm_Inf :: Vector (Mod m Z) -> R #
KnownNat m => Normed (Vector (Mod m I)) #
Methods norm_0 :: Vector (Mod m I) -> R # norm_1 :: Vector (Mod m I) -> R # norm_2 :: Vector (Mod m I) -> R # norm_Inf :: Vector (Mod m I) -> R #
(Storable t, Indexable (Vector t) t) => Indexable (Vector (Mod m t)) (Mod m t) #
Methods (!) :: Vector (Mod m t) -> Int -> Mod m t #
(Integral t, Enum t, KnownNat m) => Enum (Mod m t) #
Methods succ :: Mod m t -> Mod m t # pred :: Mod m t -> Mod m t # toEnum :: Int -> Mod m t # fromEnum :: Mod m t -> Int # enumFrom :: Mod m t -> [Mod m t] # enumFromThen :: Mod m t -> Mod m t -> [Mod m t] # enumFromTo :: Mod m t -> Mod m t -> [Mod m t] # enumFromThenTo :: Mod m t -> Mod m t -> Mod m t -> [Mod m t] #
(Eq t, KnownNat m) => Eq (Mod m t) #
Methods (==) :: Mod m t -> Mod m t -> Bool # (/=) :: Mod m t -> Mod m t -> Bool #
(Show (Mod m t), Num (Mod m t), Eq t, KnownNat m) => Fractional (Mod m t) #	this instance is only valid for prime m
Methods (/) :: Mod m t -> Mod m t -> Mod m t # recip :: Mod m t -> Mod m t # fromRational :: Rational -> Mod m t #
(Integral t, KnownNat m, Num (Mod m t)) => Integral (Mod m t) #
Methods quot :: Mod m t -> Mod m t -> Mod m t # rem :: Mod m t -> Mod m t -> Mod m t # div :: Mod m t -> Mod m t -> Mod m t # mod :: Mod m t -> Mod m t -> Mod m t # quotRem :: Mod m t -> Mod m t -> (Mod m t, Mod m t) # divMod :: Mod m t -> Mod m t -> (Mod m t, Mod m t) # toInteger :: Mod m t -> Integer #
(Integral t, KnownNat n) => Num (Mod n t) #
Methods (+) :: Mod n t -> Mod n t -> Mod n t # (-) :: Mod n t -> Mod n t -> Mod n t # (*) :: Mod n t -> Mod n t -> Mod n t # negate :: Mod n t -> Mod n t # abs :: Mod n t -> Mod n t # signum :: Mod n t -> Mod n t # fromInteger :: Integer -> Mod n t #
(Ord t, KnownNat m) => Ord (Mod m t) #
Methods compare :: Mod m t -> Mod m t -> Ordering # (<) :: Mod m t -> Mod m t -> Bool # (<=) :: Mod m t -> Mod m t -> Bool # (>) :: Mod m t -> Mod m t -> Bool # (>=) :: Mod m t -> Mod m t -> Bool # max :: Mod m t -> Mod m t -> Mod m t # min :: Mod m t -> Mod m t -> Mod m t #
(Integral t, Real t, KnownNat m, Integral (Mod m t)) => Real (Mod m t) #
Methods toRational :: Mod m t -> Rational #
Show t => Show (Mod n t) #
Methods showsPrec :: Int -> Mod n t -> ShowS # show :: Mod n t -> String # showList :: [Mod n t] -> ShowS #
Storable t => Storable (Mod n t) #
Methods sizeOf :: Mod n t -> Int # alignment :: Mod n t -> Int # peekElemOff :: Ptr (Mod n t) -> Int -> IO (Mod n t) # pokeElemOff :: Ptr (Mod n t) -> Int -> Mod n t -> IO () # peekByteOff :: Ptr b -> Int -> IO (Mod n t) # pokeByteOff :: Ptr b -> Int -> Mod n t -> IO () # peek :: Ptr (Mod n t) -> IO (Mod n t) # poke :: Ptr (Mod n t) -> Mod n t -> IO () #
NFData t => NFData (Mod n t) #
Methods rnf :: Mod n t -> () #
KnownNat m => Element (Mod m Z) #
Methods constantD :: Mod m Z -> Int -> Vector (Mod m Z) extractR :: MatrixOrder -> Matrix (Mod m Z) -> CInt -> Vector CInt -> CInt -> Vector CInt -> IO (Matrix (Mod m Z)) setRect :: Int -> Int -> Matrix (Mod m Z) -> Matrix (Mod m Z) -> IO () sortI :: Vector (Mod m Z) -> Vector CInt sortV :: Vector (Mod m Z) -> Vector (Mod m Z) compareV :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector CInt selectV :: Vector CInt -> Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) remapM :: Matrix CInt -> Matrix CInt -> Matrix (Mod m Z) -> Matrix (Mod m Z) rowOp :: Int -> Mod m Z -> Int -> Int -> Int -> Int -> Matrix (Mod m Z) -> IO () gemm :: Vector (Mod m Z) -> Matrix (Mod m Z) -> Matrix (Mod m Z) -> Matrix (Mod m Z) -> IO ()
KnownNat m => Element (Mod m I) #
Methods constantD :: Mod m I -> Int -> Vector (Mod m I) extractR :: MatrixOrder -> Matrix (Mod m I) -> CInt -> Vector CInt -> CInt -> Vector CInt -> IO (Matrix (Mod m I)) setRect :: Int -> Int -> Matrix (Mod m I) -> Matrix (Mod m I) -> IO () sortI :: Vector (Mod m I) -> Vector CInt sortV :: Vector (Mod m I) -> Vector (Mod m I) compareV :: Vector (Mod m I) -> Vector (Mod m I) -> Vector CInt selectV :: Vector CInt -> Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) remapM :: Matrix CInt -> Matrix CInt -> Matrix (Mod m I) -> Matrix (Mod m I) rowOp :: Int -> Mod m I -> Int -> Int -> Int -> Int -> Matrix (Mod m I) -> IO () gemm :: Vector (Mod m I) -> Matrix (Mod m I) -> Matrix (Mod m I) -> Matrix (Mod m I) -> IO ()
KnownNat m => Product (Mod m Z) #
Methods multiply :: Matrix (Mod m Z) -> Matrix (Mod m Z) -> Matrix (Mod m Z) absSum :: Vector (Mod m Z) -> RealOf (Mod m Z) norm1 :: Vector (Mod m Z) -> RealOf (Mod m Z) norm2 :: Vector (Mod m Z) -> RealOf (Mod m Z) normInf :: Vector (Mod m Z) -> RealOf (Mod m Z)
KnownNat m => Product (Mod m I) #
Methods multiply :: Matrix (Mod m I) -> Matrix (Mod m I) -> Matrix (Mod m I) absSum :: Vector (Mod m I) -> RealOf (Mod m I) norm1 :: Vector (Mod m I) -> RealOf (Mod m I) norm2 :: Vector (Mod m I) -> RealOf (Mod m I) normInf :: Vector (Mod m I) -> RealOf (Mod m I)
KnownNat m => Numeric (Mod m Z) #

KnownNat m => Numeric (Mod m I) #

type RealOf (Mod n Z) #
type RealOf (Mod n Z) = Z
type RealOf (Mod n I) #
type RealOf (Mod n I) = I

data Vector a :: * -> * #

Storable-based vectors

Instances

Complexable Vector #
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) single' :: Precision a b => Vector b -> Vector a double' :: Precision a b => Vector a -> Vector b
LSDiv Vector #
Methods linSolve :: Field t => Matrix t -> Vector t -> Vector t
Storable a => Vector Vector a
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) # basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) # basicLength :: Vector a -> Int # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a # basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () # elemseq :: Vector a -> a -> b -> b #
Container Vector t => Linear t Vector #
Methods scale :: t -> Vector t -> Vector t #
Container Vector Double #
Methods conj' :: Vector Double -> Vector Double size' :: Vector Double -> IndexOf Vector scalar' :: Double -> Vector Double scale' :: Double -> Vector Double -> Vector Double addConstant :: Double -> Vector Double -> Vector Double add' :: Vector Double -> Vector Double -> Vector Double sub :: Vector Double -> Vector Double -> Vector Double mul :: Vector Double -> Vector Double -> Vector Double equal :: Vector Double -> Vector Double -> Bool cmap' :: Element b => (Double -> b) -> Vector Double -> Vector b konst' :: Double -> IndexOf Vector -> Vector Double build' :: IndexOf Vector -> ArgOf Vector Double -> Vector Double atIndex' :: Vector Double -> IndexOf Vector -> Double minIndex' :: Vector Double -> IndexOf Vector maxIndex' :: Vector Double -> IndexOf Vector minElement' :: Vector Double -> Double maxElement' :: Vector Double -> Double sumElements' :: Vector Double -> Double prodElements' :: Vector Double -> Double step' :: Vector Double -> Vector Double ccompare' :: Vector Double -> Vector Double -> Vector I cselect' :: Vector I -> Vector Double -> Vector Double -> Vector Double -> Vector Double find' :: (Double -> Bool) -> Vector Double -> [IndexOf Vector] assoc' :: IndexOf Vector -> Double -> [(IndexOf Vector, Double)] -> Vector Double accum' :: Vector Double -> (Double -> Double -> Double) -> [(IndexOf Vector, Double)] -> Vector Double scaleRecip :: Double -> Vector Double -> Vector Double divide :: Vector Double -> Vector Double -> Vector Double arctan2' :: Vector Double -> Vector Double -> Vector Double cmod' :: Double -> Vector Double -> Vector Double fromInt' :: Vector I -> Vector Double toInt' :: Vector Double -> Vector I fromZ' :: Vector Z -> Vector Double toZ' :: Vector Double -> Vector Z
Container Vector Float #
Methods conj' :: Vector Float -> Vector Float size' :: Vector Float -> IndexOf Vector scalar' :: Float -> Vector Float scale' :: Float -> Vector Float -> Vector Float addConstant :: Float -> Vector Float -> Vector Float add' :: Vector Float -> Vector Float -> Vector Float sub :: Vector Float -> Vector Float -> Vector Float mul :: Vector Float -> Vector Float -> Vector Float equal :: Vector Float -> Vector Float -> Bool cmap' :: Element b => (Float -> b) -> Vector Float -> Vector b konst' :: Float -> IndexOf Vector -> Vector Float build' :: IndexOf Vector -> ArgOf Vector Float -> Vector Float atIndex' :: Vector Float -> IndexOf Vector -> Float minIndex' :: Vector Float -> IndexOf Vector maxIndex' :: Vector Float -> IndexOf Vector minElement' :: Vector Float -> Float maxElement' :: Vector Float -> Float sumElements' :: Vector Float -> Float prodElements' :: Vector Float -> Float step' :: Vector Float -> Vector Float ccompare' :: Vector Float -> Vector Float -> Vector I cselect' :: Vector I -> Vector Float -> Vector Float -> Vector Float -> Vector Float find' :: (Float -> Bool) -> Vector Float -> [IndexOf Vector] assoc' :: IndexOf Vector -> Float -> [(IndexOf Vector, Float)] -> Vector Float accum' :: Vector Float -> (Float -> Float -> Float) -> [(IndexOf Vector, Float)] -> Vector Float scaleRecip :: Float -> Vector Float -> Vector Float divide :: Vector Float -> Vector Float -> Vector Float arctan2' :: Vector Float -> Vector Float -> Vector Float cmod' :: Float -> Vector Float -> Vector Float fromInt' :: Vector I -> Vector Float toInt' :: Vector Float -> Vector I fromZ' :: Vector Z -> Vector Float toZ' :: Vector Float -> Vector Z
Container Vector Z #
Methods conj' :: Vector Z -> Vector Z size' :: Vector Z -> IndexOf Vector scalar' :: Z -> Vector Z scale' :: Z -> Vector Z -> Vector Z addConstant :: Z -> Vector Z -> Vector Z add' :: Vector Z -> Vector Z -> Vector Z sub :: Vector Z -> Vector Z -> Vector Z mul :: Vector Z -> Vector Z -> Vector Z equal :: Vector Z -> Vector Z -> Bool cmap' :: Element b => (Z -> b) -> Vector Z -> Vector b konst' :: Z -> IndexOf Vector -> Vector Z build' :: IndexOf Vector -> ArgOf Vector Z -> Vector Z atIndex' :: Vector Z -> IndexOf Vector -> Z minIndex' :: Vector Z -> IndexOf Vector maxIndex' :: Vector Z -> IndexOf Vector minElement' :: Vector Z -> Z maxElement' :: Vector Z -> Z sumElements' :: Vector Z -> Z prodElements' :: Vector Z -> Z step' :: Vector Z -> Vector Z ccompare' :: Vector Z -> Vector Z -> Vector I cselect' :: Vector I -> Vector Z -> Vector Z -> Vector Z -> Vector Z find' :: (Z -> Bool) -> Vector Z -> [IndexOf Vector] assoc' :: IndexOf Vector -> Z -> [(IndexOf Vector, Z)] -> Vector Z accum' :: Vector Z -> (Z -> Z -> Z) -> [(IndexOf Vector, Z)] -> Vector Z scaleRecip :: Z -> Vector Z -> Vector Z divide :: Vector Z -> Vector Z -> Vector Z arctan2' :: Vector Z -> Vector Z -> Vector Z cmod' :: Z -> Vector Z -> Vector Z fromInt' :: Vector I -> Vector Z toInt' :: Vector Z -> Vector I fromZ' :: Vector Z -> Vector Z toZ' :: Vector Z -> Vector Z
Container Vector I #
Methods conj' :: Vector I -> Vector I size' :: Vector I -> IndexOf Vector scalar' :: I -> Vector I scale' :: I -> Vector I -> Vector I addConstant :: I -> Vector I -> Vector I add' :: Vector I -> Vector I -> Vector I sub :: Vector I -> Vector I -> Vector I mul :: Vector I -> Vector I -> Vector I equal :: Vector I -> Vector I -> Bool cmap' :: Element b => (I -> b) -> Vector I -> Vector b konst' :: I -> IndexOf Vector -> Vector I build' :: IndexOf Vector -> ArgOf Vector I -> Vector I atIndex' :: Vector I -> IndexOf Vector -> I minIndex' :: Vector I -> IndexOf Vector maxIndex' :: Vector I -> IndexOf Vector minElement' :: Vector I -> I maxElement' :: Vector I -> I sumElements' :: Vector I -> I prodElements' :: Vector I -> I step' :: Vector I -> Vector I ccompare' :: Vector I -> Vector I -> Vector I cselect' :: Vector I -> Vector I -> Vector I -> Vector I -> Vector I find' :: (I -> Bool) -> Vector I -> [IndexOf Vector] assoc' :: IndexOf Vector -> I -> [(IndexOf Vector, I)] -> Vector I accum' :: Vector I -> (I -> I -> I) -> [(IndexOf Vector, I)] -> Vector I scaleRecip :: I -> Vector I -> Vector I divide :: Vector I -> Vector I -> Vector I arctan2' :: Vector I -> Vector I -> Vector I cmod' :: I -> Vector I -> Vector I fromInt' :: Vector I -> Vector I toInt' :: Vector I -> Vector I fromZ' :: Vector Z -> Vector I toZ' :: Vector I -> Vector Z
Container Vector e => Konst e Int Vector #
Methods konst :: e -> Int -> Vector e #
Container Vector (Complex Double) #
Methods conj' :: Vector (Complex Double) -> Vector (Complex Double) size' :: Vector (Complex Double) -> IndexOf Vector scalar' :: Complex Double -> Vector (Complex Double) scale' :: Complex Double -> Vector (Complex Double) -> Vector (Complex Double) addConstant :: Complex Double -> Vector (Complex Double) -> Vector (Complex Double) add' :: Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) sub :: Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) mul :: Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) equal :: Vector (Complex Double) -> Vector (Complex Double) -> Bool cmap' :: Element b => (Complex Double -> b) -> Vector (Complex Double) -> Vector b konst' :: Complex Double -> IndexOf Vector -> Vector (Complex Double) build' :: IndexOf Vector -> ArgOf Vector (Complex Double) -> Vector (Complex Double) atIndex' :: Vector (Complex Double) -> IndexOf Vector -> Complex Double minIndex' :: Vector (Complex Double) -> IndexOf Vector maxIndex' :: Vector (Complex Double) -> IndexOf Vector minElement' :: Vector (Complex Double) -> Complex Double maxElement' :: Vector (Complex Double) -> Complex Double sumElements' :: Vector (Complex Double) -> Complex Double prodElements' :: Vector (Complex Double) -> Complex Double step' :: Vector (Complex Double) -> Vector (Complex Double) ccompare' :: Vector (Complex Double) -> Vector (Complex Double) -> Vector I cselect' :: Vector I -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) find' :: (Complex Double -> Bool) -> Vector (Complex Double) -> [IndexOf Vector] assoc' :: IndexOf Vector -> Complex Double -> [(IndexOf Vector, Complex Double)] -> Vector (Complex Double) accum' :: Vector (Complex Double) -> (Complex Double -> Complex Double -> Complex Double) -> [(IndexOf Vector, Complex Double)] -> Vector (Complex Double) scaleRecip :: Complex Double -> Vector (Complex Double) -> Vector (Complex Double) divide :: Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) arctan2' :: Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double) cmod' :: Complex Double -> Vector (Complex Double) -> Vector (Complex Double) fromInt' :: Vector I -> Vector (Complex Double) toInt' :: Vector (Complex Double) -> Vector I fromZ' :: Vector Z -> Vector (Complex Double) toZ' :: Vector (Complex Double) -> Vector Z
Container Vector (Complex Float) #
Methods conj' :: Vector (Complex Float) -> Vector (Complex Float) size' :: Vector (Complex Float) -> IndexOf Vector scalar' :: Complex Float -> Vector (Complex Float) scale' :: Complex Float -> Vector (Complex Float) -> Vector (Complex Float) addConstant :: Complex Float -> Vector (Complex Float) -> Vector (Complex Float) add' :: Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) sub :: Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) mul :: Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) equal :: Vector (Complex Float) -> Vector (Complex Float) -> Bool cmap' :: Element b => (Complex Float -> b) -> Vector (Complex Float) -> Vector b konst' :: Complex Float -> IndexOf Vector -> Vector (Complex Float) build' :: IndexOf Vector -> ArgOf Vector (Complex Float) -> Vector (Complex Float) atIndex' :: Vector (Complex Float) -> IndexOf Vector -> Complex Float minIndex' :: Vector (Complex Float) -> IndexOf Vector maxIndex' :: Vector (Complex Float) -> IndexOf Vector minElement' :: Vector (Complex Float) -> Complex Float maxElement' :: Vector (Complex Float) -> Complex Float sumElements' :: Vector (Complex Float) -> Complex Float prodElements' :: Vector (Complex Float) -> Complex Float step' :: Vector (Complex Float) -> Vector (Complex Float) ccompare' :: Vector (Complex Float) -> Vector (Complex Float) -> Vector I cselect' :: Vector I -> Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) find' :: (Complex Float -> Bool) -> Vector (Complex Float) -> [IndexOf Vector] assoc' :: IndexOf Vector -> Complex Float -> [(IndexOf Vector, Complex Float)] -> Vector (Complex Float) accum' :: Vector (Complex Float) -> (Complex Float -> Complex Float -> Complex Float) -> [(IndexOf Vector, Complex Float)] -> Vector (Complex Float) scaleRecip :: Complex Float -> Vector (Complex Float) -> Vector (Complex Float) divide :: Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) arctan2' :: Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float) cmod' :: Complex Float -> Vector (Complex Float) -> Vector (Complex Float) fromInt' :: Vector I -> Vector (Complex Float) toInt' :: Vector (Complex Float) -> Vector I fromZ' :: Vector Z -> Vector (Complex Float) toZ' :: Vector (Complex Float) -> Vector Z
KnownNat n => Sized ℂ (C n) Vector #
Methods konst :: ℂ -> C n # unwrap :: C n -> Vector ℂ # fromList :: [ℂ] -> C n # extract :: C n -> Vector ℂ # create :: Vector ℂ -> Maybe (C n) # size :: C n -> IndexOf Vector #
KnownNat n => Sized ℝ (R n) Vector #
Methods konst :: ℝ -> R n # unwrap :: R n -> Vector ℝ # fromList :: [ℝ] -> R n # extract :: R n -> Vector ℝ # create :: Vector ℝ -> Maybe (R n) # size :: R n -> IndexOf Vector #
KnownNat m => Container Vector (Mod m Z) #
Methods conj' :: Vector (Mod m Z) -> Vector (Mod m Z) size' :: Vector (Mod m Z) -> IndexOf Vector scalar' :: Mod m Z -> Vector (Mod m Z) scale' :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) addConstant :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) add' :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) sub :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) mul :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) equal :: Vector (Mod m Z) -> Vector (Mod m Z) -> Bool cmap' :: Element b => (Mod m Z -> b) -> Vector (Mod m Z) -> Vector b konst' :: Mod m Z -> IndexOf Vector -> Vector (Mod m Z) build' :: IndexOf Vector -> ArgOf Vector (Mod m Z) -> Vector (Mod m Z) atIndex' :: Vector (Mod m Z) -> IndexOf Vector -> Mod m Z minIndex' :: Vector (Mod m Z) -> IndexOf Vector maxIndex' :: Vector (Mod m Z) -> IndexOf Vector minElement' :: Vector (Mod m Z) -> Mod m Z maxElement' :: Vector (Mod m Z) -> Mod m Z sumElements' :: Vector (Mod m Z) -> Mod m Z prodElements' :: Vector (Mod m Z) -> Mod m Z step' :: Vector (Mod m Z) -> Vector (Mod m Z) ccompare' :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector I cselect' :: Vector I -> Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) find' :: (Mod m Z -> Bool) -> Vector (Mod m Z) -> [IndexOf Vector] assoc' :: IndexOf Vector -> Mod m Z -> [(IndexOf Vector, Mod m Z)] -> Vector (Mod m Z) accum' :: Vector (Mod m Z) -> (Mod m Z -> Mod m Z -> Mod m Z) -> [(IndexOf Vector, Mod m Z)] -> Vector (Mod m Z) scaleRecip :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) divide :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) arctan2' :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) cmod' :: Mod m Z -> Vector (Mod m Z) -> Vector (Mod m Z) fromInt' :: Vector I -> Vector (Mod m Z) toInt' :: Vector (Mod m Z) -> Vector I fromZ' :: Vector Z -> Vector (Mod m Z) toZ' :: Vector (Mod m Z) -> Vector Z
KnownNat m => Container Vector (Mod m I) #
Methods conj' :: Vector (Mod m I) -> Vector (Mod m I) size' :: Vector (Mod m I) -> IndexOf Vector scalar' :: Mod m I -> Vector (Mod m I) scale' :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) addConstant :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) add' :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) sub :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) mul :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) equal :: Vector (Mod m I) -> Vector (Mod m I) -> Bool cmap' :: Element b => (Mod m I -> b) -> Vector (Mod m I) -> Vector b konst' :: Mod m I -> IndexOf Vector -> Vector (Mod m I) build' :: IndexOf Vector -> ArgOf Vector (Mod m I) -> Vector (Mod m I) atIndex' :: Vector (Mod m I) -> IndexOf Vector -> Mod m I minIndex' :: Vector (Mod m I) -> IndexOf Vector maxIndex' :: Vector (Mod m I) -> IndexOf Vector minElement' :: Vector (Mod m I) -> Mod m I maxElement' :: Vector (Mod m I) -> Mod m I sumElements' :: Vector (Mod m I) -> Mod m I prodElements' :: Vector (Mod m I) -> Mod m I step' :: Vector (Mod m I) -> Vector (Mod m I) ccompare' :: Vector (Mod m I) -> Vector (Mod m I) -> Vector I cselect' :: Vector I -> Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) find' :: (Mod m I -> Bool) -> Vector (Mod m I) -> [IndexOf Vector] assoc' :: IndexOf Vector -> Mod m I -> [(IndexOf Vector, Mod m I)] -> Vector (Mod m I) accum' :: Vector (Mod m I) -> (Mod m I -> Mod m I -> Mod m I) -> [(IndexOf Vector, Mod m I)] -> Vector (Mod m I) scaleRecip :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) divide :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) arctan2' :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) cmod' :: Mod m I -> Vector (Mod m I) -> Vector (Mod m I) fromInt' :: Vector I -> Vector (Mod m I) toInt' :: Vector (Mod m I) -> Vector I fromZ' :: Vector Z -> Vector (Mod m I) toZ' :: Vector (Mod m I) -> Vector Z
Container Vector e => Build Int (e -> e) Vector e #
Methods build :: Int -> (e -> e) -> Vector e #
Storable a => IsList (Vector a)
Associated Types type Item (Vector a) :: * # Methods fromList :: [Item (Vector a)] -> Vector a # fromListN :: Int -> [Item (Vector a)] -> Vector a # toList :: Vector a -> [Item (Vector a)] #
(Storable a, Eq a) => Eq (Vector a)
Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Data a, Storable a) => Data (Vector a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #
KnownNat m => Num (Vector (Mod m Z)) #
Methods (+) :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) # (-) :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) # (*) :: Vector (Mod m Z) -> Vector (Mod m Z) -> Vector (Mod m Z) # negate :: Vector (Mod m Z) -> Vector (Mod m Z) # abs :: Vector (Mod m Z) -> Vector (Mod m Z) # signum :: Vector (Mod m Z) -> Vector (Mod m Z) # fromInteger :: Integer -> Vector (Mod m Z) #
KnownNat m => Num (Vector (Mod m I)) #
Methods (+) :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) # (-) :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) # (*) :: Vector (Mod m I) -> Vector (Mod m I) -> Vector (Mod m I) # negate :: Vector (Mod m I) -> Vector (Mod m I) # abs :: Vector (Mod m I) -> Vector (Mod m I) # signum :: Vector (Mod m I) -> Vector (Mod m I) # fromInteger :: Integer -> Vector (Mod m I) #
(Storable a, Ord a) => Ord (Vector a)
Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
(Read a, Storable a) => Read (Vector a)
Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
(Show a, Storable a) => Show (Vector a)
Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
Storable a => Semigroup (Vector a)
Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Storable a => Monoid (Vector a)
Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
NFData (Vector a)
Methods rnf :: Vector a -> () #
Storable t => TransArray (Vector t) #
Associated Types type Trans (Vector t) b :: * # type TransRaw (Vector t) b :: * # Methods apply :: Vector t -> (b -> IO r) -> Trans (Vector t) b -> IO r # applyRaw :: Vector t -> (b -> IO r) -> TransRaw (Vector t) b -> IO r #
Container Vector t => Additive (Vector t) #
Methods add :: Vector t -> Vector t -> Vector t #
Normed (Vector Float) #
Methods norm_0 :: Vector Float -> R # norm_1 :: Vector Float -> R # norm_2 :: Vector Float -> R # norm_Inf :: Vector Float -> R #
Normed (Vector (Complex Float)) #
Methods norm_0 :: Vector (Complex Float) -> R # norm_1 :: Vector (Complex Float) -> R # norm_2 :: Vector (Complex Float) -> R # norm_Inf :: Vector (Complex Float) -> R #
Normed (Vector C) #
Methods norm_0 :: Vector C -> R # norm_1 :: Vector C -> R # norm_2 :: Vector C -> R # norm_Inf :: Vector C -> R #
Normed (Vector R) #
Methods norm_0 :: Vector R -> R # norm_1 :: Vector R -> R # norm_2 :: Vector R -> R # norm_Inf :: Vector R -> R #
Normed (Vector Z) #
Methods norm_0 :: Vector Z -> R # norm_1 :: Vector Z -> R # norm_2 :: Vector Z -> R # norm_Inf :: Vector Z -> R #
Normed (Vector I) #
Methods norm_0 :: Vector I -> R # norm_1 :: Vector I -> R # norm_2 :: Vector I -> R # norm_Inf :: Vector I -> R #
KnownNat m => Normed (Vector (Mod m Z)) #
Methods norm_0 :: Vector (Mod m Z) -> R # norm_1 :: Vector (Mod m Z) -> R # norm_2 :: Vector (Mod m Z) -> R # norm_Inf :: Vector (Mod m Z) -> R #
KnownNat m => Normed (Vector (Mod m I)) #
Methods norm_0 :: Vector (Mod m I) -> R # norm_1 :: Vector (Mod m I) -> R # norm_2 :: Vector (Mod m I) -> R # norm_Inf :: Vector (Mod m I) -> R #
Indexable (Vector Double) Double #
Methods (!) :: Vector Double -> Int -> Double #
Indexable (Vector Float) Float #
Methods (!) :: Vector Float -> Int -> Float #
Indexable (Vector Z) Z #
Methods (!) :: Vector Z -> Int -> Z #
Indexable (Vector I) I #
Methods (!) :: Vector I -> Int -> I #
Indexable (Vector (Complex Double)) (Complex Double) #
Methods (!) :: Vector (Complex Double) -> Int -> Complex Double #
Indexable (Vector (Complex Float)) (Complex Float) #
Methods (!) :: Vector (Complex Float) -> Int -> Complex Float #
Element t => Indexable (Matrix t) (Vector t) #
Methods (!) :: Matrix t -> Int -> Vector t #
(Storable t, Indexable (Vector t) t) => Indexable (Vector (Mod m t)) (Mod m t) #
Methods (!) :: Vector (Mod m t) -> Int -> Mod m t #
type Mutable Vector
type Mutable Vector = MVector
type IndexOf Vector #
type IndexOf Vector = Int
type Item (Vector a)
type Item (Vector a) = a
type Trans (Vector t) b #
type Trans (Vector t) b = CInt -> Ptr t -> b
type TransRaw (Vector t) b #
type TransRaw (Vector t) b = CInt -> Ptr t -> b

data Matrix t #

Matrix representation suitable for BLAS/LAPACK computations.

Instances

Complexable Matrix #
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) single' :: Precision a b => Matrix b -> Matrix a double' :: Precision a b => Matrix a -> Matrix b
LSDiv Matrix #
Methods linSolve :: Field t => Matrix t -> Matrix t -> Matrix t
Container Matrix t => Linear t Matrix #
Methods scale :: t -> Matrix t -> Matrix t #
(Num a, Element a, Container Vector a) => Container Matrix a #
Methods conj' :: Matrix a -> Matrix a size' :: Matrix a -> IndexOf Matrix scalar' :: a -> Matrix a scale' :: a -> Matrix a -> Matrix a addConstant :: a -> Matrix a -> Matrix a add' :: Matrix a -> Matrix a -> Matrix a sub :: Matrix a -> Matrix a -> Matrix a mul :: Matrix a -> Matrix a -> Matrix a equal :: Matrix a -> Matrix a -> Bool cmap' :: Element b => (a -> b) -> Matrix a -> Matrix b konst' :: a -> IndexOf Matrix -> Matrix a build' :: IndexOf Matrix -> ArgOf Matrix a -> Matrix a atIndex' :: Matrix a -> IndexOf Matrix -> a minIndex' :: Matrix a -> IndexOf Matrix maxIndex' :: Matrix a -> IndexOf Matrix minElement' :: Matrix a -> a maxElement' :: Matrix a -> a sumElements' :: Matrix a -> a prodElements' :: Matrix a -> a step' :: Matrix a -> Matrix a ccompare' :: Matrix a -> Matrix a -> Matrix I cselect' :: Matrix I -> Matrix a -> Matrix a -> Matrix a -> Matrix a find' :: (a -> Bool) -> Matrix a -> [IndexOf Matrix] assoc' :: IndexOf Matrix -> a -> [(IndexOf Matrix, a)] -> Matrix a accum' :: Matrix a -> (a -> a -> a) -> [(IndexOf Matrix, a)] -> Matrix a scaleRecip :: a -> Matrix a -> Matrix a divide :: Matrix a -> Matrix a -> Matrix a arctan2' :: Matrix a -> Matrix a -> Matrix a cmod' :: a -> Matrix a -> Matrix a fromInt' :: Matrix I -> Matrix a toInt' :: Matrix a -> Matrix I fromZ' :: Matrix Z -> Matrix a toZ' :: Matrix a -> Matrix Z
(Num e, Container Vector e) => Konst e (Int, Int) Matrix #
Methods konst :: e -> (Int, Int) -> Matrix e #
(KnownNat m, KnownNat n) => Sized ℂ (M m n) Matrix #
Methods konst :: ℂ -> M m n # unwrap :: M m n -> Matrix ℂ # fromList :: [ℂ] -> M m n # extract :: M m n -> Matrix ℂ # create :: Matrix ℂ -> Maybe (M m n) # size :: M m n -> IndexOf Matrix #
(KnownNat m, KnownNat n) => Sized ℝ (L m n) Matrix #
Methods konst :: ℝ -> L m n # unwrap :: L m n -> Matrix ℝ # fromList :: [ℝ] -> L m n # extract :: L m n -> Matrix ℝ # create :: Matrix ℝ -> Maybe (L m n) # size :: L m n -> IndexOf Matrix #
(Storable t, NFData t) => NFData (Matrix t) #
Methods rnf :: Matrix t -> () #
Storable t => TransArray (Matrix t) #
Associated Types type Trans (Matrix t) b :: * # type TransRaw (Matrix t) b :: * # Methods apply :: Matrix t -> (b -> IO r) -> Trans (Matrix t) b -> IO r # applyRaw :: Matrix t -> (b -> IO r) -> TransRaw (Matrix t) b -> IO r #
KnownNat m => Testable (Matrix (Mod m I)) #
Methods checkT :: Matrix (Mod m I) -> (Bool, IO ()) # ioCheckT :: Matrix (Mod m I) -> IO (Bool, IO ()) #
Container Matrix t => Additive (Matrix t) #
Methods add :: Matrix t -> Matrix t -> Matrix t #
Normed (Matrix C) #
Methods norm_0 :: Matrix C -> R # norm_1 :: Matrix C -> R # norm_2 :: Matrix C -> R # norm_Inf :: Matrix C -> R #
Normed (Matrix R) #
Methods norm_0 :: Matrix R -> R # norm_1 :: Matrix R -> R # norm_2 :: Matrix R -> R # norm_Inf :: Matrix R -> R #
(CTrans t, Container Vector t) => Transposable (Matrix t) (Matrix t) #
Methods tr :: Matrix t -> Matrix t # tr' :: Matrix t -> Matrix t #
Element t => Indexable (Matrix t) (Vector t) #
Methods (!) :: Matrix t -> Int -> Vector t #
Container Matrix e => Build (Int, Int) (e -> e -> e) Matrix e #
Methods build :: (Int, Int) -> (e -> e -> e) -> Matrix e #
type IndexOf Matrix #
type IndexOf Matrix = (Int, Int)
type Trans (Matrix t) b #
type Trans (Matrix t) b = CInt -> CInt -> CInt -> CInt -> Ptr t -> b
type TransRaw (Matrix t) b #
type TransRaw (Matrix t) b = CInt -> CInt -> Ptr t -> b

data GMatrix #

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)]
>>> m
SparseR {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])
>>> m
Dense {gmDense = (2><2)
 [ 1.0, 2.0
 , 3.0, 4.0 ], nRows = 2, nCols = 2}

Instances

Show GMatrix #
Methods showsPrec :: Int -> GMatrix -> ShowS # show :: GMatrix -> String # showList :: [GMatrix] -> ShowS #
Transposable GMatrix GMatrix #
Methods tr :: GMatrix -> GMatrix # tr' :: GMatrix -> GMatrix #

nRows :: GMatrix -> Int #

nCols :: GMatrix -> Int #