cblas128

package
v0.0.0-...-dfba71b Latest Latest
Warning

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

Go to latest
Published: Dec 9, 2020 License: BSD-2-Clause Imports: 2 Imported by: 0

Documentation

Overview

Package cblas128 provides a simple interface to the complex128 BLAS API.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Asum

func Asum(n int, x Vector) float64

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

func Dscal(n int, alpha float64, x Vector)

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

func Her(alpha float64, x Vector, a Hermitian)

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

func Her2k(t blas.Transpose, alpha complex128, a, b General, beta float64, c Hermitian)

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

func Herk(t blas.Transpose, alpha float64, a General, beta float64, c Hermitian)

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

func Iamax(n int, x Vector) int

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

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

type Triangular struct {
	N      int
	Stride int
	Data   []complex128
	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   []complex128
	Uplo   blas.Uplo
	Diag   blas.Diag
}

TriangularBand represents a triangular matrix using the band storage scheme.

type TriangularPacked

type TriangularPacked struct {
	N    int
	Data []complex128
	Uplo blas.Uplo
	Diag blas.Diag
}

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL