blas-hs-0.1.1.0: Low-level Haskell bindings to Blas.

StabilityExperimental
Safe HaskellSafe
LanguageHaskell98

Blas.Generic.Safe

Description

Generic interface to Blas using safe foreign calls. Refer to the GHC documentation for more information regarding appropriate use of safe and unsafe foreign calls.

The functions here are named in a similar fashion to the original Blas interface, with the type-dependent letter(s) removed. Some functions have been merged with others to allow the interface to work on both real and complex numbers. If you can't a particular function, try looking for its corresponding complex equivalent (e.g. symv is a special case of hemv applied to real numbers).

Note: although complex versions of rot and rotg exist in many implementations, they are not part of the official Blas standard and therefore not included here. If you really need them, submit a ticket so we can try to come up with a solution.

The documentation here is still incomplete. Consult the official documentation for more information.

Notation:

  • denotes dot product (without any conjugation).
  • * denotes complex conjugation.
  • denotes transpose.
  • denotes conjugate transpose (Hermitian conjugate).

Conventions:

  • All scalars are denoted with lowercase Greek letters
  • All vectors are denoted with lowercase Latin letters and are assumed to be column vectors (unless transposed).
  • All matrices are denoted with uppercase Latin letters.

Synopsis

Documentation

class (Floating a, Storable a) => Numeric a where #

Blas operations that are applicable to real and complex numbers.

Instances are defined for the 4 types supported by Blas: the single- and double-precision floating point types and their complex versions.

Minimal complete definition

swap, scal, copy, axpy, dotu, dotc, nrm2, asum, iamax, gemv, gbmv, hemv, hbmv, hpmv, trmv, tbmv, tpmv, trsv, tbsv, tpsv, geru, gerc, her, hpr, her2, hpr2, gemm, symm, hemm, syrk, herk, syr2k, her2k, trmm, trsm

Associated Types

type RealType a :: * #

The corresponding real type of a.

In other words, RealType (Complex a) is an alias for a. For everything else, RealType a is simply a.

Methods

swap :: Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Swap two vectors:

(x, y) ← (y, x)

scal :: Int -> a -> Ptr a -> Int -> IO () #

Multiply a vector by a scalar.

x ← α x

copy :: Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Copy a vector into another vector:

y ← x

axpy :: Int -> a -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Add a scalar-vector product to a vector.

y ← α x + y

dotu :: Int -> Ptr a -> Int -> Ptr a -> Int -> IO a #

Calculate the bilinear dot product of two vectors:

x ⋅ y ≡ ∑[i] x[i] y[i]

dotc :: Int -> Ptr a -> Int -> Ptr a -> Int -> IO a #

Calculate the sesquilinear dot product of two vectors.

x* ⋅ y ≡ ∑[i] x[i]* y[i]

nrm2 :: Int -> Ptr a -> Int -> IO (RealType a) #

Calculate the Euclidean (L²) norm of a vector:

‖x‖₂ ≡ √(∑[i] x[i]²)

asum :: Int -> Ptr a -> Int -> IO (RealType a) #

Calculate the Manhattan (L¹) norm, equal to the sum of the magnitudes of the elements:

‖x‖₁ = ∑[i] |x[i]|

iamax :: Int -> Ptr a -> Int -> IO Int #

Calculate the index of the element with the maximum magnitude (absolute value).

gemv :: Order -> Transpose -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a general matrix-vector update.

y ← α T(A) x + β y

gbmv :: Order -> Transpose -> Int -> Int -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a general banded matrix-vector update.

y ← α T(A) x + β y

hemv :: Order -> Uplo -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a hermitian matrix-vector update.

y ← α A x + β y

hbmv :: Order -> Uplo -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a hermitian banded matrix-vector update.

y ← α A x + β y

hpmv :: Order -> Uplo -> Int -> a -> Ptr a -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a hermitian packed matrix-vector update.

y ← α A x + β y

trmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Multiply a triangular matrix by a vector.

