Back to godoc.org

Package blas64

v0.7.0
Latest Go to latest
Published: Feb 26, 2020 | License: BSD-3-Clause | Module: gonum.org/v1/gonum

Overview

Package blas64 provides a simple interface to the float64 BLAS API.

Index

Package Files

func Asum

func Asum(x Vector) float64

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 float64, 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 Dot

func Dot(x, y Vector) float64

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 float64, a Band, x Vector, beta float64, 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 float64, a, b General, beta float64, 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 float64, a General, x Vector, beta float64, 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 float64, 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.Float64

Implementation returns the current BLAS float64 implementation.

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

func Nrm2

func Nrm2(x Vector) float64

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(x, y Vector, c, s float64)

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 float64) (c, s, r, z float64)

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(x, y Vector, p blas.DrotmParams)

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

func Rotmg

func Rotmg(d1, d2, b1, b2 float64) (p blas.DrotmParams, rd1, rd2, rb1 float64)

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

func Sbmv

func Sbmv(alpha float64, a SymmetricBand, x Vector, beta float64, 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 float64, 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 float64, a SymmetricPacked, x Vector, beta float64, 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 float64, 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 float64, 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 float64, a Symmetric, b General, beta float64, 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 float64, a Symmetric, x Vector, beta float64, 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 float64, 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 float64, 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 float64, a, b General, beta float64, 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 float64, a General, beta float64, 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 float64, 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 float64, 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.Float64)

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

type Band

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

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
	Data       []float64
	Stride     int
}

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 {
	Uplo   blas.Uplo
	N      int
	Data   []float64
	Stride int
}

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 {
	Uplo   blas.Uplo
	N, K   int
	Data   []float64
	Stride int
}

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 {
	Uplo blas.Uplo
	N    int
	Data []float64
}

SymmetricPacked represents a symmetric matrix using the packed storage scheme.

type Triangular

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

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 {
	Uplo   blas.Uplo
	Diag   blas.Diag
	N, K   int
	Data   []float64
	Stride int
}

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 {
	Uplo blas.Uplo
	Diag blas.Diag
	N    int
	Data []float64
}

TriangularPacked represents a triangular matrix using the packed storage scheme.

type Vector

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

Vector represents a vector with an associated element increment.

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier