Numerical.HBLAS.MatrixTypes

PSA, the matrix data types used in the hBLAS binding should not be regarded as being general purpose matrices.

They are designed to exactly express only the matrices which are valid inputs for BLAS. When applicable, such matrices should be easily mapped to and from other matrix libraries. That said, the BLAS and LAPACK matrix formats capture a rich and very expressive subset of Dense Matrix formats.

The primary and hence default format is Dense Row and Column Major Matrices, but support will be added for other formats that BLAS and LAPACK provide operations for.

A guiding rule of thumb for this package is that there are no generic abstractions provided, merely machinery to ensure all uses of BLAS and LAPACK operations can be used in their full generality in a human friendly type safe fashion. It is the role of a higher level library to provide any generic operations.

One such higher level lib you can interface with easily is Numerical. There is a work in progress binding to help this in the numerical-hblas package (which may not be public yet at the time of this writing)

Documentation

data Orientation

Constructors

Row

Column

Instances

Eq Orientation

Methods

(==) :: Orientation -> Orientation -> Bool

(/=) :: Orientation -> Orientation -> Bool

Show Orientation

Methods

showsPrec :: Int -> Orientation -> ShowS

show :: Orientation -> String

showList :: [Orientation] -> ShowS

type Row = Row

type Column = Column

data SOrientation :: Orientation -> * where

Constructors

SRow :: SOrientation Row

SColumn :: SOrientation Column

Instances

Eq (SOrientation a)

Methods

(==) :: SOrientation a -> SOrientation a -> Bool

(/=) :: SOrientation a -> SOrientation a -> Bool

Ord (SOrientation a)

Methods

compare :: SOrientation a -> SOrientation a -> Ordering

(<) :: SOrientation a -> SOrientation a -> Bool

(<=) :: SOrientation a -> SOrientation a -> Bool

(>) :: SOrientation a -> SOrientation a -> Bool

(>=) :: SOrientation a -> SOrientation a -> Bool

max :: SOrientation a -> SOrientation a -> SOrientation a

min :: SOrientation a -> SOrientation a -> SOrientation a

Show (SOrientation a)

Methods

showsPrec :: Int -> SOrientation a -> ShowS

show :: SOrientation a -> String

showList :: [SOrientation a] -> ShowS

sTranpose :: (x ~ TransposeF y, y ~ TransposeF x) => SOrientation x -> SOrientation y

data Transpose

Constructors

NoTranspose

Transpose

ConjTranspose

ConjNoTranspose

Instances

Eq Transpose

Methods

(==) :: Transpose -> Transpose -> Bool

(/=) :: Transpose -> Transpose -> Bool

Show Transpose

Methods

showsPrec :: Int -> Transpose -> ShowS

show :: Transpose -> String

showList :: [Transpose] -> ShowS

data MatUpLo

For Symmetric, Hermetian or Triangular matrices, which part is modeled.

Constructors

MatUpper

MatLower

Instances

Eq MatUpLo

Methods

(==) :: MatUpLo -> MatUpLo -> Bool

(/=) :: MatUpLo -> MatUpLo -> Bool

Show MatUpLo

Methods

showsPrec :: Int -> MatUpLo -> ShowS

show :: MatUpLo -> String

showList :: [MatUpLo] -> ShowS

data MatDiag

Many triangular matrix routines expect to know if the matrix is all 1 (unit ) on the diagonal or not. Likewise, Many Factorizations routines can be assumed to return unit triangular matrices

Constructors

MatUnit

MatNonUnit

Instances

Eq MatDiag

Methods

(==) :: MatDiag -> MatDiag -> Bool

(/=) :: MatDiag -> MatDiag -> Bool

Show MatDiag

Methods

showsPrec :: Int -> MatDiag -> ShowS

show :: MatDiag -> String

showList :: [MatDiag] -> ShowS

data EquationSide

For certain Square matrix product, do you want to Compute A*B or B*A only used as an argument

Constructors

LeftSide

RightSide

