Asum computes the sum of magnitudes of the real and imaginary parts of elements of the vector x: \sum_i (|Re x[i]| + |Im x[i]|).

Axpy computes y = alpha * x + y, where x and y are vectors, and alpha is a scalar.

Copy copies the elements of x into the elements of y: y[i] = x[i] for all i.

Dotc computes the dot product of the two vectors with complex conjugation: x^H * y.

Dotu computes the dot product of the two vectors without complex conjugation: x^T * y.

Dscal computes x = alpha * x, where x is a vector, and alpha is a real scalar.

Gbmv computes y = alpha * A * x + beta * y, if t == blas.NoTrans, y = alpha * A^T * x + beta * y, if t == blas.Trans, y = alpha * A^H * x + beta * y, if t == blas.ConjTrans, where A is an m×n band matrix, x and y are vectors, and alpha and beta are scalars.

Gemm computes C = alpha * A * B + beta * C, where A, B, and C are dense matrices, and alpha and beta are scalars.

Gemv computes y = alpha * A * x + beta * y, if t == blas.NoTrans, y = alpha * A^T * x + beta * y, if t == blas.Trans, y = alpha * A^H * x + beta * y, if t == blas.ConjTrans, where A is an m×n dense matrix, x and y are vectors, and alpha and beta are scalars.

Gerc performs a rank-1 update A += alpha * x * y^H, where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.

Geru performs a rank-1 update A += alpha * x * y^T, where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.

Hbmv performs y = alpha * A * x + beta * y, where A is an n×n Hermitian band matrix, x and y are vectors, and alpha and beta are scalars.

Hemm performs C = alpha * A * B + beta * C, if s == blas.Left, C = alpha * B * A + beta * C, if s == blas.Right, where A is an n×n or m×m Hermitian matrix, B and C are m×n matrices, and alpha and beta are scalars.

Hemv computes y = alpha * A * x + beta * y, where A is an n×n Hermitian matrix, x and y are vectors, and alpha and beta are scalars.

Her performs a rank-1 update A += alpha * x * y^T, where A is an m×n Hermitian matrix, x and y are vectors, and alpha is a scalar.

Her2 performs a rank-2 update A += alpha * x * y^H + conj(alpha) * y * x^H, where A is an n×n Hermitian matrix, x and y are vectors, and alpha is a scalar.

Her2k performs the Hermitian rank-2k update C = alpha * A * B^H + conj(alpha) * B * A^H + beta * C, if t == blas.NoTrans, C = alpha * A^H * B + conj(alpha) * B^H * A + beta * C, if t == blas.ConjTrans, where C is an n×n Hermitian matrix, A and B are n×k matrices if t == NoTrans and k×n matrices otherwise, and alpha and beta are scalars.

Herk performs the Hermitian rank-k update C = alpha * A * A^H + beta*C, if t == blas.NoTrans, C = alpha * A^H * A + beta*C, if t == blas.ConjTrans, where C is an n×n Hermitian matrix, A is an n×k matrix if t == blas.NoTrans and a k×n matrix otherwise, and alpha and beta are scalars.

Hpmv performs y = alpha * A * x + beta * y, where A is an n×n Hermitian matrix in packed format, x and y are vectors, and alpha and beta are scalars.

Hpr performs a rank-1 update A += alpha * x * x^H, where A is an n×n Hermitian matrix in packed format, x is a vector, and alpha is a scalar.

Hpr2 performs a rank-2 update A += alpha * x * y^H + conj(alpha) * y * x^H, where A is an n×n Hermitian matrix in packed format, x and y are vectors, and alpha is a scalar.

Iamax returns the index of an element of x with the largest sum of magnitudes of the real and imaginary parts (|Re x[i]|+|Im x[i]|).

Implementation returns the current BLAS complex64 implementation.

Nrm2 computes the Euclidean norm of the vector x: sqrt(\sum_i x[i] * x[i]).

Scal computes x = alpha * x, where x is a vector, and alpha is a scalar.

Swap exchanges the elements of two vectors: x[i], y[i] = y[i], x[i] for all i.