x ← T(A) x

tbmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Multiply a triangular banded matrix by a vector.

x ← T(A) x

tpmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr a -> Ptr a -> Int -> IO () #

Multiply a triangular packed matrix by a vector.

x ← T(A) x

trsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Multiply an inverse triangular matrix by a vector.

x ← T(A⁻¹) x

tbsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Multiply an inverse triangular banded matrix by a vector.

x ← T(A⁻¹) x

tpsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr a -> Ptr a -> Int -> IO () #

Multiply an inverse triangular packed matrix by a vector.

x ← T(A⁻¹) x

geru :: Order -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Perform an unconjugated rank-1 update of a general matrix.

A ← α x y⊤ + A

gerc :: Order -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Perform a conjugated rank-1 update of a general matrix.

A ← α x y† + A

her :: Order -> Uplo -> Int -> RealType a -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Perform a rank-1 update of a Hermitian matrix.

A ← α x y† + A

hpr :: Order -> Uplo -> Int -> RealType a -> Ptr a -> Int -> Ptr a -> IO () #

Perform a rank-1 update of a Hermitian packed matrix.

A ← α x y† + A

her2 :: Order -> Uplo -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Perform a rank-2 update of a Hermitian matrix.

A ← α x y† + y (α x)† + A

hpr2 :: Order -> Uplo -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> Ptr a -> IO () #

Perform a rank-2 update of a Hermitian packed matrix.

A ← α x y† + y (α x)† + A

gemm #

Arguments

:: Order

Layout of all the matrices.

-> Transpose

The operation T to be applied to A.

-> Transpose

The operation U to be applied to B.

-> Int

Number of rows of T(A) and C.

-> Int

Number of columns of U(B) and C.

-> Int

Number of columns of T(A) and number of rows of U(B).

-> a

Scaling factor α of the product.

-> Ptr a

Pointer to a matrix A.

-> Int

Stride of the major dimension of A.

-> Ptr a

Pointer to a matrix B.

-> Int

Stride of the major dimension of B.

-> a

Scaling factor β of the original C.

-> Ptr a

Pointer to a mutable matrix C.

-> Int

Stride of the major dimension of C.

-> IO () 

Perform a general matrix-matrix update.

C ← α T(A) U(B) + β C

symm #

Arguments

:: Order

Layout of all the matrices.

-> Side

Side that A appears in the product.

-> Uplo

The part of A that is used.

-> Int

Number of rows of C.

-> Int

Number of columns of C.

-> a

Scaling factor α of the product.

-> Ptr a

Pointer to a symmetric matrix A.

-> Int

Stride of the major dimension of A.

-> Ptr a

Pointer to a matrix B.

-> Int

Stride of the major dimension of B.

-> a

Scaling factor α of the original C.

-> Ptr a

Pointer to a mutable matrix C.

-> Int

Stride of the major dimension of C.

-> IO () 

Perform a symmetric matrix-matrix update.

C ← α A B + β C    or    C ← α B A + β C

where A is symmetric. The matrix A must be in an unpacked format, although the routine will only access half of it as specified by the Uplo argument.

hemm #

Arguments

:: Order

Layout of all the matrices.

-> Side

Side that A appears in the product.

-> Uplo

The part of A that is used.

-> Int

Number of rows of C.

-> Int

Number of columns of C.

-> a

Scaling factor α of the product.

-> Ptr a

Pointer to a Hermitian matrix A.

-> Int

Stride of the major dimension of A.

-> Ptr a

Pointer to a matrix B.

-> Int

Stride of the major dimension of B.

-> a

Scaling factor α of the original C.

-> Ptr a

Pointer to a mutable matrix C.

-> Int

Stride of the major dimension of C.

-> IO () 

Perform a Hermitian matrix-matrix update.

C ← α A B + β C    or    C ← α B A + β C

where A is Hermitian. The matrix A must be in an unpacked format, although the routine will only access half of it as specified by the Uplo argument.