Instances

Eq EquationSide

Methods

(==) :: EquationSide -> EquationSide -> Bool

(/=) :: EquationSide -> EquationSide -> Bool

Show EquationSide

Methods

showsPrec :: Int -> EquationSide -> ShowS

show :: EquationSide -> String

showList :: [EquationSide] -> ShowS

type family TransposeF (x :: Orientation) :: Orientation

Instances

type TransposeF Column

type TransposeF Column = Row

type TransposeF Row

type TransposeF Row = Column

data Variant

Constructors

Direct

Implicit

Instances

Eq Variant

Methods

(==) :: Variant -> Variant -> Bool

(/=) :: Variant -> Variant -> Bool

Show Variant

Methods

showsPrec :: Int -> Variant -> ShowS

show :: Variant -> String

showList :: [Variant] -> ShowS

data SVariant :: Variant -> * where

Variant and SVariant are a bit odd looking, They crop up when needing to talk about eg the row vectors of a packed triangular row major matrix wrt both their logical size and manifest sizes this notion only makes sense in the 1dim case. If you don't understand this parameter, just use SDirect and Direct as they will generally be the correct choice for most users.

Constructors

SImplicit :: {..} -> SVariant Implicit

Fields

• _frontPadding :: !Int
• _endPadding :: !Int

SDirect :: SVariant Direct

data DenseVector :: Variant -> * -> * where

Constructors

DenseVector :: {..} -> DenseVector varnt elem

Fields

• _VariantDenseVect :: !(SVariant varnt)
• _LogicalDimDenseVector :: !Int
• _StrideDenseVector :: !Int
• _bufferDenseVector :: !(Vector elem)

data MDenseVector :: * -> Variant -> * -> * where

Constructors

MutableDenseVector :: {..} -> MDenseVector s varnt elem

Fields

• _VariantMutDenseVect :: !(SVariant varnt)
• _LogicalDimMutDenseVector :: !Int
• _StrideMutDenseVector :: !Int
• _bufferMutDenseVector :: !(MVector s elem)

data DenseMatrix :: Orientation -> * -> * where

DenseMatrix is for dense row or column major matrices

Constructors

DenseMatrix :: {..} -> DenseMatrix ornt elem

Fields

• _OrientationMat :: SOrientation ornt
• _XdimDenMat :: !Int
• _YdimDenMat :: !Int
• _StrideDenMat :: !Int
• _bufferDenMat :: !(Vector elem)

Instances

(Eq b, Storable b) => Eq (DenseMatrix a b)

Methods

(==) :: DenseMatrix a b -> DenseMatrix a b -> Bool

(/=) :: DenseMatrix a b -> DenseMatrix a b -> Bool

(Ord b, Storable b) => Ord (DenseMatrix a b)

Methods

compare :: DenseMatrix a b -> DenseMatrix a b -> Ordering

(<) :: DenseMatrix a b -> DenseMatrix a b -> Bool

(<=) :: DenseMatrix a b -> DenseMatrix a b -> Bool

(>) :: DenseMatrix a b -> DenseMatrix a b -> Bool

(>=) :: DenseMatrix a b -> DenseMatrix a b -> Bool

max :: DenseMatrix a b -> DenseMatrix a b -> DenseMatrix a b

min :: DenseMatrix a b -> DenseMatrix a b -> DenseMatrix a b

(Storable b, Show b) => Show (DenseMatrix a b)

Methods

showsPrec :: Int -> DenseMatrix a b -> ShowS

show :: DenseMatrix a b -> String

showList :: [DenseMatrix a b] -> ShowS

mutableVectorToList :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m [a]

toList routine for pure matrices TODO this should build on top of a traverse/mapM style routine like the mapper etc

this should never be used in real code, ever ever, but its handy for testing but seriously never use this in real code, it doesn't do what you think because in the case of a matrix slice, the underlying buffer will have additional elements aside from the ones you expect! never use this in real code please. :)

data MDenseMatrix :: * -> Orientation -> * -> * where