Symm performs C = alpha * A * B + beta * C, if s == blas.Left, C = alpha * B * A + beta * C, if s == blas.Right, where A is an n×n or m×m symmetric matrix, B and C are m×n matrices, and alpha and beta are scalars.

Syr2k performs a symmetric rank-2k update C = alpha * A * B^T + alpha * B * A^T + beta * C, if t == blas.NoTrans, C = alpha * A^T * B + alpha * B^T * A + beta * C, if t == blas.Trans, where C is an n×n symmetric matrix, A and B are n×k matrices if t == blas.NoTrans and k×n otherwise, and alpha and beta are scalars.

Syrk performs a symmetric rank-k update C = alpha * A * A^T + beta * C, if t == blas.NoTrans, C = alpha * A^T * A + beta * C, if t == blas.Trans, where C is an n×n symmetric matrix, A is an n×k matrix if t == blas.NoTrans and a k×n matrix otherwise, and alpha and beta are scalars.

Tbmv computes x = A * x, if t == blas.NoTrans, x = A^T * x, if t == blas.Trans, x = A^H * x, if t == blas.ConjTrans, where A is an n×n triangular band matrix, and x is a vector.

Tbsv solves A * x = b, if t == blas.NoTrans, A^T * x = b, if t == blas.Trans, A^H * x = b, if t == blas.ConjTrans, where A is an n×n triangular band matrix, and x is a vector.

Tpmv computes x = A * x, if t == blas.NoTrans, x = A^T * x, if t == blas.Trans, x = A^H * x, if t == blas.ConjTrans, where A is an n×n triangular matrix in packed format, and x is a vector.

Tpsv solves A * x = b, if t == blas.NoTrans, A^T * x = b, if t == blas.Trans, A^H * x = b, if t == blas.ConjTrans, where A is an n×n triangular matrix in packed format and x is a vector.

Trmm performs B = alpha * A * B, if tA == blas.NoTrans and s == blas.Left, B = alpha * A^T * B, if tA == blas.Trans and s == blas.Left, B = alpha * A^H * B, if tA == blas.ConjTrans and s == blas.Left, B = alpha * B * A, if tA == blas.NoTrans and s == blas.Right, B = alpha * B * A^T, if tA == blas.Trans and s == blas.Right, B = alpha * B * A^H, if tA == blas.ConjTrans and s == blas.Right, where A is an n×n or m×m triangular matrix, B is an m×n matrix, and alpha is a scalar.

Trmv computes x = A * x, if t == blas.NoTrans, x = A^T * x, if t == blas.Trans, x = A^H * x, if t == blas.ConjTrans, where A is an n×n triangular matrix, and x is a vector.

Trsm solves A * X = alpha * B, if tA == blas.NoTrans and s == blas.Left, A^T * X = alpha * B, if tA == blas.Trans and s == blas.Left, A^H * X = alpha * B, if tA == blas.ConjTrans and s == blas.Left, X * A = alpha * B, if tA == blas.NoTrans and s == blas.Right, X * A^T = alpha * B, if tA == blas.Trans and s == blas.Right, X * A^H = alpha * B, if tA == blas.ConjTrans and s == blas.Right, where A is an n×n or m×m triangular matrix, X and B are m×n matrices, and alpha is a scalar.

Trsv solves A * x = b, if t == blas.NoTrans, A^T * x = b, if t == blas.Trans, A^H * x = b, if t == blas.ConjTrans, where A is an n×n triangular matrix and x is a vector.

Use sets the BLAS complex64 implementation to be used by subsequent BLAS calls.

Band represents a band matrix using the band storage scheme.

General represents a matrix using the conventional storage scheme.

Symmetric represents a symmetric matrix using the conventional storage scheme.

SymmetricBand represents a symmetric matrix using the band storage scheme.

SymmetricPacked represents a symmetric matrix using the packed storage scheme.

Triangular represents a triangular matrix using the conventional storage scheme.

TriangularBand represents a triangular matrix using the band storage scheme.

TriangularPacked represents a triangular matrix using the packed storage scheme.

Vector represents a vector with an associated element increment.

Hermitian represents an Hermitian matrix using the conventional storage scheme.

HermitianBand represents an Hermitian matrix using the band storage scheme.

HermitianPacked represents an Hermitian matrix using the packed storage scheme.