syrk :: Order -> Uplo -> Transpose -> Int -> Int -> a -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a symmetric rank-k update.

C ← α A A⊤ + β C    or    C ← α A⊤ A + β C

herk :: Order -> Uplo -> Transpose -> Int -> Int -> RealType a -> Ptr a -> Int -> RealType a -> Ptr a -> Int -> IO () #

Perform a Hermitian rank-k update.

C ← α A A† + β C    or    C ← α A† A + β C

syr2k :: Order -> Uplo -> Transpose -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> a -> Ptr a -> Int -> IO () #

Perform a symmetric rank-2k update.

C ← α A B⊤ + α* B A⊤ + β C    or    C ← α A⊤ B + α* B⊤ A + β C

her2k :: Order -> Uplo -> Transpose -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> RealType a -> Ptr a -> Int -> IO () #

Perform a Hermitian rank-2k update.

C ← α A B† + α* B A† + β C    or    C ← α A† B + α* B† A + β C

trmm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Perform a triangular matrix-matrix multiplication.

B ← α T(A) B    or    B ← α B T(A)

where A is triangular.

trsm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> a -> Ptr a -> Int -> Ptr a -> Int -> IO () #

Perform an inverse triangular matrix-matrix multiplication.

B ← α T(A⁻¹) B    or    B ← α B T(A⁻¹)

where A is triangular.

Instances

Numeric Double # 

Associated Types

type RealType Double :: * #

Methods

swap :: Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

scal :: Int -> Double -> Ptr Double -> Int -> IO () #

copy :: Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

axpy :: Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

dotu :: Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO Double #

dotc :: Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO Double #

nrm2 :: Int -> Ptr Double -> Int -> IO (RealType Double) #

asum :: Int -> Ptr Double -> Int -> IO (RealType Double) #

iamax :: Int -> Ptr Double -> Int -> IO Int #

gemv :: Order -> Transpose -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

gbmv :: Order -> Transpose -> Int -> Int -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

hemv :: Order -> Uplo -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

hbmv :: Order -> Uplo -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

hpmv :: Order -> Uplo -> Int -> Double -> Ptr Double -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

trmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

tbmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

tpmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Double -> Ptr Double -> Int -> IO () #

trsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

tbsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

tpsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Double -> Ptr Double -> Int -> IO () #

geru :: Order -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

gerc :: Order -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

her :: Order -> Uplo -> Int -> RealType Double -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

hpr :: Order -> Uplo -> Int -> RealType Double -> Ptr Double -> Int -> Ptr Double -> IO () #

her2 :: Order -> Uplo -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

hpr2 :: Order -> Uplo -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Ptr Double -> IO () #

gemm :: Order -> Transpose -> Transpose -> Int -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

symm :: Order -> Side -> Uplo -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

hemm :: Order -> Side -> Uplo -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

syrk :: Order -> Uplo -> Transpose -> Int -> Int -> Double -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

herk :: Order -> Uplo -> Transpose -> Int -> Int -> RealType Double -> Ptr Double -> Int -> RealType Double -> Ptr Double -> Int -> IO () #

syr2k :: Order -> Uplo -> Transpose -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Ptr Double -> Int -> IO () #

her2k :: Order -> Uplo -> Transpose -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> RealType Double -> Ptr Double -> Int -> IO () #

trmm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

trsm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Double -> Ptr Double -> Int -> Ptr Double -> Int -> IO () #

Numeric Float # 

Associated Types

type RealType Float :: * #

Methods

swap :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

scal :: Int -> Float -> Ptr Float -> Int -> IO () #

copy :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

axpy :: Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

dotu :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO Float #

dotc :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO Float #

nrm2 :: Int -> Ptr Float -> Int -> IO (RealType Float) #

asum :: Int -> Ptr Float -> Int -> IO (RealType Float) #

iamax :: Int -> Ptr Float -> Int -> IO Int #

gemv :: Order -> Transpose -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

gbmv :: Order -> Transpose -> Int -> Int -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

