`import "gonum.org/v1/gonum/blas/cblas64"`

Package cblas64 provides a simple interface to the complex64 BLAS API.

- func Asum(n int, x Vector) float32
- func Axpy(n int, alpha complex64, x, y Vector)
- func Copy(n int, x, y Vector)
- func Dotc(n int, x, y Vector) complex64
- func Dotu(n int, x, y Vector) complex64
- func Dscal(n int, alpha float32, x Vector)
- func Gbmv(t blas.Transpose, alpha complex64, a Band, x Vector, beta complex64, y Vector)
- func Gemm(tA, tB blas.Transpose, alpha complex64, a, b General, beta complex64, c General)
- func Gemv(t blas.Transpose, alpha complex64, a General, x Vector, beta complex64, y Vector)
- func Gerc(alpha complex64, x, y Vector, a General)
- func Geru(alpha complex64, x, y Vector, a General)
- func Hbmv(alpha complex64, a HermitianBand, x Vector, beta complex64, y Vector)
- func Hemm(s blas.Side, alpha complex64, a Hermitian, b General, beta complex64, c General)
- func Hemv(alpha complex64, a Hermitian, x Vector, beta complex64, y Vector)
- func Her(alpha float32, x Vector, a Hermitian)
- func Her2(alpha complex64, x, y Vector, a Hermitian)
- func Her2k(t blas.Transpose, alpha complex64, a, b General, beta float32, c Hermitian)
- func Herk(t blas.Transpose, alpha float32, a General, beta float32, c Hermitian)
- func Hpmv(alpha complex64, a HermitianPacked, x Vector, beta complex64, y Vector)
- func Hpr(alpha float32, x Vector, a HermitianPacked)
- func Hpr2(alpha complex64, x, y Vector, a HermitianPacked)
- func Iamax(n int, x Vector) int
- func Implementation() blas.Complex64
- func Nrm2(n int, x Vector) float32
- func Scal(n int, alpha complex64, x Vector)
- func Swap(n int, x, y Vector)
- func Symm(s blas.Side, alpha complex64, a Symmetric, b General, beta complex64, c General)
- func Syr2k(t blas.Transpose, alpha complex64, a, b General, beta complex64, c Symmetric)
- func Syrk(t blas.Transpose, alpha complex64, a General, beta complex64, 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 complex64, a Triangular, b General)
- func Trmv(t blas.Transpose, a Triangular, x Vector)
- func Trsm(s blas.Side, tA blas.Transpose, alpha complex64, a Triangular, b General)
- func Trsv(t blas.Transpose, a Triangular, x Vector)
- func Use(b blas.Complex64)
- type Band
- type BandCols
- type General
- type GeneralCols
- type Hermitian
- type HermitianBand
- type HermitianBandCols
- type HermitianCols
- type HermitianPacked
- type Symmetric
- type SymmetricBand
- type SymmetricPacked
- type Triangular
- type TriangularBand
- type TriangularBandCols
- type TriangularCols
- type TriangularPacked
- type Vector

cblas64.go conv.go conv_hermitian.go doc.go

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.

Axpy computes

y = alpha * x + y,

where x and y are vectors, and alpha is a scalar.

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

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

Dotc computes the dot product of the two vectors with complex conjugation:

x^H * y.

Dotu computes the dot product of the two vectors without complex conjugation:

x^T * y

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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(alpha float32, 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(alpha complex64, 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.

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.

Implementation returns the current BLAS complex64 implementation.

Implementation allows direct calls to the current the BLAS complex64 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.

Scal computes

x = alpha * x,

where x is a vector, and alpha is a scalar.

Scal will panic if the vector increment is negative.

Swap exchanges the elements of two vectors:

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

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.

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.

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(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(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(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(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.

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(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.

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(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.

Use sets the BLAS complex64 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.

Hermitian represents an Hermitian matrix using the conventional storage scheme.

❖

func (t Hermitian) From(a HermitianCols)

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 HermitianBand SymmetricBand

HermitianBand represents an Hermitian matrix using the band storage scheme.

❖

func (t HermitianBand) From(a HermitianBandCols)

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 HermitianBandCols HermitianBand

HermitianBandCols represents an Hermitian matrix using the band column-major storage scheme.

❖

func (t HermitianBandCols) From(a HermitianBand)

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.

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

❖

func (t HermitianCols) From(a Hermitian)

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 HermitianPacked SymmetricPacked

HermitianPacked represents an Hermitian matrix using the packed storage scheme.

Symmetric represents a symmetric matrix using the conventional storage scheme.

SymmetricBand represents a symmetric matrix using the band storage scheme.

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 symmetric matrix using the band column-major storage scheme.

❖

func (t TriangularBandCols) From(a TriangularBand)

❖

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 cblas64 imports 2 packages (graph). Updated 2019-01-30. Refresh now. Tools for package owners.