MDenseMatrix

Constructors

MutableDenseMatrix :: {..} -> MDenseMatrix s ornt elem

Fields

• _OrientationMutMat :: SOrientation ornt
• _XdimDenMutMat :: !Int
• _YdimDenMutMat :: !Int
• _StrideDenMutMat :: !Int
• _bufferDenMutMat :: !(MVector s elem)

type IODenseMatrix = MDenseMatrix RealWorld

unsafeFreezeDenseMatrix :: (Storable elem, PrimMonad m) => MDenseMatrix (PrimState m) or elem -> m (DenseMatrix or elem)

unsafeThawDenseMatrix :: (Storable elem, PrimMonad m) => DenseMatrix or elem -> m (MDenseMatrix (PrimState m) or elem)

getDenseMatrixRow :: DenseMatrix or elem -> Int

getDenseMatrixColumn :: DenseMatrix or elem -> Int

getDenseMatrixLeadingDimStride :: DenseMatrix or elem -> Int

getDenseMatrixArray :: DenseMatrix or elem -> Vector elem

getDenseMatrixOrientation :: DenseMatrix or elem -> SOrientation or

uncheckedDenseMatrixIndex :: Storable elem => DenseMatrix or elem -> (Int, Int) -> elem

uncheckedDenseMatrixIndexM :: (Monad m, Storable elem) => DenseMatrix or elem -> (Int, Int) -> m elem

uncheckedMutableDenseMatrixIndexM :: (PrimMonad m, Storable elem) => MDenseMatrix (PrimState m) or elem -> (Int, Int) -> m elem

swap :: (a, b) -> (b, a)

mapDenseMatrix :: (Storable a, Storable b) => (a -> b) -> DenseMatrix or a -> DenseMatrix or b

`map f matrix`

imapDenseMatrix :: (Storable a, Storable b) => ((Int, Int) -> a -> b) -> DenseMatrix or a -> DenseMatrix or b

uncheckedDenseMatrixNextTuple :: DenseMatrix or elem -> (Int, Int) -> Maybe (Int, Int)

In Matrix format memory order enumeration of the index tuples, for good locality 2dim map

generateDenseMatrix :: Storable a => SOrientation x -> (Int, Int) -> ((Int, Int) -> a) -> DenseMatrix x a

generateDenseMatrix Row (k,k) (i,j)-> if i == j then 1.0 else 0.0 would generate a KxK identity matrix

generateMutableDenseMatrix :: (Storable a, PrimMonad m) => SOrientation x -> (Int, Int) -> ((Int, Int) -> a) -> m (MDenseMatrix (PrimState m) x a)

mutable version of generateDenseMatrix

generateMutableUpperTriangular :: forall a x m. (Num a, Storable a, PrimMonad m) => SOrientation x -> (Int, Int) -> ((Int, Int) -> a) -> m (MDenseMatrix (PrimState m) x a)

generateMutableLowerTriangular :: forall a x m. (Num a, Storable a, PrimMonad m) => SOrientation x -> (Int, Int) -> ((Int, Int) -> a) -> m (MDenseMatrix (PrimState m) x a)

generateMutableDenseVector :: (Storable a, PrimMonad m) => Int -> (Int -> a) -> m (MDenseVector (PrimState m) Direct a)

generateMutableDenseVectorWithStride :: (Num a, Storable a, PrimMonad m) => Int -> Int -> (Int -> a) -> m (MDenseVector (PrimState m) Direct a)

uncheckedDenseMatrixSlice :: Storable elem => DenseMatrix or elem -> (Int, Int) -> (Int, Int) -> DenseMatrix or elem

transposeDenseMatrix :: (inor ~ TransposeF outor, outor ~ TransposeF inor) => DenseMatrix inor elem -> DenseMatrix outor elem

tranposeMatrix does a shallow transpose that swaps the format and the x y params, but changes nothing in the memory layout. Most applications where transpose is used in a computation need a deep, copying, tranpose operation