blas32

package
v1.1.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 6, 2016 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Overview

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

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Asum 

func Asum(n int, 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(n int, alpha float32, x, y Vector)

Axpy adds alpha times x to y 

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

func Copy 

func Copy(n int, x, y Vector)

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

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

func DDot 

func DDot(n int, x, y Vector) float64

DDot computes the dot product of the two vectors 

\sum_i x[i]*y[i]

func Dot 

func Dot(n int, x, y Vector) float32

Dot computes the dot product of the two vectors 

\sum_i x[i]*y[i]

func Gbmv 

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

Gbmv computes 

y = alpha * A * x + beta * y if tA == blas.NoTrans
y = alpha * A^T * x + beta * y if tA == blas.Trans or blas.ConjTrans

where a is an m×n band matrix kL subdiagonals and kU super-diagonals, and m and n refer to the size of the full dense matrix it represents. 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 = beta * C + alpha * A * B.

tA and tB specify whether A or B are transposed. A, B, and C are m×n dense matrices.

func Gemv 

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

Gemv computes 

y = alpha * a * x + beta * y if tA = blas.NoTrans
y = alpha * A^T * x + beta * y if tA = blas.Trans or blas.ConjTrans

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

func Ger 

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

Ger performs the rank-one operation 

A += alpha * x * y^T

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

func Iamax 

func Iamax(n int, x Vector) int

Iamax returns the index of the largest element of x. 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(n int, x Vector) float32

Nrm2 computes the Euclidean norm of a vector, 

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. 

x[i] = c * x[i] + s * y[i]
y[i] = c * y[i] - s * x[i]

func Rotg 

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

Rotg computes the plane rotation 

 _    _      _ _       _ _
| c  s |    | a |     | r |
| -s c |  * | b |   = | 0 |
 ‾    ‾      ‾ ‾       ‾ ‾

where 

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

func Rotm 

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

Rotm applies the modified Givens rotation to the 2×n matrix.

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(n int, 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]

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 banded matrix, x and y are vectors, and alpha and beta are scalars.

func Scal 

func Scal(n int, alpha float32, x Vector)

Scal scales x by alpha. 

x[i] *= alpha

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 computes the rank-one operation 

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.

func Spr2 

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

Spr2 performs the symmetric rank-2 update 

a += alpha * x * y^T + alpha * y * x^T

where a is an n×n symmetric matirx in packed format and x and y are vectors.

func Swap 

func Swap(n int, x, y Vector)

Swap exchanges the elements of two vectors. 

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

func Symm 

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

Symm performs one of 

C = alpha * A * B + beta * C if side == blas.Left
C = alpha * B * A + beta * C if side == blas.Right

where A is an n×n 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 the rank-one update 

a += alpha * x * x^T

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

func Syr2 

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

Syr2 performs the symmetric rank-two 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.

func Syr2k 

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

Syr2k performs the symmetric rank 2k operation 

C = alpha * A * B^T + alpha * B * A^T + beta * C

where C is an n×n symmetric matrix. A and B are n×k matrices if tA == NoTrans and k×n otherwise. alpha and beta are scalars.

func Syrk 

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

Syrk performs the symmetric rank-k operation 

C = alpha * A * A^T + beta*C

C is an n×n symmetric matrix. A is an n×k matrix if tA == blas.NoTrans, and a k×n matrix otherwise. alpha and beta are scalars.

func Tbmv 

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

Tbmv computes 

x = A * x if tA == blas.NoTrans
x = A^T * x if tA == blas.Trans or blas.ConjTrans

where A is an n×n triangular banded matrix with k diagonals, and x is a vector.

func Tbsv 

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

Tbsv solves 

A * x = b

where A is an n×n triangular banded matrix with k diagonals in packed format, and x is a vector. 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(tA blas.Transpose, a TriangularPacked, x Vector)

Tpmv computes 

x = A * x if tA == blas.NoTrans
x = A^T * x if tA == blas.Trans or blas.ConjTrans

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

func Tpsv 

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

Tpsv solves 

A * x = b if tA == blas.NoTrans
A^T * x = b if tA == blas.Trans or blas.ConjTrans

where A is an n×n triangular matrix in packed format and x is a vector. 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 side == blas.Left
B = alpha * A^T * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Left
B = alpha * B * A if tA == blas.NoTrans and side == blas.Right
B = alpha * B * A^T if tA == blas.Trans or blas.ConjTrans, and side == blas.Right

where A is an n×n triangular matrix, and B is an m×n matrix.

func Trmv 

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

Trmv computes 

x = A * x if tA == blas.NoTrans
x = A^T * x if tA == blas.Trans or blas.ConjTrans

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 side == blas.Left
A^T * X = alpha * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Left
X * A = alpha * B if tA == blas.NoTrans side == blas.Right
X * A^T = alpha * B if tA == blas.Trans or blas.ConjTrans, and side == blas.Right

where A is an n×n triangular matrix, x is an m×n matrix, 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(tA blas.Transpose, a Triangular, x Vector)

Trsv solves 

A * x = b if tA == blas.NoTrans
A^T * x = b if tA == blas.Trans or blas.ConjTrans

A is an n×n triangular matrix and x is a vector. 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 native.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.

type General 

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

General represents a matrix using the conventional storage scheme.

type Symmetric 

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

Symmetric represents a symmetric matrix using the conventional storage scheme.

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.

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.

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.

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 {
	Inc  int
	Data []float32
}

Vector represents a vector with an associated element increment.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.