Documentation ¶
Overview ¶
Package cblas128 provides a simple interface to the complex128 BLAS API.
Index ¶
- func Asum(n int, x Vector) float64
- func Axpy(n int, alpha complex128, x, y Vector)
- func Copy(n int, x, y Vector)
- func Dotc(n int, x, y Vector) complex128
- func Dotu(n int, x, y Vector) complex128
- func Dscal(n int, alpha float64, x Vector)
- func Gbmv(t blas.Transpose, alpha complex128, a Band, x Vector, beta complex128, ...)
- func Gemm(tA, tB blas.Transpose, alpha complex128, a, b General, beta complex128, ...)
- func Gemv(t blas.Transpose, alpha complex128, a General, x Vector, beta complex128, ...)
- func Gerc(alpha complex128, x, y Vector, a General)
- func Geru(alpha complex128, x, y Vector, a General)
- func Hbmv(alpha complex128, a HermitianBand, x Vector, beta complex128, y Vector)
- func Hemm(s blas.Side, alpha complex128, a Hermitian, b General, beta complex128, ...)
- func Hemv(alpha complex128, a Hermitian, x Vector, beta complex128, y Vector)
- func Her(alpha float64, x Vector, a Hermitian)
- func Her2(alpha complex128, x, y Vector, a Hermitian)
- func Her2k(t blas.Transpose, alpha complex128, a, b General, beta float64, c Hermitian)
- func Herk(t blas.Transpose, alpha float64, a General, beta float64, c Hermitian)
- func Hpmv(alpha complex128, a HermitianPacked, x Vector, beta complex128, y Vector)
- func Hpr(alpha float64, x Vector, a HermitianPacked)
- func Hpr2(alpha complex128, x, y Vector, a HermitianPacked)
- func Iamax(n int, x Vector) int
- func Implementation() blas.Complex128
- func Nrm2(n int, x Vector) float64
- func Scal(n int, alpha complex128, x Vector)
- func Swap(n int, x, y Vector)
- func Symm(s blas.Side, alpha complex128, a Symmetric, b General, beta complex128, ...)
- func Syr2k(t blas.Transpose, alpha complex128, a, b General, beta complex128, c Symmetric)
- func Syrk(t blas.Transpose, alpha complex128, a General, beta complex128, c Symmetric)
- func Tbmv(t blas.Transpose, a TriangularBand, x Vector)
- func Tbsv(t blas.Transpose, a TriangularBand, x Vector)
- func Tpmv(t blas.Transpose, a TriangularPacked, x Vector)
- func Tpsv(t blas.Transpose, a TriangularPacked, x Vector)
- func Trmm(s blas.Side, tA blas.Transpose, alpha complex128, a Triangular, b General)
- func Trmv(t blas.Transpose, a Triangular, x Vector)
- func Trsm(s blas.Side, tA blas.Transpose, alpha complex128, a Triangular, b General)
- func Trsv(t blas.Transpose, a Triangular, x Vector)
- func Use(b blas.Complex128)
- type Band
- type General
- type Hermitian
- type HermitianBand
- type HermitianPacked
- type Symmetric
- type SymmetricBand
- type SymmetricPacked
- type Triangular
- type TriangularBand
- type TriangularPacked
- type Vector
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Asum ¶
Asum computes the sum of magnitudes of the real and imaginary parts of elements of the vector x:
\sum_i (|Re x[i]| + |Im x[i]|).
Asum will panic if the vector increment is negative.
func Axpy ¶
func Axpy(n int, alpha complex128, x, y Vector)
Axpy computes
y = alpha * x + y,
where x and y are vectors, and alpha is a scalar.
func Dotc ¶
func Dotc(n int, x, y Vector) complex128
Dotc computes the dot product of the two vectors with complex conjugation:
x^H * y.
func Dotu ¶
func Dotu(n int, x, y Vector) complex128
Dotu computes the dot product of the two vectors without complex conjugation:
x^T * y.
func Dscal ¶
Dscal computes
x = alpha * x,
where x is a vector, and alpha is a real scalar.
Dscal will panic if the vector increment is negative.
func Gbmv ¶
func Gbmv(t blas.Transpose, alpha complex128, a Band, x Vector, beta complex128, y Vector)
Gbmv computes
y = alpha * A * x + beta * y, if t == blas.NoTrans, y = alpha * A^T * x + beta * y, if t == blas.Trans, y = alpha * A^H * x + beta * y, if t == 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 complex128, a, b General, beta complex128, 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 or conjugated.
func Gemv ¶
func Gemv(t blas.Transpose, alpha complex128, a General, x Vector, beta complex128, y Vector)
Gemv computes
y = alpha * A * x + beta * y, if t == blas.NoTrans, y = alpha * A^T * x + beta * y, if t == blas.Trans, y = alpha * A^H * x + beta * y, if t == blas.ConjTrans,
where A is an m×n dense matrix, x and y are vectors, and alpha and beta are scalars.
func Gerc ¶
func Gerc(alpha complex128, x, y Vector, a General)
Gerc performs a rank-1 update
A += alpha * x * y^H,
where A is an m×n dense matrix, x and y are vectors, and alpha is a scalar.
func Geru ¶
func Geru(alpha complex128, x, y Vector, a General)
Geru 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.
func Hbmv ¶
func Hbmv(alpha complex128, a HermitianBand, x Vector, beta complex128, y Vector)
Hbmv performs
y = alpha * A * x + beta * y,
where A is an n×n Hermitian band matrix, x and y are vectors, and alpha and beta are scalars.
func Hemm ¶
func Hemm(s blas.Side, alpha complex128, a Hermitian, b General, beta complex128, c General)
Hemm 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 Hermitian matrix, B and C are m×n matrices, and alpha and beta are scalars.
func Hemv ¶
func Hemv(alpha complex128, a Hermitian, x Vector, beta complex128, y Vector)
Hemv computes
y = alpha * A * x + beta * y,
where A is an n×n Hermitian matrix, x and y are vectors, and alpha and beta are scalars.
func Her ¶
Her performs a rank-1 update
A += alpha * x * y^T,
where A is an m×n Hermitian matrix, x and y are vectors, and alpha is a scalar.
func Her2 ¶
func Her2(alpha complex128, x, y Vector, a Hermitian)
Her2 performs a rank-2 update
A += alpha * x * y^H + conj(alpha) * y * x^H,
where A is an n×n Hermitian matrix, x and y are vectors, and alpha is a scalar.
func Her2k ¶
Her2k performs the Hermitian rank-2k update
C = alpha * A * B^H + conj(alpha) * B * A^H + beta * C, if t == blas.NoTrans, C = alpha * A^H * B + conj(alpha) * B^H * A + beta * C, if t == blas.ConjTrans,
where C is an n×n Hermitian matrix, A and B are n×k matrices if t == NoTrans and k×n matrices otherwise, and alpha and beta are scalars.
func Herk ¶
Herk performs the Hermitian rank-k update
C = alpha * A * A^H + beta*C, if t == blas.NoTrans, C = alpha * A^H * A + beta*C, if t == blas.ConjTrans,
where C is an n×n Hermitian matrix, A is an n×k matrix if t == blas.NoTrans and a k×n matrix otherwise, and alpha and beta are scalars.
func Hpmv ¶
func Hpmv(alpha complex128, a HermitianPacked, x Vector, beta complex128, y Vector)
Hpmv performs
y = alpha * A * x + beta * y,
where A is an n×n Hermitian matrix in packed format, x and y are vectors, and alpha and beta are scalars.
func Hpr ¶
func Hpr(alpha float64, x Vector, a HermitianPacked)
Hpr performs a rank-1 update
A += alpha * x * x^H,
where A is an n×n Hermitian matrix in packed format, x is a vector, and alpha is a scalar.
func Hpr2 ¶
func Hpr2(alpha complex128, x, y Vector, a HermitianPacked)
Hpr2 performs a rank-2 update
A += alpha * x * y^H + conj(alpha) * y * x^H,
where A is an n×n Hermitian matrix in packed format, x and y are vectors, and alpha is a scalar.
func Iamax ¶
Iamax returns the index of an element of x with the largest sum of magnitudes of the real and imaginary parts (|Re x[i]|+|Im x[i]|). 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.Complex128
Implementation returns the current BLAS complex128 implementation.
Implementation allows direct calls to the current the BLAS complex128 implementation giving finer control of parameters.
func Nrm2 ¶
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 Scal ¶
func Scal(n int, alpha complex128, x Vector)
Scal computes
x = alpha * x,
where x is a vector, and alpha is a scalar.
Scal will panic if the vector increment is negative.
func Symm ¶
func Symm(s blas.Side, alpha complex128, a Symmetric, b General, beta complex128, 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 and beta are scalars.
func Syr2k ¶
func Syr2k(t blas.Transpose, alpha complex128, a, b General, beta complex128, c Symmetric)
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,
where C is an n×n symmetric matrix, A and B are n×k matrices if t == blas.NoTrans and k×n otherwise, and alpha and beta are scalars.
func Syrk ¶
func Syrk(t blas.Transpose, alpha complex128, a General, beta complex128, c Symmetric)
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,
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^T * x, if t == blas.Trans, x = A^H * x, if t == 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^T * x = b, if t == blas.Trans, A^H * x = b, if t == blas.ConjTrans,
where A is an n×n triangular band 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 Tpmv ¶
func Tpmv(t blas.Transpose, a TriangularPacked, x Vector)
Tpmv computes
x = A * x, if t == blas.NoTrans, x = A^T * x, if t == blas.Trans, x = A^H * x, if t == 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^T * x = b, if t == blas.Trans, A^H * x = b, if t == 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 complex128, a Triangular, b General)
Trmm performs
B = alpha * A * B, if tA == blas.NoTrans and s == blas.Left, B = alpha * A^T * B, if tA == blas.Trans and s == blas.Left, B = alpha * A^H * B, if tA == 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 and s == blas.Right, B = alpha * B * A^H, if tA == 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^T * x, if t == blas.Trans, x = A^H * x, if t == 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 complex128, a Triangular, b General)
Trsm solves
A * X = alpha * B, if tA == blas.NoTrans and s == blas.Left, A^T * X = alpha * B, if tA == blas.Trans and s == blas.Left, A^H * X = alpha * B, if tA == 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 and s == blas.Right, X * A^H = alpha * B, if tA == 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, b contains the values of B, and the result is stored in-place into b.
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^T * x = b, if t == blas.Trans, A^H * x = b, if t == blas.ConjTrans,
where 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.Complex128)
Use sets the BLAS complex128 implementation to be used by subsequent BLAS calls. The default implementation is cgo.Implementation.
Types ¶
type Band ¶
type Band struct {
Rows, Cols int
KL, KU int
Stride int
Data []complex128
}
Band represents a band matrix using the band storage scheme.
type General ¶
type General struct {
Rows, Cols int
Stride int
Data []complex128
}
General represents a matrix using the conventional storage scheme.
type Hermitian ¶
type Hermitian Symmetric
Hermitian represents an Hermitian matrix using the conventional storage scheme.
type HermitianBand ¶
type HermitianBand SymmetricBand
HermitianBand represents an Hermitian matrix using the band storage scheme.
type HermitianPacked ¶
type HermitianPacked SymmetricPacked
HermitianPacked represents an Hermitian matrix using the packed storage scheme.
type Symmetric ¶
type Symmetric struct { N int Stride int Data []complex128 Uplo blas.Uplo }
Symmetric represents a symmetric matrix using the conventional storage scheme.
type SymmetricBand ¶
type SymmetricBand struct {
N, K int
Stride int
Data []complex128
Uplo blas.Uplo
}
SymmetricBand represents a symmetric matrix using the band storage scheme.
type SymmetricPacked ¶
type SymmetricPacked struct { N int Data []complex128 Uplo blas.Uplo }
SymmetricPacked represents a symmetric matrix using the packed storage scheme.
type Triangular ¶
Triangular represents a triangular matrix using the conventional storage scheme.
type TriangularBand ¶
TriangularBand represents a triangular matrix using the band storage scheme.
type TriangularPacked ¶
TriangularPacked represents a triangular matrix using the packed storage scheme.
type Vector ¶
type Vector struct { Inc int Data []complex128 }
Vector represents a vector with an associated element increment.