hemv :: Order -> Uplo -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

hbmv :: Order -> Uplo -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

hpmv :: Order -> Uplo -> Int -> Float -> Ptr Float -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

trmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

tbmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

tpmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Float -> Ptr Float -> Int -> IO () #

trsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

tbsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

tpsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr Float -> Ptr Float -> Int -> IO () #

geru :: Order -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

gerc :: Order -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

her :: Order -> Uplo -> Int -> RealType Float -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

hpr :: Order -> Uplo -> Int -> RealType Float -> Ptr Float -> Int -> Ptr Float -> IO () #

her2 :: Order -> Uplo -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

hpr2 :: Order -> Uplo -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Ptr Float -> IO () #

gemm :: Order -> Transpose -> Transpose -> Int -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

symm :: Order -> Side -> Uplo -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

hemm :: Order -> Side -> Uplo -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

syrk :: Order -> Uplo -> Transpose -> Int -> Int -> Float -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

herk :: Order -> Uplo -> Transpose -> Int -> Int -> RealType Float -> Ptr Float -> Int -> RealType Float -> Ptr Float -> Int -> IO () #

syr2k :: Order -> Uplo -> Transpose -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Ptr Float -> Int -> IO () #

her2k :: Order -> Uplo -> Transpose -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> RealType Float -> Ptr Float -> Int -> IO () #

trmm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

trsm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> IO () #

Numeric (Complex Double) # 

Associated Types

type RealType (Complex Double) :: * #

Methods

swap :: Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

scal :: Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

copy :: Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

axpy :: Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

dotu :: Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO (Complex Double) #

dotc :: Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO (Complex Double) #

nrm2 :: Int -> Ptr (Complex Double) -> Int -> IO (RealType (Complex Double)) #

asum :: Int -> Ptr (Complex Double) -> Int -> IO (RealType (Complex Double)) #

iamax :: Int -> Ptr (Complex Double) -> Int -> IO Int #

gemv :: Order -> Transpose -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

gbmv :: Order -> Transpose -> Int -> Int -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

hemv :: Order -> Uplo -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

hbmv :: Order -> Uplo -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

hpmv :: Order -> Uplo -> Int -> Complex Double -> Ptr (Complex Double) -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

trmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

tbmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

tpmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Double) -> Ptr (Complex Double) -> Int -> IO () #

trsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

tbsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

tpsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Double) -> Ptr (Complex Double) -> Int -> IO () #

geru :: Order -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

gerc :: Order -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

her :: Order -> Uplo -> Int -> RealType (Complex Double) -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

hpr :: Order -> Uplo -> Int -> RealType (Complex Double) -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> IO () #

her2 :: Order -> Uplo -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

hpr2 :: Order -> Uplo -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> IO () #

gemm :: Order -> Transpose -> Transpose -> Int -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

symm :: Order -> Side -> Uplo -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

hemm :: Order -> Side -> Uplo -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

syrk :: Order -> Uplo -> Transpose -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

herk :: Order -> Uplo -> Transpose -> Int -> Int -> RealType (Complex Double) -> Ptr (Complex Double) -> Int -> RealType (Complex Double) -> Ptr (Complex Double) -> Int -> IO () #

syr2k :: Order -> Uplo -> Transpose -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> IO () #

her2k :: Order -> Uplo -> Transpose -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> RealType (Complex Double) -> Ptr (Complex Double) -> Int -> IO () #

trmm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

trsm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Complex Double -> Ptr (Complex Double) -> Int -> Ptr (Complex Double) -> Int -> IO () #

Numeric (Complex Float) # 

Associated Types

type RealType (Complex Float) :: * #

Methods

swap :: Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

scal :: Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

copy :: Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

axpy :: Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

dotu :: Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO (Complex Float) #

dotc :: Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO (Complex Float) #

nrm2 :: Int -> Ptr (Complex Float) -> Int -> IO (RealType (Complex Float)) #

asum :: Int -> Ptr (Complex Float) -> Int -> IO (RealType (Complex Float)) #

iamax :: Int -> Ptr (Complex Float) -> Int -> IO Int #

gemv :: Order -> Transpose -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

gbmv :: Order -> Transpose -> Int -> Int -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

hemv :: Order -> Uplo -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

hbmv :: Order -> Uplo -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

hpmv :: Order -> Uplo -> Int -> Complex Float -> Ptr (Complex Float) -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

trmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

tbmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

tpmv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Float) -> Ptr (Complex Float) -> Int -> IO () #

trsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

tbsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

tpsv :: Order -> Uplo -> Transpose -> Diag -> Int -> Ptr (Complex Float) -> Ptr (Complex Float) -> Int -> IO () #

geru :: Order -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

gerc :: Order -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

her :: Order -> Uplo -> Int -> RealType (Complex Float) -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

hpr :: Order -> Uplo -> Int -> RealType (Complex Float) -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> IO () #

her2 :: Order -> Uplo -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

hpr2 :: Order -> Uplo -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> IO () #

gemm :: Order -> Transpose -> Transpose -> Int -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

symm :: Order -> Side -> Uplo -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

hemm :: Order -> Side -> Uplo -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

syrk :: Order -> Uplo -> Transpose -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

herk :: Order -> Uplo -> Transpose -> Int -> Int -> RealType (Complex Float) -> Ptr (Complex Float) -> Int -> RealType (Complex Float) -> Ptr (Complex Float) -> Int -> IO () #

syr2k :: Order -> Uplo -> Transpose -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> IO () #

her2k :: Order -> Uplo -> Transpose -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> RealType (Complex Float) -> Ptr (Complex Float) -> Int -> IO () #

trmm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

trsm :: Order -> Side -> Uplo -> Transpose -> Diag -> Int -> Int -> Complex Float -> Ptr (Complex Float) -> Int -> Ptr (Complex Float) -> Int -> IO () #

class Numeric a => RealNumeric a where #

Blas operations that are only applicable to real numbers.

Minimal complete definition

rotg, rotmg, rot, rotm

Methods

rotg :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO () #

Generate a Givens rotation. (Only available for real floating-point types.)

rotmg :: Ptr a -> Ptr a -> Ptr a -> a -> Ptr a -> IO () #

Generate a modified Givens rotation. (Only available for real floating-point types.)

rot :: Int -> Ptr a -> Int -> Ptr a -> Int -> a -> a -> IO () #

Apply a Givens rotation. (Only available for real floating-point types.)

rotm :: Int -> Ptr a -> Int -> Ptr a -> Int -> Ptr a -> IO () #

Apply a modified Givens rotation. (Only available for real floating-point types.)

Instances

RealNumeric Double # 

Methods

rotg :: Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO () #

rotmg :: Ptr Double -> Ptr Double -> Ptr Double -> Double -> Ptr Double -> IO () #

rot :: Int -> Ptr Double -> Int -> Ptr Double -> Int -> Double -> Double -> IO () #

rotm :: Int -> Ptr Double -> Int -> Ptr Double -> Int -> Ptr Double -> IO () #

RealNumeric Float # 

Methods

rotg :: Ptr Float -> Ptr Float -> Ptr Float -> Ptr Float -> IO () #

rotmg :: Ptr Float -> Ptr Float -> Ptr Float -> Float -> Ptr Float -> IO () #

rot :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> Float -> Float -> IO () #

rotm :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> Ptr Float -> IO () #

dsdot :: Int -> Ptr Float -> Int -> Ptr Float -> Int -> IO Double #

Calculate the dot product of two vectors with extended precision accumulation of the intermediate results and return a double-precision result. (Only available in the Double module.)

sdsdot :: Int -> Float -> Ptr Float -> Int -> Ptr Float -> Int -> IO Float #

Calculate the dot product of two vectors with extended precision accumulation of the intermediate results and add a scalar value to the result. (Only available for the Float type.)