## Documentation

### Overview ¶

Package blas32 provides a simple interface to the float32 BLAS API.

### Constants ¶

This section is empty.

### Variables ¶

This section is empty.

### Functions ¶

#### func Asum¶

func Asum(x Vector) float32

Asum computes the sum of the absolute values of the elements of x:

\sum_i |x[i]|.


Asum will panic if the vector increment is negative.

#### func Axpy¶

func Axpy(alpha float32, x, y Vector)

Axpy adds x scaled by alpha to y:

y[i] += alpha*x[i] for all i.


Axpy will panic if the lengths of x and y do not match.

#### func Copy¶

func Copy(x, y Vector)

Copy copies the elements of x into the elements of y:

y[i] = x[i] for all i.


Copy will panic if the lengths of x and y do not match.

#### func DDot¶

func DDot(x, y Vector) float64

DDot computes the dot product of the two vectors:

\sum_i x[i]*y[i].


DDot will panic if the lengths of x and y do not match.

#### func Dot¶

func Dot(x, y Vector) float32

Dot computes the dot product of the two vectors:

\sum_i x[i]*y[i].


Dot will panic if the lengths of x and y do not match.

#### func Gbmv¶

func Gbmv(t blas.Transpose, alpha float32, a Band, x Vector, beta float32, y Vector)

Gbmv computes

y = alpha * A * x + beta * y   if t == blas.NoTrans,
y = alpha * Aᵀ * 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.

#### func Gemm¶

func Gemm(tA, tB blas.Transpose, alpha float32, a, b General, beta float32, c General)

Gemm computes

C = alpha * A * B + beta * C,


where A, B, and C are dense matrices, and alpha and beta are scalars. tA and tB specify whether A or B are transposed.

#### func Gemv¶

func Gemv(t blas.Transpose, alpha float32, a General, x Vector, beta float32, y Vector)

Gemv computes

y = alpha * A * x + beta * y   if t == blas.NoTrans,
y = alpha * Aᵀ * 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.

#### func Ger¶

func Ger(alpha float32, x, y Vector, a General)

Ger performs a rank-1 update

A += alpha * x * yᵀ,


where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.

#### func Iamax¶

func Iamax(x Vector) int

Iamax returns the index of an element of x with the largest absolute value. If there are multiple such indices the earliest is returned. Iamax returns -1 if n == 0.

Iamax will panic if the vector increment is negative.

#### func Implementation¶

func Implementation() blas.Float32

Implementation returns the current BLAS float32 implementation.

Implementation allows direct calls to the current the BLAS float32 implementation giving finer control of parameters.

#### func Nrm2¶

func Nrm2(x Vector) float32

Nrm2 computes the Euclidean norm of the vector x:

sqrt(\sum_i x[i]*x[i]).


Nrm2 will panic if the vector increment is negative.

#### func Rot¶

func Rot(n int, x, y Vector, c, s float32)

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.


#### func Rotg¶

func Rotg(a, b float32) (c, s, r, z float32)

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. c, s, and r are defined as

r = ±Sqrt(a^2 + b^2),
c = a/r, the cosine of the rotation angle,
s = a/r, the sine of the rotation angle,


and z is defined such that

if |a| > |b|,        z = s,
otherwise if c != 0, z = 1/c,
otherwise            z = 1.


#### func Rotm¶

func Rotm(n int, x, y Vector, p blas.SrotmParams)

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

#### func Rotmg¶

func Rotmg(d1, d2, b1, b2 float32) (p blas.SrotmParams, rd1, rd2, rb1 float32)

Rotmg computes the modified Givens rotation. See http://www.netlib.org/lapack/explore-html/df/deb/drotmg_8f.html for more details.

#### func SDDot¶

func SDDot(alpha float32, x, y Vector) float32

SDDot computes the dot product of the two vectors adding a constant:

alpha + \sum_i x[i]*y[i].


SDDot will panic if the lengths of x and y do not match.

#### func Sbmv¶

func Sbmv(alpha float32, a SymmetricBand, x Vector, beta float32, y Vector)

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.

#### func Scal¶

func Scal(alpha float32, x Vector)

Scal scales the vector x by alpha:

x[i] *= alpha for all i.


Scal will panic if the vector increment is negative.

#### func Spmv¶

func Spmv(alpha float32, a SymmetricPacked, x Vector, beta float32, y Vector)

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.

#### func Spr¶

func Spr(alpha float32, x Vector, a SymmetricPacked)

Spr performs the rank-1 update

A += alpha * x * xᵀ,


where A is an n×n symmetric matrix in packed format, x is a vector, and alpha is a scalar.

#### func Spr2¶

func Spr2(alpha float32, x, y Vector, a SymmetricPacked)

Spr2 performs a rank-2 update

