import "gonum.org/v1/gonum/blas/blas64"
Package blas64 provides a simple interface to the float64 BLAS API.
blas64.go conv.go conv_symmetric.go doc.go
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.
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.
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.
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.
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.
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.
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.
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.
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.
Implementation returns the current BLAS float64 implementation.
Implementation allows direct calls to the current the BLAS float64 implementation giving finer control of parameters.
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.
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. 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(x, y Vector, p blas.DrotmParams)
Rotm applies the modified Givens rotation to n points represented by the vectors x and y.
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.
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.
Scal will panic if the vector increment is negative.
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(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(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.
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.
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ᵀ,
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ᵀ + alpha * y * xᵀ,
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ᵀ + 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.
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(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(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(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(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.
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(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.
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(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.
Use sets the BLAS float64 implementation to be used by subsequent BLAS calls. The default implementation is gonum.org/v1/gonum/blas/gonum.Implementation.
Band represents a band matrix using the band storage scheme.
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.
BandCols represents a matrix using the band column-major storage scheme.
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.
General represents a matrix using the conventional storage scheme.
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.
GeneralCols represents a matrix using the conventional column-major storage scheme.
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.
Symmetric represents a symmetric matrix using the conventional storage scheme.
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.
SymmetricBand represents a symmetric matrix using the band storage scheme.
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 SymmetricBand
SymmetricBandCols represents a symmetric matrix using the band column-major storage scheme.
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.
SymmetricCols represents a matrix using the conventional column-major storage scheme.
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.
SymmetricPacked represents a symmetric matrix using the packed storage scheme.
Triangular represents a triangular matrix using the conventional storage scheme.
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.
TriangularBand represents a triangular matrix using the band storage scheme.
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 TriangularBand
TriangularBandCols represents a triangular matrix using the band column-major storage scheme.
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 Triangular
TriangularCols represents a matrix using the conventional column-major storage scheme.
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.
TriangularPacked represents a triangular matrix using the packed storage scheme.
Vector represents a vector with an associated element increment.
Package blas64 imports 2 packages (graph) and is imported by 20 packages. Updated 2021-01-02. Refresh now. Tools for package owners.