Asum computes the sum of the absolute values of the elements of x: \sum_i |x[i]|.

Axpy adds x scaled by alpha to y: y[i] += alpha*x[i] for all i.

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

DDot computes the dot product of the two vectors: \sum_i x[i]*y[i].

Dot computes the dot product of the two vectors: \sum_i x[i]*y[i].

Gbmv computes y = alpha * A * x + beta * y, if t == blas.NoTrans, y = alpha * A^T * x + beta * y, if t == blas.Trans or 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 or blas.ConjTrans, where A is an m×n dense matrix, x and y are vectors, and alpha and beta are scalars.

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

Iamax returns the index of an element of x with the largest absolute value.

Implementation returns the current BLAS float32 implementation.

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

Rot applies a plane transformation to n points represented by the vectors x and y: x[i] = c*x[i] + s*y[i], y[i] = -s*x[i] + c*y[i], for all i.

Rotg computes the parameters of a Givens plane rotation so that ⎡ c s⎤ ⎡a⎤ ⎡r⎤ ⎣-s c⎦ * ⎣b⎦ = ⎣0⎦ where a and b are the Cartesian coordinates of a given point.

Rotm applies the modified Givens rotation to n points represented by the vectors x and y.

Rotmg computes the modified Givens rotation.

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

Scal scales the vector x by alpha: x[i] *= alpha for all i.

SDDot computes the dot product of the two vectors adding a constant: alpha + \sum_i x[i]*y[i].

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

Spr performs the rank-1 update A += alpha * x * x^T, where A is an n×n symmetric matrix in packed format, x is a vector, and alpha is a scalar.

Spr2 performs a rank-2 update A += alpha * x * y^T + alpha * y * x^T, where A is an n×n symmetric matrix in packed format, x and y are vectors, and alpha is a scalar.

Swap exchanges the elements of the 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 is a scalar.

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

Syr performs a rank-1 update A += alpha * x * x^T, where A is an n×n symmetric matrix, x is a vector, and alpha is a scalar.

Syr2 performs a rank-2 update A += alpha * x * y^T + alpha * y * x^T, where A is a symmetric n×n matrix, x and y are vectors, and alpha is a scalar.

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 or blas.ConjTrans, where C is an n×n symmetric matrix, A and B are n×k matrices if t == NoTrans and k×n matrices 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 or blas.ConjTrans, 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 or 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 or blas.ConjTrans, where A is an n×n triangular band matrix, and x and b are vectors.

Tpmv computes x = A * x, if t == blas.NoTrans, x = A^T * x, if t == blas.Trans or 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 or blas.ConjTrans, where A is an n×n triangular matrix in packed format, and x and b are vectors.

Trmm performs B = alpha * A * B, if tA == blas.NoTrans and s == blas.Left, B = alpha * A^T * B, if tA == blas.Trans or 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 or 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 or 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 or 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 or 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 or blas.ConjTrans, where A is an n×n triangular matrix, and x and b are vectors.

Use sets the BLAS float32 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.