A += alpha * x * yᵀ + alpha * y * xᵀ,


where A is an n×n symmetric matrix in packed format, x and y are vectors, and alpha is a scalar.

#### func Swap¶

func Swap(x, y Vector)

Swap exchanges the elements of the two vectors:

x[i], y[i] = y[i], x[i] for all i.


Swap will panic if the lengths of x and y do not match.

#### func Symm¶

func Symm(s blas.Side, alpha float32, a Symmetric, b General, beta float32, c General)

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.

#### func Symv¶

func Symv(alpha float32, a Symmetric, x Vector, beta float32, y Vector)

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.

#### func Syr¶

func Syr(alpha float32, x Vector, a Symmetric)

Syr performs a rank-1 update

A += alpha * x * xᵀ,


where A is an n×n symmetric matrix, x is a vector, and alpha is a scalar.

#### func Syr2¶

func Syr2(alpha float32, x, y Vector, a Symmetric)

Syr2 performs a rank-2 update

A += alpha * x * yᵀ + alpha * y * xᵀ,


where A is a symmetric n×n matrix, x and y are vectors, and alpha is a scalar.

#### func Syr2k¶

func Syr2k(t blas.Transpose, alpha float32, a, b General, beta float32, c Symmetric)

Syr2k performs a symmetric rank-2k update

C = alpha * A * Bᵀ + alpha * B * Aᵀ + beta * C  if t == blas.NoTrans,
C = alpha * Aᵀ * B + alpha * Bᵀ * 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.

#### func Syrk¶

func Syrk(t blas.Transpose, alpha float32, a General, beta float32, c Symmetric)

Syrk performs a symmetric rank-k update

C = alpha * A * Aᵀ + beta * C  if t == blas.NoTrans,
C = alpha * Aᵀ * 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.

#### func Tbmv¶

func Tbmv(t blas.Transpose, a TriangularBand, x Vector)

Tbmv computes

x = A * x   if t == blas.NoTrans,
x = Aᵀ * x  if t == blas.Trans or blas.ConjTrans,


where A is an n×n triangular band matrix, and x is a vector.

#### func Tbsv¶

func Tbsv(t blas.Transpose, a TriangularBand, x Vector)

Tbsv solves

A * x = b   if t == blas.NoTrans,
Aᵀ * x = b  if t == blas.Trans or blas.ConjTrans,


where A is an n×n triangular band matrix, and x and b are vectors.

At entry to the function, x contains the values of b, and the result is stored in place into x.

No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

#### func Tpmv¶

func Tpmv(t blas.Transpose, a TriangularPacked, x Vector)

Tpmv computes

x = A * x   if t == blas.NoTrans,
x = Aᵀ * x  if t == blas.Trans or blas.ConjTrans,


where A is an n×n triangular matrix in packed format, and x is a vector.

#### func Tpsv¶

func Tpsv(t blas.Transpose, a TriangularPacked, x Vector)

Tpsv solves

A * x = b   if t == blas.NoTrans,
Aᵀ * 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.

At entry to the function, x contains the values of b, and the result is stored in place into x.

No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

#### func Trmm¶

func Trmm(s blas.Side, tA blas.Transpose, alpha float32, a Triangular, b General)

Trmm performs

B = alpha * A * B   if tA == blas.NoTrans and s == blas.Left,
B = alpha * Aᵀ * 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ᵀ  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.

#### func Trmv¶

func Trmv(t blas.Transpose, a Triangular, x Vector)

Trmv computes

x = A * x   if t == blas.NoTrans,
x = Aᵀ * x  if t == blas.Trans or blas.ConjTrans,


where A is an n×n triangular matrix, and x is a vector.

#### func Trsm¶

func Trsm(s blas.Side, tA blas.Transpose, alpha float32, a Triangular, b General)

Trsm solves

A * X = alpha * B   if tA == blas.NoTrans and s == blas.Left,
Aᵀ * 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ᵀ = 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.

At entry to the function, X contains the values of B, and the result is stored in-place into X.

No check is made that A is invertible.

#### func Trsv¶

func Trsv(t blas.Transpose, a Triangular, x Vector)

Trsv solves

A * x = b   if t == blas.NoTrans,
Aᵀ * x = b  if t == blas.Trans or blas.ConjTrans,


where A is an n×n triangular matrix, and x and b are vectors.

At entry to the function, x contains the values of b, and the result is stored in-place into x.

No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

#### func Use¶

func Use(b blas.Float32)

Use sets the BLAS float32 implementation to be used by subsequent BLAS calls. The default implementation is gonum.org/v1/gonum/blas/gonum.Implementation.

### Types ¶

#### type Band¶

type Band struct {
Rows, Cols int
KL, KU     int
Stride     int
Data       []float32
}

Band represents a band matrix using the band storage scheme.

#### func (Band) From¶

func (t Band) From(a BandCols)

From fills the receiver with elements from a. The receiver must have the same dimensions and bandwidth as a and have adequate backing data storage.

#### type BandCols¶

type BandCols Band

BandCols represents a matrix using the band column-major storage scheme.

#### func (BandCols) From¶

func (t BandCols) From(a Band)

From fills the receiver with elements from a. The receiver must have the same dimensions and bandwidth as a and have adequate backing data storage.

#### type General¶

type General struct {
Rows, Cols int
Stride     int
Data       []float32
}

General represents a matrix using the conventional storage scheme.

#### func (General) From¶

func (t General) From(a GeneralCols)

From fills the receiver with elements from a. The receiver must have the same dimensions as a and have adequate backing data storage.

#### type GeneralCols¶

type GeneralCols General

GeneralCols represents a matrix using the conventional column-major storage scheme.

#### func (GeneralCols) From¶

func (t GeneralCols) From(a General)

From fills the receiver with elements from a. The receiver must have the same dimensions as a and have adequate backing data storage.

#### type Symmetric¶

type Symmetric struct {
N      int
Stride int
Data   []float32
Uplo   blas.Uplo
}

Symmetric represents a symmetric matrix using the conventional storage scheme.

#### func (Symmetric) From¶

func (t Symmetric) From(a SymmetricCols)

From fills the receiver with elements from a. The receiver must have the same dimensions and uplo as a and have adequate backing data storage.

#### type SymmetricBand¶

type SymmetricBand struct {
N, K   int
Stride int
Data   []float32
Uplo   blas.Uplo
}

SymmetricBand represents a symmetric matrix using the band storage scheme.

#### func (SymmetricBand) From¶

func (t SymmetricBand) From(a SymmetricBandCols)

From fills the receiver with elements from a. The receiver must have the same dimensions, bandwidth and uplo as a and have adequate backing data storage.

#### type SymmetricBandCols¶

type SymmetricBandCols SymmetricBand

SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.

#### func (SymmetricBandCols) From¶

func (t SymmetricBandCols) From(a SymmetricBand)

From fills the receiver with elements from a. The receiver must have the same dimensions, bandwidth and uplo as a and have adequate backing data storage.

#### type SymmetricCols¶

type SymmetricCols Symmetric

SymmetricCols represents a matrix using the conventional column-major storage scheme.

#### func (SymmetricCols) From¶

func (t SymmetricCols) From(a Symmetric)

From fills the receiver with elements from a. The receiver must have the same dimensions and uplo as a and have adequate backing data storage.

#### type SymmetricPacked¶

type SymmetricPacked struct {
N    int
Data []float32
Uplo blas.Uplo
}

SymmetricPacked represents a symmetric matrix using the packed storage scheme.

#### type Triangular¶

type Triangular struct {
N      int
Stride int
Data   []float32
Uplo   blas.Uplo
Diag   blas.Diag
}

Triangular represents a triangular matrix using the conventional storage scheme.

#### func (Triangular) From¶

func (t Triangular) From(a TriangularCols)

From fills the receiver with elements from a. The receiver must have the same dimensions, uplo and diag as a and have adequate backing data storage.

#### type TriangularBand¶

type TriangularBand struct {
N, K   int
Stride int
Data   []float32
Uplo   blas.Uplo
Diag   blas.Diag
}

TriangularBand represents a triangular matrix using the band storage scheme.

#### func (TriangularBand) From¶

func (t TriangularBand) From(a TriangularBandCols)

From fills the receiver with elements from a. The receiver must have the same dimensions, bandwidth and uplo as a and have adequate backing data storage.

#### type TriangularBandCols¶

type TriangularBandCols TriangularBand

TriangularBandCols represents a triangular matrix using the band column-major storage scheme.

#### func (TriangularBandCols) From¶

func (t TriangularBandCols) From(a TriangularBand)

From fills the receiver with elements from a. The receiver must have the same dimensions, bandwidth and uplo as a and have adequate backing data storage.

#### type TriangularCols¶

type TriangularCols Triangular

TriangularCols represents a matrix using the conventional column-major storage scheme.

#### func (TriangularCols) From¶

func (t TriangularCols) From(a Triangular)

From fills the receiver with elements from a. The receiver must have the same dimensions, uplo and diag as a and have adequate backing data storage.

#### type TriangularPacked¶

type TriangularPacked struct {
N    int
Data []float32
Uplo blas.Uplo
Diag blas.Diag
}

TriangularPacked represents a triangular matrix using the packed storage scheme.

#### type Vector¶

type Vector struct {
N    int
Inc  int
Data []float32
}

Vector represents a vector with an associated element increment.