blas

func CAXPY ¶

func CAXPY(alpha complex64, X []complex64, incX int, Y []complex64, incY int)

Replaces Y by (alpha*X) + Y. Every incX'th and incY'th element is used.

alpha := complex64(complex(0, 1))
X := []complex64{1, 2, 3}
incX := 1
Y := []complex64{4, 5, 6}
incY := 1
CAXPY(alpha, X, incX, Y, incY)
fmt.Println(Y)

Output:

[(4+1i) (5+2i) (6+3i)]

func CCOPY ¶

func CCOPY(X []complex64, incX int, Y []complex64, incY int)

Copies X to Y. Every incX'th and incY'th element is used.

X := []complex64{1, 666, 2, 666}
incX := 2
Y := []complex64{-1, -2}
incY := 1
CCOPY(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[(1+0i) (666+0i) (2+0i) (666+0i)] [(1+0i) (2+0i)]

func CDOTC ¶

func CDOTC(X []complex64, incX int, Y []complex64, incY int) complex64

Calculates the dot product of the complex conjugate of X with Y. Every incX'th and incY'th element is used.

X := []complex64{complex(1, 0), complex(1, 1)}
incX := 1
Y := []complex64{complex(0, 0), complex(2, 0)}
incY := 1
result := CDOTC(X, incX, Y, incY)
fmt.Println(result)

Output:

(2-2i)

func CDOTU ¶

func CDOTU(X []complex64, incX int, Y []complex64, incY int) complex64

Computes the dot product of vectors X and Y. Every incX'th and incY'th element is used.

X := []complex64{complex(1, 0), complex(1, 1)}
incX := 1
Y := []complex64{complex(0, 0), complex(2, 0)}
incY := 1
result := CDOTU(X, incX, Y, incY)
fmt.Println(result)

Output:

(2+2i)

func CGEMM ¶

func CGEMM(transA Transpose, transB Transpose, alpha complex64, A [][]complex64, B [][]complex64, beta complex64, C [][]complex64)

General matrix-matrix multiplication:

C = alpha*A*B + beta*C

where A and B can optionally be transposed by specifying transA, transB = Trans/NoTrans

alpha := complex64(1.0)
A := matrix.MakeComplex64(2, 4)
A[0][0] = 1
A[0][1] = complex(0, -1)
A[1][1] = 2

B := matrix.MakeComplex64(4, 3)
B[1][0] = 2
B[2][1] = 3

beta := complex64(0.0)
C := matrix.MakeComplex64(2, 3)
CGEMM(NoTrans, NoTrans, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[(1+0i) (0-1i) (0+0i) (0+0i)] [(0+0i) (2+0i) (0+0i) (0+0i)]] * [[(0+0i) (0+0i) (0+0i)] [(2+0i) (0+0i) (0+0i)] [(0+0i) (3+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]] = [[(0-2i) (0+0i) (0+0i)] [(4+0i) (0+0i) (0+0i)]]

func CGEMV ¶

func CGEMV(transA Transpose, alpha complex64, A [][]complex64, X []complex64, incX int, beta complex64, Y []complex64, incY int)

Matrix-vector multiplication plus vector with optional matrix transpose. When transA == NoTrans this computes:

Y = alpha*A*X + beta*Y

When transA == Trans this computes:

Y = alpha*(A^T)*X + beta*Y

Every incX'th element of X and incY'th element of Y is used. Matrices must be allocated with MakeComplex64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeComplex64(2, 3)
A[0][1] = 1
A[0][2] = 2
A[1][0] = 3

X := []complex64{-1, 4, 0}
incX := 1
Y := []complex64{0, 0}
incY := 1

alpha := complex64(complex(1, 0))
beta := complex64(complex(0, 0))

CGEMV(NoTrans, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A, "*", X, "=", Y)

CGEMV(Trans, alpha, A, Y, incX, beta, X, incY)
fmt.Println(A, "^T*", Y, "=", X)

Output:

[[(0+0i) (1+0i) (2+0i)] [(3+0i) (0+0i) (0+0i)]] * [(-1+0i) (4+0i) (0+0i)] = [(4+0i) (-3+0i)]
[[(0+0i) (1+0i) (2+0i)] [(3+0i) (0+0i) (0+0i)]] ^T* [(4+0i) (-3+0i)] = [(-9+0i) (4+0i) (8+0i)]

func CGERC ¶

func CGERC(alpha complex64, X []complex64, incX int, Y []complex64, incY int, A [][]complex64)

Computes the conjugate rank-1 update:

A = alpha*X*conj(Y^T) + A

Matrices must be allocated with MakeComplex64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. Every incX'th element of X and incY'th element of Y is used.

alpha := complex64(1)
X := []complex64{1, 2}
incX := 1
Y := []complex64{complex(0, 3), complex(0, 4), complex(0, 5)}
incY := 1
A := matrix.MakeComplex64(2, 3)
CGERC(alpha, X, incX, Y, incY, A)
fmt.Println(X, "* conj", Y, "^T = ", A)

Output:

[(1+0i) (2+0i)] * conj [(0+3i) (0+4i) (0+5i)] ^T =  [[(0-3i) (0-4i) (0-5i)] [(0-6i) (0-8i) (0-10i)]]

func CGERU ¶

func CGERU(alpha complex64, X []complex64, incX int, Y []complex64, incY int, A [][]complex64)

Computes the rank-1 update:

A = alpha*X*(Y^T) + A

Matrices must be allocated with MakeComplex64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. Every incX'th element of X and incY'th element of Y is used.

alpha := complex64(1)
X := []complex64{1, 2}
incX := 1
Y := []complex64{3, 4, 5}
incY := 1
A := matrix.MakeComplex64(2, 3)
CGERU(alpha, X, incX, Y, incY, A)
fmt.Println(X, "*", Y, "^T = ", A)

Output:

[(1+0i) (2+0i)] * [(3+0i) (4+0i) (5+0i)] ^T =  [[(3+0i) (4+0i) (5+0i)] [(6+0i) (8+0i) (10+0i)]]

func CHEMM ¶

func CHEMM(side Side, uplo Uplo, alpha complex64, A [][]complex64, B [][]complex64, beta complex64, C [][]complex64)

Computes the matrix-matrix product and sum

C = alpha A B + beta C (for Side==Left)
C = alpha B A + beta C (for Side==Right)

where the matrix A is hermitian. When Uplo is Upper then the upper triangle and diagonal of A are used, and when Uplo is Lower then the lower triangle and diagonal of A are used. The imaginary elements of the diagonal are automatically set to zero.

alpha := complex64(1.0)
A := matrix.MakeComplex64(2, 2)
A[0][0] = 1
A[0][1] = complex(0, -1)
A[1][1] = 2

B := matrix.MakeComplex64(2, 2)
B[1][0] = 2
B[0][1] = 3

beta := complex64(0.0)
C := matrix.MakeComplex64(2, 2)
CHEMM(Left, Upper, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[(0-2i) (3+0i)] [(4+0i) (0+3i)]]

func CHEMV ¶

func CHEMV(uplo Uplo, alpha complex64, A [][]complex64, X []complex64, incX int, beta complex64, Y []complex64, incY int)

Hermitian matrix-vector product:

Y = alpha*X + beta*Y

Matrices must be allocated with MakeComplex64Matrix to ensure contiguous underlying storage, With uplo == Upper or Lower, the upper or lower triangular part of A is used. Every incX'th and incY'th element is used.

A := matrix.MakeComplex64(3, 3)
A[0][1] = 1
A[0][2] = 2
A[1][0] = 3

X := []complex64{-1, 4, 0}
incX := 1
Y := []complex64{0, 0, 0}
incY := 1

alpha := complex64(complex(1, 0))
beta := complex64(complex(0, 0))

CHEMV(Upper, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A)

Output:

[[(0+0i) (1+0i) (2+0i)] [(3+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]]

func CHER ¶

func CHER(uplo Uplo, alpha float32, X []complex64, incX int, A [][]complex64)

Computes the hermitian rank-1 update:

A = alpha*X*conj(X^T) + A

A is a hermitian matrix. Only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := float32(1.0)
X := []complex64{complex(0, 1), 2}
incX := 1
A := matrix.MakeComplex64(2, 2)
CHER(Upper, alpha, X, incX, A)
fmt.Println(A)

Output:

[[(1+0i) (0+2i)] [(0+0i) (4+0i)]]

func CHER2 ¶

func CHER2(uplo Uplo, alpha complex64, X []complex64, incX int, Y []complex64, incY int, A [][]complex64)

Computes the hermitian rank-2 update: A = alpha X conj(Y^T) + conj(alpha) Y conj(X^T) + A A is a hermitian matrix. Only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := complex64(1.0)
X := []complex64{complex(0, 1), 2}
incX := 1
Y := []complex64{2, complex(3, 1)}
incY := 1
A := matrix.MakeComplex64(2, 2)
CHER2(Upper, alpha, X, incX, Y, incY, A)
fmt.Println(A)

Output:

[[(2+0i) (0+4i)] [(0+0i) (8+0i)]]

func CHER2K ¶

func CHER2K(uplo Uplo, trans Transpose, alpha complex64, A [][]complex64, B [][]complex64, beta float32, C [][]complex64)

Computes a rank-2k update of the hermitian matrix C,

C = alpha A B^H + alpha^* B A^H + beta C (for trans==NoTrans)
C = alpha A^H B + alpha^* B^H A + beta C (for Trans==ConjTrans)

Since the matrix C is hermitian only its upper half or lower half need to be stored. When Uplo is Upper then the upper triangle and diagonal of C are used, and when Uplo is Lower then the lower triangle and diagonal of C are used. The imaginary elements of the diagonal are automatically set to zero.

alpha := complex64(complex(2.0, 3.0))
A := matrix.MakeComplex64(2, 2)
A[1][1] = complex(0, 1)
B := matrix.MakeComplex64(2, 2)
B[0][1] = complex(1, 0)
beta := float32(2.0)
C := matrix.MakeComplex64(2, 2)
CHER2K(Upper, NoTrans, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[(0+0i) (-3-2i)] [(0+0i) (0+0i)]]

func CHERK ¶

func CHERK(uplo Uplo, trans Transpose, alpha float32, A [][]complex64, beta float32, C [][]complex64)

Computes a rank-k update of the hermitian matrix C

C = alpha A A^H + beta C (for trans==NoTrans)
C = alpha A^H A + beta C (for trans==ConjTrans)

Since the matrix C is hermitian only its upper half or lower half need to be stored. When Uplo is Upper then the upper triangle and diagonal of C are used, and when Uplo is Lower then the lower triangle and diagonal of C are used. The imaginary elements of the diagonal are automatically set to zero.

alpha := float32(1.0)
A := matrix.MakeComplex64(2, 2)
A[1][1] = complex(0, 1)
beta := float32(0.0)
C := matrix.MakeComplex64(2, 2)
CHERK(Upper, ConjTrans, alpha, A, beta, C)
fmt.Println(C)

Output:

[[(0+0i) (0+0i)] [(0+0i) (1+0i)]]

func CSCAL ¶

func CSCAL(alpha complex64, X []complex64, incX int)

Multiply X by alpha. Every incX'th element is used.

alpha := complex64(complex(0, 1))
X := []complex64{1, 666, 2, 666}
incX := 2
CSCAL(alpha, X, incX)
fmt.Println(X)

Output:

[(0+1i) (666+0i) (0+2i) (666+0i)]

func CSSCAL ¶

func CSSCAL(alpha float32, X []complex64, incX int)

Multiply X by alpha. Every incX'th element is used.

alpha := float32(2)
X := []complex64{1, 666, 2, 666}
incX := 2
CSSCAL(alpha, X, incX)
fmt.Println(X)

Output:

[(2+0i) (666+0i) (4+0i) (666+0i)]

func CSWAP ¶

func CSWAP(X []complex64, incX int, Y []complex64, incY int)

Exchanges the elements of vectors X and Y. Every incX'th and incY'th element is used.

X := []complex64{1, 666, 2, 666}
incX := 2
Y := []complex64{-1, -2}
incY := 1
CSWAP(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[(-1+0i) (666+0i) (-2+0i) (666+0i)] [(1+0i) (2+0i)]

func CSYMM ¶

func CSYMM(side Side, uplo Uplo, alpha complex64, A [][]complex64, B [][]complex64, beta complex64, C [][]complex64)

Computes the matrix-matrix product

C = alpha*A*B + beta*C  (for Side==Left)
C = alpha*B*A + beta*C  (for Side==Right)

where the matrix A is symmetric. Only its upper half or lower half is used, specified by uplo=Upper/Lower.

alpha := complex64(1)
A := matrix.MakeComplex64(3, 3)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 2

B := matrix.MakeComplex64(3, 2)
B[1][0] = 2
B[2][1] = 3

beta := complex64(0)
C := matrix.MakeComplex64(3, 2)
CSYMM(Left, Upper, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[(1+0i) (-1+0i) (0+0i)] [(0+0i) (2+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]] * [[(0+0i) (0+0i)] [(2+0i) (0+0i)] [(0+0i) (3+0i)]] = [[(-2+0i) (0+0i)] [(4+0i) (0+0i)] [(0+0i) (0+0i)]]

func CSYR2K ¶

func CSYR2K(uplo Uplo, trans Transpose, alpha complex64, A [][]complex64, B [][]complex64, beta complex64, C [][]complex64)

Computes a rank-2k update of the symmetric matrix C:

C = alpha A*(B^T) + alpha B*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*B + alpha (B^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := complex64(1.0)
A := matrix.MakeComplex64(2, 3)
A[0][0] = 1

B := matrix.MakeComplex64(2, 3)
B[0][0] = 1

beta := complex64(0.0)
C := matrix.MakeComplex64(3, 3)

CSYR2K(Upper, Trans, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[(2+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]]

func CSYRK ¶

func CSYRK(uplo Uplo, trans Transpose, alpha complex64, A [][]complex64, beta complex64, C [][]complex64)

Computes a rank-k update of the symmetric matrix C:

C = alpha A*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := complex64(1)
A := matrix.MakeComplex64(2, 3)
A[0][0] = 1

beta := complex64(0)
C := matrix.MakeComplex64(3, 3)

CSYRK(Upper, Trans, alpha, A, beta, C)
fmt.Println(C)

Output:

[[(1+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]]

func CTRMM ¶

func CTRMM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha complex64, A [][]complex64, B [][]complex64)

Computes the matrix-matrix product

B = alpha op(A) B (for Side is Left)
B = alpha B op(A) (for Side is Right)

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := complex64(1)
A := matrix.MakeComplex64(3, 3)
A[1][1] = 1
A[1][2] = complex(0, 1)
B := matrix.MakeComplex64(2, 3)
B[1][2] = 1

CTRMM(Right, Upper, ConjTrans, NonUnit, alpha, A, B)
fmt.Println(B)

Output:

[[(0+0i) (0+0i) (0+0i)] [(0+0i) (0-1i) (0+0i)]]

func CTRMV ¶

func CTRMV(uplo Uplo, transA Transpose, diag Diag, A [][]complex64, X []complex64, incX int)

Triangular matrix-vector multiplication plus vector with optional matrix transpose. With uplo == Upper or Lower, the upper or lower triangular part of A is used. diag specifies whether the matrix is unit triangular (). When transA == NoTrans this computes:

X = A*X

When transA == Trans this computes:

X = (A^T)*X

Every incX'th element of X is used. Matrices must be allocated with MakeComplex64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeComplex64(2, 2)
A[0][0] = 1
A[1][1] = 1

A[0][1] = 2

X := []complex64{-1, 4}
incX := 1

fmt.Println(A, "*", X)
CTRMV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println("=", X)

Output:

[[(1+0i) (2+0i)] [(0+0i) (1+0i)]] * [(-1+0i) (4+0i)]
= [(7+0i) (4+0i)]

func CTRSM ¶

func CTRSM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha complex64, A [][]complex64, B [][]complex64)

Computes the inverse-matrix matrix product

B = alpha op(inv(A))B for Side is Left
B = alpha B op(inv(A)) for Side is Right.

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := complex64(1)
A := matrix.MakeComplex64(3, 3)
A[1][1] = 1
A[1][2] = complex(0, 1)
B := matrix.MakeComplex64(2, 3)
B[1][2] = 1

CTRSM(Right, Upper, ConjTrans, Unit, alpha, A, B)
fmt.Println(B)

Output:

[[(0+0i) (0+0i) (0+0i)] [(0+0i) (0+1i) (1+0i)]]

func CTRSV ¶

func CTRSV(uplo Uplo, transA Transpose, diag Diag, A [][]complex64, X []complex64, incX int)

Computes

inv(op(A)) x for x

where op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of the matrix is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

// solve:
//  x - y = 2
//      y = 3
// for x, y:
A := matrix.MakeComplex64(2, 2)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 1
X := []complex64{2, 3}
incX := 1
CTRSV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println(X)

Output:

[(5+0i) (3+0i)]

func DASUM ¶

func DASUM(X []float64, incX int) float64

Computes the sum of the absolute values of the elements in vector X. Every incX'th element is used.

X := []float64{1, 666, 2, 666}
incX := 2
result := DASUM(X, incX)
fmt.Println(result)

Output:

3

func DAXPY ¶

func DAXPY(alpha float64, X []float64, incX int, Y []float64, incY int)

Replaces Y by (alpha*X) + Y. Every incX'th and incY'th element is used.

alpha := float64(2)
X := []float64{1, 2, 3}
incX := 1
Y := []float64{4, 5, 6}
incY := 1
DAXPY(alpha, X, incX, Y, incY)
fmt.Println(Y)

Output:

[6 9 12]

func DCOPY ¶

func DCOPY(X []float64, incX int, Y []float64, incY int)

Copies X to Y. Every incX'th and incY'th element is used.

X := []float64{1, 666, 2, 666}
incX := 2
Y := []float64{-1, -2}
incY := 1
DCOPY(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[1 666 2 666] [1 2]

func DDOT ¶

func DDOT(X []float64, incX int, Y []float64, incY int) float64

Computes the dot product of vectors X and Y. Every incX'th and incY'th element is used.

X := []float64{2, 0}
incX := 1
Y := []float64{3, 5}
incY := 1
result := DDOT(X, incX, Y, incY)
fmt.Println(result)

Output:

6

func DGEMM ¶

func DGEMM(transA Transpose, transB Transpose, alpha float64, A [][]float64, B [][]float64, beta float64, C [][]float64)

General matrix-matrix multiplication:

C = alpha*A*B + beta*C

where A and B can optionally be transposed by specifying transA, transB = Trans/NoTrans

alpha := 1.0
A := matrix.MakeFloat64(2, 4)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 2

B := matrix.MakeFloat64(4, 3)
B[1][0] = 2
B[2][1] = 3

beta := 0.0
C := matrix.MakeFloat64(2, 3)
DGEMM(NoTrans, NoTrans, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[1 -1 0 0] [0 2 0 0]] * [[0 0 0] [2 0 0] [0 3 0] [0 0 0]] = [[-2 0 0] [4 0 0]]

func DGEMV ¶

func DGEMV(transA Transpose, alpha float64, A [][]float64, X []float64, incX int, beta float64, Y []float64, incY int)

Matrix-vector multiplication plus vector with optional matrix transpose. When transA == NoTrans this computes:

Y = alpha*A*X + beta*Y

When transA == Trans this computes:

Y = alpha*(A^T)*X + beta*Y

Every incX'th element of X and incY'th element of Y is used. Matrices must be allocated with MakeFloat64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeFloat64(2, 3)
A[0][1] = 1
A[0][2] = 2
A[1][0] = 3

X := []float64{-1, 4, 0}
incX := 1
Y := []float64{0, 0}
incY := 1

alpha := 1.0
beta := 0.0

DGEMV(NoTrans, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A, "*", X, "=", Y)

DGEMV(Trans, alpha, A, Y, incX, beta, X, incY)
fmt.Println(A, "^T*", Y, "=", X)

Output:

[[0 1 2] [3 0 0]] * [-1 4 0] = [4 -3]
[[0 1 2] [3 0 0]] ^T* [4 -3] = [-9 4 8]

func DGER ¶

func DGER(alpha float64, X []float64, incX int, Y []float64, incY int, A [][]float64)

Computes

A = alpha*X*(Y^T) + A

Matrices must be allocated with MakeFloat64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. Every incX'th element of X and incY'th element of Y is used.

alpha := 1.0
X := []float64{1, 2}
incX := 1
Y := []float64{3, 4, 5}
incY := 1
A := matrix.MakeFloat64(2, 3)
DGER(alpha, X, incX, Y, incY, A)
fmt.Println(X, "*", Y, "^T = ", A)

Output:

[1 2] * [3 4 5] ^T =  [[3 4 5] [6 8 10]]

func DNRM2 ¶

func DNRM2(X []float64, incX int) float64

Computes the L2 norm (Euclidian length) of vector X. Every incX'th element is used.

X := []float64{1, 666, 1, 666}
incX := 2
result := DNRM2(X, incX)
fmt.Println(result)

Output:

1.4142135623730951

func DROT ¶

func DROT(X []float64, incX int, Y []float64, incY int, c float64, s float64)

Applies a plane rotation to the two vectors X and Y. This routine computes:

[ x_i ]   [ c s ] [ x_i ]
[ y_i ] = [-s c ] [ y_i ]

for all i with strides incX, incY.

X := []float64{1, 0, 1}
incX := 1
Y := []float64{0, 1, 1}
incY := 1
theta := math.Pi / 4
c := math.Cos(theta)
s := math.Sin(theta)
DROT(X, incX, Y, incY, c, s)
fmt.Println(X, Y)

Output:

[0.7071067811865476 0.7071067811865475 1.414213562373095] [-0.7071067811865475 0.7071067811865476 1.1102230246251565e-16]

func DROTG ¶

func DROTG(a float64, b float64) (r, c, s float64)

Constructs a Givens rotation matrix. Computes the values of c and s so that:

[ c  s ] [ a ]    [ r ]
[ -s c ] [ b ] =  [ 0 ].

Returns r, c and s.

func DROTM ¶

func DROTM(X []float64, incX int, Y []float64, incY int, P [5]float64)

Applies the modified-Givens rotation of the vectors X and Y:

[ x_i ]   [ h_11 h_12 ] [ x_i ]
[ y_i ] = [ h_21 h_22 ] [ y_i ]

for all i with strides incX, incY

H stored in P according to the encoding used by DROTMG.

d1 := 1.0
d2 := 1.0
b1 := 1.0
b2 := 1.0
P := DROTMG(d1, d2, b1, b2)

X := []float64{1}
incX := 1
Y := []float64{1}
incY := 1
DROTM(X, incX, Y, incY, P)
fmt.Println(X, Y)

Output:

[2] [0]

func DROTMG ¶

func DROTMG(d1 float64, d2 float64, b1 float64, b2 float64) [5]float64

Constructs a modified Givens rotation matrix. The input scalars d1, d2, x1 and y1 define a 2-vector [a1 a2]' such that

[ b1 ]   [ d1^{1/2}  0      ] [ x1 ]
[ b2 ] = [   0     d2^{1/2} ] [ y1 ].

This subroutine determines the modified Givens rotation matrix H that transforms y1 and thus a2 to zero. A representation of this matrix is returned:

P[0]: defines the form of matrix H:

-2.0: matrix H contains the identity matrix.
-1.0: matrix H is identical to matrix SH (defined by the remaining values in the vector).
 0.0: H[1,2] and H[2,1] are obtained from matrix SH. The remaining values are both 1.0.
 1.0: H[1,1] and H[2,2] are obtained from matrix SH. H[1,2] is 1.0. H[2,1] is -1.0.

The other elements contain SH:

P[1]	contains SH[1,1].
P[2]	contains SH[2,1].
P[3]	contains SH[1,2].
P[4]	contains SH[2,2].

d1 := 1.0
d2 := 1.0
b1 := 1.0
b2 := 1.0
result := DROTMG(d1, d2, b1, b2)
fmt.Println(result)

Output:

[1 1 0 0 1]

func DSCAL ¶

func DSCAL(alpha float64, X []float64, incX int)

Multiply X by alpha. Every incX'th element is used.

alpha := 2.0
X := []float64{1, 666, 2, 666}
incX := 2
DSCAL(alpha, X, incX)
fmt.Println(X)

Output:

[2 666 4 666]

func DSDOT ¶

func DSDOT(X []float32, incX int, Y []float32, incY int) float64

Computes the dot product of vectors X and Y. Every incX'th and incY'th element is used.

X := []float32{2, 0}
incX := 1
Y := []float32{3, 5}
incY := 1
result := DSDOT(X, incX, Y, incY)
fmt.Println(result)

Output:

6

func DSWAP ¶

func DSWAP(X []float64, incX int, Y []float64, incY int)

Exchanges the elements of vectors X and Y. Every incX'th and incY'th element is used.

X := []float64{1, 666, 2, 666}
incX := 2
Y := []float64{-1, -2}
incY := 1
DSWAP(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[-1 666 -2 666] [1 2]

func DSYMM ¶

func DSYMM(side Side, uplo Uplo, alpha float64, A [][]float64, B [][]float64, beta float64, C [][]float64)

Computes the matrix-matrix product

C = alpha*A*B + beta*C  (for Side==Left)
C = alpha*B*A + beta*C  (for Side==Right)

where the matrix A is symmetric. Only its upper half or lower half is used, specified by uplo=Upper/Lower.

alpha := 1.0
A := matrix.MakeFloat64(3, 3)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 2

B := matrix.MakeFloat64(3, 2)
B[1][0] = 2
B[2][1] = 3

beta := 0.0
C := matrix.MakeFloat64(3, 2)
DSYMM(Left, Upper, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[1 -1 0] [0 2 0] [0 0 0]] * [[0 0] [2 0] [0 3]] = [[-2 0] [4 0] [0 0]]

func DSYMV ¶

func DSYMV(uplo Uplo, alpha float64, A [][]float64, X []float64, incX int, beta float64, Y []float64, incY int)

Symmetric matrix-vector multiplication:

Y = alpha*A*X + beta*Y

A is a symmetric matrix, where uplo (Upper or Lower) determines which part of A is used. Every incX'th element of X and incY'th element of Y is used.

A := matrix.MakeFloat64(2, 2)
A[0][0] = 1
A[1][1] = 2
A[0][1] = 3
A[1][0] = 3

X := []float64{-1, 4}
incX := 1
Y := []float64{0, 0}
incY := 1

alpha := float64(1.0)
beta := float64(0.0)

DSYMV(Upper, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A, "*", X, "=", Y)

Output:

[[1 3] [3 2]] * [-1 4] = [11 5]

func DSYR ¶

func DSYR(uplo Uplo, alpha float64, X []float64, incX int, A [][]float64)

Computes

A = A + alpha*X*(X^T)

A is a symmetric matrix, where uplo (Upper or Lower) determines which part of A is used.

alpha := 1.0
X := []float64{1, 2}
incX := 1
A := matrix.MakeFloat64(2, 2)
DSYR(Upper, alpha, X, incX, A)
fmt.Println(X, "*", X, "^T = ", A)

Output:

[1 2] * [1 2] ^T =  [[1 2] [0 4]]

func DSYR2 ¶

func DSYR2(uplo Uplo, alpha float64, X []float64, incX int, Y []float64, incY int, A [][]float64)

Computes the symmetric rank-2 update

A = \alpha x y^T + \alpha y x^T + A

of the symmetric matrix A. Since the matrix A is symmetric only its upper half or lower half need to be stored. When Uplo is Upper then the upper triangle and diagonal of A are used, and when Uplo is Lower then the lower triangle and diagonal of A are used.

alpha := float64(1)
X := []float64{1, 2}
incX := 1
Y := []float64{2, 4}
incY := 1
A := matrix.MakeFloat64(2, 2)
DSYR2(Upper, alpha, X, incX, Y, incY, A)
fmt.Println(A)

Output:

[[4 8] [0 16]]

func DSYR2K ¶

func DSYR2K(uplo Uplo, trans Transpose, alpha float64, A [][]float64, B [][]float64, beta float64, C [][]float64)

Computes a rank-2k update of the symmetric matrix C:

C = alpha A*(B^T) + alpha B*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*B + alpha (B^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := float64(1.0)
A := matrix.MakeFloat64(2, 3)
A[0][0] = 1

B := matrix.MakeFloat64(2, 3)
B[0][0] = 1

beta := float64(0.0)
C := matrix.MakeFloat64(3, 3)

DSYR2K(Upper, Trans, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[2 0 0] [0 0 0] [0 0 0]]

func DSYRK ¶

func DSYRK(uplo Uplo, trans Transpose, alpha float64, A [][]float64, beta float64, C [][]float64)

Computes a rank-k update of the symmetric matrix C:

C = alpha A*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := 1.0
A := matrix.MakeFloat64(2, 3)
A[0][0] = 1

beta := 0.0
C := matrix.MakeFloat64(3, 3)

DSYRK(Upper, Trans, alpha, A, beta, C)
fmt.Println(C)

Output:

[[1 0 0] [0 0 0] [0 0 0]]

func DTRMM ¶

func DTRMM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha float64, A [][]float64, B [][]float64)

Computes the matrix-matrix product

B = alpha op(A) B (for Side is Left)
B = alpha B op(A) (for Side is Right)

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := float64(1.0)
A := matrix.MakeFloat64(3, 3)
A[1][1] = 1
A[1][2] = 1
B := matrix.MakeFloat64(2, 3)
B[1][1] = 1

DTRMM(Right, Lower, Trans, NonUnit, alpha, A, B)
fmt.Println(B)

Output:

[[0 0 0] [0 1 0]]

func DTRMV ¶

func DTRMV(uplo Uplo, transA Transpose, diag Diag, A [][]float64, X []float64, incX int)

Triangular matrix-vector multiplication plus vector with optional matrix transpose. With uplo == Upper or Lower, the upper or lower triangular part of A is used. diag specifies whether the matrix is unit triangular (). When transA == NoTrans this computes:

X = A*X

When transA == Trans this computes:

X = (A^T)*X

Every incX'th element of X is used. Matrices must be allocated with MakeFloat64Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeFloat64(2, 2)
A[0][0] = 1
A[1][1] = 1

A[0][1] = 2

X := []float64{-1, 4}
incX := 1

fmt.Println(A, "*", X)
DTRMV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println("=", X)

Output:

[[1 2] [0 1]] * [-1 4]
= [7 4]

func DTRSM ¶

func DTRSM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha float64, A [][]float64, B [][]float64)

Computes the inverse-matrix matrix product

B = alpha op(inv(A))B for Side is Left
B = alpha B op(inv(A)) for Side is Right.

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := float64(1.0)
A := matrix.MakeFloat64(3, 3)
B := matrix.MakeFloat64(3, 2)
B[1][1] = 1

DTRSM(Left, Upper, NoTrans, Unit, alpha, A, B)
fmt.Println(B)

Output:

[[0 0] [0 1] [0 0]]

func DTRSV ¶

func DTRSV(uplo Uplo, transA Transpose, diag Diag, A [][]float64, X []float64, incX int)

Computes

inv(op(A)) x for x

where op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of the matrix is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

// solve:
//  x - y = 2
//      y = 3
// for x, y:
A := matrix.MakeFloat64(2, 2)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 1
X := []float64{2, 3}
incX := 1
DTRSV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println(X)

Output:

[5 3]

func DZASUM ¶

func DZASUM(X []complex128, incX int) float64

Computes the sum of the absolute values of real and imaginary parts of elements in vector X. Every incX'th element is used.

X := []complex128{complex(1, 0), complex(1, 1)}
incX := 1
result := DZASUM(X, incX)
fmt.Println(result)

Output:

3

func DZNRM2 ¶

func DZNRM2(X []complex128, incX int) float64

Computes the unitary norm of vector X. Every incX'th element is used.

X := []complex128{complex(1, 0), complex(0, 1)}
incX := 1
result := DZNRM2(X, incX)
fmt.Println(result)

Output:

1.4142135623730951

func ICAMAX ¶

func ICAMAX(X []complex64, incX int) int

Returns the index of the element with the largest absolute value in vector X. Every incX'th element is used.

X := []complex64{complex(2, 0), complex(2, 2), complex(0, 2)}
incX := 1
result := ICAMAX(X, incX)
fmt.Println(result)

Output:

1

func IDAMAX ¶

func IDAMAX(X []float64, incX int) int

Returns the index of the element with the largest absolute value in vector X. Every incX'th element is used.

X := []float32{1, -999, 2, 3, 999}
incX := 1
result := ISAMAX(X, incX)
fmt.Println(result)

Output:

1

func ISAMAX ¶

func ISAMAX(X []float32, incX int) int

Returns the index of the element with the largest absolute value in vector X. Every incX'th element is used.

X := []float32{1, -999, 2, 3, 999}
incX := 1
result := ISAMAX(X, incX)
fmt.Println(result)

Output:

1

func IZAMAX ¶

func IZAMAX(X []complex128, incX int) int

Returns the index of the element with the largest absolute value in vector X. Every incX'th element is used.

X := []complex128{complex(2, 0), complex(2, 2), complex(0, 2)}
incX := 1
result := IZAMAX(X, incX)
fmt.Println(result)

Output:

1

func SASUM ¶

func SASUM(X []float32, incX int) float32

Computes the sum of the absolute values of the elements in vector X. Every incX'th element is used.

X := []float32{1, 666, 2, 666}
incX := 2
result := SASUM(X, incX)
fmt.Println(result)

Output:

3

func SAXPY ¶

func SAXPY(alpha float32, X []float32, incX int, Y []float32, incY int)

Replaces Y by (alpha*X) + Y. Every incX'th and incY'th element is used.

alpha := float32(2)
X := []float32{1, 2, 3}
incX := 1
Y := []float32{4, 5, 6}
incY := 1
SAXPY(alpha, X, incX, Y, incY)
fmt.Println(Y)

Output:

[6 9 12]

func SCASUM ¶

func SCASUM(X []complex64, incX int) float32

Computes the sum of the absolute values of real and imaginary parts of elements in vector X. Every incX'th element is used.

X := []complex64{complex(1, 0), complex(1, 1)}
incX := 1
result := SCASUM(X, incX)
fmt.Println(result)

Output:

3

func SCNRM2 ¶

func SCNRM2(X []complex64, incX int) float32

Computes the unitary norm of vector X. Every incX'th element is used.

X := []complex64{complex(1, 0), complex(0, 1)}
incX := 1
result := SCNRM2(X, incX)
fmt.Println(result)

Output:

1.4142135

func SCOPY ¶

func SCOPY(X []float32, incX int, Y []float32, incY int)

Copies X to Y. Every incX'th and incY'th element is used.

X := []float32{1, 666, 2, 666}
incX := 2
Y := []float32{-1, -2}
incY := 1
SCOPY(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[1 666 2 666] [1 2]

func SDOT ¶

func SDOT(X []float32, incX int, Y []float32, incY int) float32

Computes the dot product of vectors X and Y. Every incX'th and incY'th element is used.

X := []float32{2, 0}
incX := 1
Y := []float32{3, 5}
incY := 1
result := SDOT(X, incX, Y, incY)
fmt.Println(result)

Output:

6

func SDSDOT ¶

func SDSDOT(alpha float32, X []float32, incX int, Y []float32, incY int) float32

Computes the dot product of vectors X and Y plus an initial value alpha. Every incX'th and incY'th element is used.

alpha := float32(4)
X := []float32{2, 0}
incX := 1
Y := []float32{3, 5}
incY := 1
result := SDSDOT(alpha, X, incX, Y, incY)
fmt.Println(result)

Output:

10

func SGEMM ¶

func SGEMM(transA Transpose, transB Transpose, alpha float32, A [][]float32, B [][]float32, beta float32, C [][]float32)

General matrix-matrix multiplication:

C = alpha*A*B + beta*C

where A and B can optionally be transposed by specifying transA, transB = Trans/NoTrans

alpha := float32(1.0)
A := matrix.MakeFloat32(2, 4)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 2

B := matrix.MakeFloat32(4, 3)
B[1][0] = 2
B[2][1] = 3

beta := float32(0.0)
C := matrix.MakeFloat32(2, 3)
SGEMM(NoTrans, NoTrans, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[1 -1 0 0] [0 2 0 0]] * [[0 0 0] [2 0 0] [0 3 0] [0 0 0]] = [[-2 0 0] [4 0 0]]

func SGEMV ¶

func SGEMV(transA Transpose, alpha float32, A [][]float32, X []float32, incX int, beta float32, Y []float32, incY int)

Matrix-vector multiplication plus vector with optional matrix transpose. When transA == NoTrans this computes:

Y = alpha*A*X + beta*Y

When transA == Trans this computes:

Y = alpha*(A^T)*X + beta*Y

Every incX'th element of X and incY'th element of Y is used. Matrices must be allocated with MakeFloat32Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeFloat32(2, 3)
A[0][1] = 1
A[0][2] = 2
A[1][0] = 3

X := []float32{-1, 4, 0}
incX := 1
Y := []float32{0, 0}
incY := 1

alpha := float32(1.0)
beta := float32(0.0)

SGEMV(NoTrans, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A, "*", X, "=", Y)

SGEMV(Trans, alpha, A, Y, incX, beta, X, incY)
fmt.Println(A, "^T*", Y, "=", X)

Output:

[[0 1 2] [3 0 0]] * [-1 4 0] = [4 -3]
[[0 1 2] [3 0 0]] ^T* [4 -3] = [-9 4 8]

func SGER ¶

func SGER(alpha float32, X []float32, incX int, Y []float32, incY int, A [][]float32)

Computes

A = alpha*X*(Y^T) + A

Matrices must be allocated with MakeFloat32Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. Every incX'th element of X and incY'th element of Y is used.

alpha := float32(1)
X := []float32{1, 2}
incX := 1
Y := []float32{3, 4, 5}
incY := 1
A := matrix.MakeFloat32(2, 3)
SGER(alpha, X, incX, Y, incY, A)
fmt.Println(X, "*", Y, "^T = ", A)

Output:

[1 2] * [3 4 5] ^T =  [[3 4 5] [6 8 10]]

func SNRM2 ¶

func SNRM2(X []float32, incX int) float32

Computes the L2 norm (Euclidian length) of vector X. Every incX'th element is used.

X := []float32{1, 666, 1, 666}
incX := 2
result := SNRM2(X, incX)
fmt.Println(result)

Output:

1.4142135

func SROT ¶

func SROT(X []float32, incX int, Y []float32, incY int, c float32, s float32)

Applies a plane rotation to the two vectors X and Y, This routine computes:

[ x_i ]   [ c s ] [ x_i ]
[ y_i ] = [-s c ] [ y_i ]

for all i with strides incX and incY.

X := []float32{1, 0, 1}
incX := 1
Y := []float32{0, 1, 1}
incY := 1
theta := math.Pi / 4
c := float32(math.Cos(theta))
s := float32(math.Sin(theta))
SROT(X, incX, Y, incY, c, s)
fmt.Println(X, Y)

Output:

[0.70710677 0.70710677 1.4142135] [-0.70710677 0.70710677 0]

func SROTG ¶

func SROTG(a float32, b float32) (r, c, s float32)

Constructs a Givens rotation matrix. Computes the values of c and s so that:

[ c  s ] [ a ]    [ r ]
[ -s c ] [ b ] =  [ 0 ].

Returns r, c and s.

a := float32(1)
b := float32(1)
r, c, s := SROTG(a, b)
fmt.Println(r, c, s)

Output:

1.4142135 0.70710677 0.70710677

func SROTM ¶

func SROTM(X []float32, incX int, Y []float32, incY int, P [5]float32)

Applies the modified-Givens rotation of the vectors X and Y:

[ x_i ]   [ h_11 h_12 ] [ x_i ]
[ y_i ] = [ h_21 h_22 ] [ y_i ]

for all i.

H stored in P according to the encoding used by SROTMG.

d1 := float32(1.0)
d2 := float32(1.0)
b1 := float32(1.0)
b2 := float32(1.0)
P := SROTMG(d1, d2, b1, b2)

X := []float32{1}
incX := 1
Y := []float32{1}
incY := 1
SROTM(X, incX, Y, incY, P)
fmt.Println(X, Y)

Output:

[2] [0]

func SROTMG ¶

func SROTMG(d1 float32, d2 float32, b1 float32, b2 float32) [5]float32

Constructs a modified Givens rotation matrix. The input scalars d1, d2, x1 and y1 define a 2-vector [a1 a2]' such that

[ b1 ]   [ d1^{1/2}  0      ] [ x1 ]
[ b2 ] = [   0     d2^{1/2} ] [ y1 ].

This subroutine determines the modified Givens rotation matrix H that transforms y1 and thus a2 to zero. A representation of this matrix is returned:

P[0]: defines the form of matrix H:

-2.0: matrix H contains the identity matrix.
-1.0: matrix H is identical to matrix SH (defined by the remaining values in the vector).
 0.0: H[1,2] and H[2,1] are obtained from matrix SH. The remaining values are both 1.0.
 1.0: H[1,1] and H[2,2] are obtained from matrix SH. H[1,2] is 1.0. H[2,1] is -1.0.

The other elements contain SH:

P[1]	contains SH[1,1].
P[2]	contains SH[2,1].
P[3]	contains SH[1,2].
P[4]	contains SH[2,2].

d1 := float32(1)
d2 := float32(1)
b1 := float32(1)
b2 := float32(1)
result := SROTMG(d1, d2, b1, b2)
fmt.Println(result)

Output:

[1 1 0 0 1]

func SSCAL ¶

func SSCAL(alpha float32, X []float32, incX int)

Multiply X by alpha. Every incX'th element is used.

alpha := float32(2)
X := []float32{1, 666, 2, 666}
incX := 2
SSCAL(alpha, X, incX)
fmt.Println(X)

Output:

[2 666 4 666]

func SSWAP ¶

func SSWAP(X []float32, incX int, Y []float32, incY int)

Exchanges the elements of vectors X and Y. Every incX'th and incY'th element is used.

X := []float32{1, 666, 2, 666}
incX := 2
Y := []float32{-1, -2}
incY := 1
SSWAP(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[-1 666 -2 666] [1 2]

func SSYMM ¶

func SSYMM(side Side, uplo Uplo, alpha float32, A [][]float32, B [][]float32, beta float32, C [][]float32)

Computes the matrix-matrix product

C = alpha*A*B + beta*C  (for Side==Left)
C = alpha*B*A + beta*C  (for Side==Right)

where the matrix A is symmetric. Only its upper half or lower half is used, specified by uplo=Upper/Lower.

alpha := float32(1.0)
A := matrix.MakeFloat32(3, 3)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 2

B := matrix.MakeFloat32(3, 2)
B[1][0] = 2
B[2][1] = 3

beta := float32(0.0)
C := matrix.MakeFloat32(3, 2)
SSYMM(Left, Upper, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[1 -1 0] [0 2 0] [0 0 0]] * [[0 0] [2 0] [0 3]] = [[-2 0] [4 0] [0 0]]

func SSYMV ¶

func SSYMV(uplo Uplo, alpha float32, A [][]float32, X []float32, incX int, beta float32, Y []float32, incY int)

Symmetric matrix-vector multiplication:

Y = alpha*A*X + beta*Y

Matrices must be allocated with MakeFloat32Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. A is a symmetric matrix, where uplo (Upper or Lower) determines which part of A is used. Every incX'th element of X and incY'th element of Y is used.

A := matrix.MakeFloat32(2, 2)
A[0][0] = 1
A[1][1] = 2
A[0][1] = 3
A[1][0] = 3

X := []float32{-1, 4}
incX := 1
Y := []float32{0, 0}
incY := 1

alpha := float32(1.0)
beta := float32(0.0)

SSYMV(Upper, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A, "*", X, "=", Y)

Output:

[[1 3] [3 2]] * [-1 4] = [11 5]

func SSYR ¶

func SSYR(uplo Uplo, alpha float32, X []float32, incX int, A [][]float32)

Computes

A = A + alpha*X*(X^T)

A is a symmetric matrix, where uplo (Upper or Lower) determines which part of A is used.

alpha := float32(1)
X := []float32{1, 2}
incX := 1
A := matrix.MakeFloat32(2, 2)
SSYR(Upper, alpha, X, incX, A)
fmt.Println(X, "*", X, "^T = ", A)

Output:

[1 2] * [1 2] ^T =  [[1 2] [0 4]]

func SSYR2 ¶

func SSYR2(uplo Uplo, alpha float32, X []float32, incX int, Y []float32, incY int, A [][]float32)

Computes the symmetric rank-2 update

A = \alpha x y^T + \alpha y x^T + A

of the symmetric matrix A. Since the matrix A is symmetric only its upper half or lower half need to be stored. When Uplo is Upper then the upper triangle and diagonal of A are used, and when Uplo is Lower then the lower triangle and diagonal of A are used.

alpha := float32(1)
X := []float32{1, 2}
incX := 1
Y := []float32{2, 4}
incY := 1
A := matrix.MakeFloat32(2, 2)
SSYR2(Upper, alpha, X, incX, Y, incY, A)
fmt.Println(A)

Output:

[[4 8] [0 16]]

func SSYR2K ¶

func SSYR2K(uplo Uplo, trans Transpose, alpha float32, A [][]float32, B [][]float32, beta float32, C [][]float32)

Computes a rank-2k update of the symmetric matrix C:

C = alpha A*(B^T) + alpha B*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*B + alpha (B^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := float32(1.0)
A := matrix.MakeFloat32(2, 3)
A[0][0] = 1

B := matrix.MakeFloat32(2, 3)
B[0][0] = 1

beta := float32(0.0)
C := matrix.MakeFloat32(3, 3)

SSYR2K(Upper, Trans, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[2 0 0] [0 0 0] [0 0 0]]

func SSYRK ¶

func SSYRK(uplo Uplo, trans Transpose, alpha float32, A [][]float32, beta float32, C [][]float32)

Computes a rank-k update of the symmetric matrix C:

C = alpha A*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := float32(1.0)
A := matrix.MakeFloat32(2, 3)
A[0][0] = 1

beta := float32(0.0)
C := matrix.MakeFloat32(3, 3)

SSYRK(Upper, Trans, alpha, A, beta, C)
fmt.Println(C)

Output:

[[1 0 0] [0 0 0] [0 0 0]]

func STRMM ¶

func STRMM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha float32, A [][]float32, B [][]float32)

Computes the matrix-matrix product

B = alpha op(A) B (for Side is Left)
B = alpha B op(A) (for Side is Right)

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := float32(1.0)
A := matrix.MakeFloat32(3, 3)
A[1][1] = 1
A[2][2] = 1
B := matrix.MakeFloat32(3, 2)
B[1][1] = 1

STRMM(Left, Upper, NoTrans, NonUnit, alpha, A, B)
fmt.Println(B)

Output:

[[0 0] [0 1] [0 0]]

func STRMV ¶

func STRMV(uplo Uplo, transA Transpose, diag Diag, A [][]float32, X []float32, incX int)

Triangular matrix-vector multiplication plus vector with optional matrix transpose. With uplo == Upper or Lower, the upper or lower triangular part of A is used. diag specifies whether the matrix is unit triangular (). When transA == NoTrans this computes:

X = A*X

When transA == Trans this computes:

X = (A^T)*X

Every incX'th element of X is used. Matrices must be allocated with MakeFloat32Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeFloat32(2, 2)
A[0][0] = 1
A[1][1] = 1

A[0][1] = 2

X := []float32{-1, 4}
incX := 1

fmt.Println(A, "*", X)
STRMV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println("=", X)

Output:

[[1 2] [0 1]] * [-1 4]
= [7 4]

func STRSM ¶

func STRSM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha float32, A [][]float32, B [][]float32)

Computes the inverse-matrix matrix product

B = alpha op(inv(A))B for Side is Left
B = alpha B op(inv(A)) for Side is Right.

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := float32(1.0)
A := matrix.MakeFloat32(3, 3)
B := matrix.MakeFloat32(3, 2)
B[1][1] = 1

STRSM(Left, Upper, NoTrans, Unit, alpha, A, B)
fmt.Println(B)

Output:

[[0 0] [0 1] [0 0]]

func STRSV ¶

func STRSV(uplo Uplo, transA Transpose, diag Diag, A [][]float32, X []float32, incX int)

Computes

inv(op(A)) x for x

where op(A) = A, A^T for TransA = NoTrans, Trans When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of the matrix is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

// solve:
//  x - y = 2
//      y = 3
// for x, y:
A := matrix.MakeFloat32(2, 2)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 1
X := []float32{2, 3}
incX := 1
STRSV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println(X)

Output:

[5 3]

func ZAXPY ¶

func ZAXPY(alpha complex128, X []complex128, incX int, Y []complex128, incY int)

Replaces Y by (alpha*X) + Y. Every incX'th and incY'th element is used.

alpha := complex128(complex(0, 1))
X := []complex128{1, 2, 3}
incX := 1
Y := []complex128{4, 5, 6}
incY := 1
ZAXPY(alpha, X, incX, Y, incY)
fmt.Println(Y)

Output:

[(4+1i) (5+2i) (6+3i)]

func ZCOPY ¶

func ZCOPY(X []complex128, incX int, Y []complex128, incY int)

Copies X to Y. Every incX'th and incY'th element is used.

X := []complex128{1, 666, 2, 666}
incX := 2
Y := []complex128{-1, -2}
incY := 1
ZCOPY(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[(1+0i) (666+0i) (2+0i) (666+0i)] [(1+0i) (2+0i)]

func ZDOTC ¶

func ZDOTC(X []complex128, incX int, Y []complex128, incY int) complex128

Calculates the dot product of the complex conjugate of X with Y. Every incX'th and incY'th element is used.

X := []complex128{complex(1, 0), complex(1, 1)}
incX := 1
Y := []complex128{complex(0, 0), complex(2, 0)}
incY := 1
result := ZDOTC(X, incX, Y, incY)
fmt.Println(result)

Output:

(2-2i)

func ZDOTU ¶

func ZDOTU(X []complex128, incX int, Y []complex128, incY int) complex128

Computes the dot product of vectors X and Y. Every incX'th and incY'th element is used.

X := []complex128{complex(1, 0), complex(1, 1)}
incX := 1
Y := []complex128{complex(0, 0), complex(2, 0)}
incY := 1
result := ZDOTU(X, incX, Y, incY)
fmt.Println(result)

Output:

(2+2i)

func ZDSCAL ¶

func ZDSCAL(alpha float64, X []complex128, incX int)

Multiply X by alpha. Every incX'th element is used.

alpha := 2.0
X := []complex128{1, 666, 2, 666}
incX := 2
ZDSCAL(alpha, X, incX)
fmt.Println(X)

Output:

[(2+0i) (666+0i) (4+0i) (666+0i)]

func ZGEMM ¶

func ZGEMM(transA Transpose, transB Transpose, alpha complex128, A [][]complex128, B [][]complex128, beta complex128, C [][]complex128)

General matrix-matrix multiplication:

C = alpha*A*B + beta*C

where A and B can optionally be transposed by specifying transA, transB = Trans/NoTrans

alpha := complex128(1.0)
A := matrix.MakeComplex128(2, 4)
A[0][0] = 1
A[0][1] = complex(0, -1)
A[1][1] = 2

B := matrix.MakeComplex128(4, 3)
B[1][0] = 2
B[2][1] = 3

beta := complex128(0.0)
C := matrix.MakeComplex128(2, 3)
ZGEMM(NoTrans, NoTrans, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[(1+0i) (0-1i) (0+0i) (0+0i)] [(0+0i) (2+0i) (0+0i) (0+0i)]] * [[(0+0i) (0+0i) (0+0i)] [(2+0i) (0+0i) (0+0i)] [(0+0i) (3+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]] = [[(0-2i) (0+0i) (0+0i)] [(4+0i) (0+0i) (0+0i)]]

func ZGEMV ¶

func ZGEMV(transA Transpose, alpha complex128, A [][]complex128, X []complex128, incX int, beta complex128, Y []complex128, incY int)

Matrix-vector multiplication plus vector with optional matrix transpose. When transA == NoTrans this computes:

Y = alpha*A*X + beta*Y

When transA == Trans this computes:

Y = alpha*(A^T)*X + beta*Y

Every incX'th element of X and incY'th element of Y is used. Matrices must be allocated with MakeComplex128Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeComplex128(2, 3)
A[0][1] = 1
A[0][2] = 2
A[1][0] = 3

X := []complex128{-1, 4, 0}
incX := 1
Y := []complex128{0, 0}
incY := 1

alpha := complex(1, 0)
beta := complex(0, 0)

ZGEMV(NoTrans, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A, "*", X, "=", Y)

ZGEMV(Trans, alpha, A, Y, incX, beta, X, incY)
fmt.Println(A, "^T*", Y, "=", X)

Output:

[[(0+0i) (1+0i) (2+0i)] [(3+0i) (0+0i) (0+0i)]] * [(-1+0i) (4+0i) (0+0i)] = [(4+0i) (-3+0i)]
[[(0+0i) (1+0i) (2+0i)] [(3+0i) (0+0i) (0+0i)]] ^T* [(4+0i) (-3+0i)] = [(-9+0i) (4+0i) (8+0i)]

func ZGERC ¶

func ZGERC(alpha complex128, X []complex128, incX int, Y []complex128, incY int, A [][]complex128)

Computes the conjugate rank-1 update

A = alpha*X*conj(Y^T) + A

Matrices must be allocated with MakeComplex128Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. Every incX'th element of X and incY'th element of Y is used.

alpha := complex128(1)
X := []complex128{1, 2}
incX := 1
Y := []complex128{complex(0, 3), complex(0, 4), complex(0, 5)}
incY := 1
A := matrix.MakeComplex128(2, 3)
ZGERC(alpha, X, incX, Y, incY, A)
fmt.Println(X, "* conj", Y, "^T = ", A)

Output:

[(1+0i) (2+0i)] * conj [(0+3i) (0+4i) (0+5i)] ^T =  [[(0-3i) (0-4i) (0-5i)] [(0-6i) (0-8i) (0-10i)]]

func ZGERU ¶

func ZGERU(alpha complex128, X []complex128, incX int, Y []complex128, incY int, A [][]complex128)

Computes the rank-1 update:

A = alpha*X*(Y^T) + A

Matrices must be allocated with MakeComplex128Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results. Every incX'th element of X and incY'th element of Y is used.

alpha := complex128(1)
X := []complex128{1, 2}
incX := 1
Y := []complex128{3, 4, 5}
incY := 1
A := matrix.MakeComplex128(2, 3)
ZGERU(alpha, X, incX, Y, incY, A)
fmt.Println(X, "*", Y, "^T = ", A)

Output:

[(1+0i) (2+0i)] * [(3+0i) (4+0i) (5+0i)] ^T =  [[(3+0i) (4+0i) (5+0i)] [(6+0i) (8+0i) (10+0i)]]

func ZHEMM ¶

func ZHEMM(side Side, uplo Uplo, alpha complex128, A [][]complex128, B [][]complex128, beta complex128, C [][]complex128)

Computes the matrix-matrix product and sum

C = alpha A B + beta C (for Side==Left)
C = alpha B A + beta C (for Side==Right)

where the matrix A is hermitian. When Uplo is Upper then the upper triangle and diagonal of A are used, and when Uplo is Lower then the lower triangle and diagonal of A are used. The imaginary elements of the diagonal are automatically set to zero.

alpha := complex128(1.0)
A := matrix.MakeComplex128(2, 2)
A[0][0] = 1
A[0][1] = complex(0, -1)
A[1][1] = 2

B := matrix.MakeComplex128(2, 2)
B[1][0] = 2
B[1][1] = 3

beta := complex128(0.0)
C := matrix.MakeComplex128(2, 2)
ZHEMM(Left, Upper, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[(0-2i) (0-3i)] [(4+0i) (6+0i)]]

func ZHEMV ¶

func ZHEMV(uplo Uplo, alpha complex128, A [][]complex128, X []complex128, incX int, beta complex128, Y []complex128, incY int)

Hermitian matrix-vector product:

Y = alpha*X + beta*Y

Matrices must be allocated with MakeComplex128Matrix to ensure contiguous underlying storage, With uplo == Upper or Lower, the upper or lower triangular part of A is used. Every incX'th and incY'th element is used.

A := matrix.MakeComplex128(3, 3)
A[0][1] = 1
A[0][2] = 2
A[1][0] = 3

X := []complex128{-1, 4, 0}
incX := 1
Y := []complex128{0, 0, 0}
incY := 1

alpha := complex128(complex(1, 0))
beta := complex128(complex(0, 0))

ZHEMV(Upper, alpha, A, X, incX, beta, Y, incY)
fmt.Println(A)

Output:

[[(0+0i) (1+0i) (2+0i)] [(3+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]]

func ZHER ¶

func ZHER(uplo Uplo, alpha float64, X []complex128, incX int, A [][]complex128)

Computes the hermitian rank-1 update:

A = alpha*X*conj(X^T) + A

A is a hermitian matrix. Only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := 1.0
X := []complex128{complex(0, 1), 2}
incX := 1
A := matrix.MakeComplex128(2, 2)
ZHER(Upper, alpha, X, incX, A)
fmt.Println(A)

Output:

[[(1+0i) (0+2i)] [(0+0i) (4+0i)]]

func ZHER2 ¶

func ZHER2(uplo Uplo, alpha complex128, X []complex128, incX int, Y []complex128, incY int, A [][]complex128)

Computes the hermitian rank-2 update: A = alpha X conj(Y^T) + conj(alpha) Y conj(X^T) + A A is a hermitian matrix. Only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := complex128(1.0)
X := []complex128{complex(0, 1), 2}
incX := 1
Y := []complex128{2, complex(3, 1)}
incY := 1
A := matrix.MakeComplex128(2, 2)
ZHER2(Upper, alpha, X, incX, Y, incY, A)
fmt.Println(A)

Output:

[[(2+0i) (0+4i)] [(0+0i) (8+0i)]]

func ZHER2K ¶

func ZHER2K(uplo Uplo, trans Transpose, alpha complex128, A [][]complex128, B [][]complex128, beta float64, C [][]complex128)

Computes a rank-2k update of the hermitian matrix C,

C = alpha A B^H + alpha^* B A^H + beta C (for trans==NoTrans)
C = alpha A^H B + alpha^* B^H A + beta C (for Trans==ConjTrans)

Since the matrix C is hermitian only its upper half or lower half need to be stored. When uplo is Upper then the upper triangle and diagonal of C are used, and when uplo is Lower then the lower triangle and diagonal of C are used. The imaginary elements of the diagonal are automatically set to zero.

alpha := complex(2.0, 3.0)
A := matrix.MakeComplex128(2, 2)
A[1][1] = complex(0, 1)
B := matrix.MakeComplex128(2, 2)
B[0][1] = complex(1, 0)
beta := 2.0
C := matrix.MakeComplex128(2, 2)
ZHER2K(Upper, NoTrans, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[(0+0i) (-3-2i)] [(0+0i) (0+0i)]]

func ZHERK ¶

func ZHERK(uplo Uplo, trans Transpose, alpha float64, A [][]complex128, beta float64, C [][]complex128)

Computes a rank-k update of the hermitian matrix C

C = alpha A A^H + beta C (for trans==NoTrans)
C = alpha A^H A + beta C (for trans==ConjTrans)

Since the matrix C is hermitian only its upper half or lower half need to be stored. When Uplo is Upper then the upper triangle and diagonal of C are used, and when Uplo is Lower then the lower triangle and diagonal of C are used. The imaginary elements of the diagonal are automatically set to zero.

alpha := 1.0
A := matrix.MakeComplex128(2, 2)
A[1][1] = complex(0, 1)
beta := 0.0
C := matrix.MakeComplex128(2, 2)
ZHERK(Upper, ConjTrans, alpha, A, beta, C)
fmt.Println(C)

Output:

[[(0+0i) (0+0i)] [(0+0i) (1+0i)]]

func ZSCAL ¶

func ZSCAL(alpha complex128, X []complex128, incX int)

Multiply X by alpha. Every incX'th element is used.

alpha := complex(0, 1)
X := []complex128{1, 666, 2, 666}
incX := 2
ZSCAL(alpha, X, incX)
fmt.Println(X)

Output:

[(0+1i) (666+0i) (0+2i) (666+0i)]

func ZSWAP ¶

func ZSWAP(X []complex128, incX int, Y []complex128, incY int)

Exchanges the elements of vectors X and Y. Every incX'th and incY'th element is used.

X := []complex128{1, 666, 2, 666}
incX := 2
Y := []complex128{-1, -2}
incY := 1
ZSWAP(X, incX, Y, incY)
fmt.Println(X, Y)

Output:

[(-1+0i) (666+0i) (-2+0i) (666+0i)] [(1+0i) (2+0i)]

func ZSYMM ¶

func ZSYMM(side Side, uplo Uplo, alpha complex128, A [][]complex128, B [][]complex128, beta complex128, C [][]complex128)

Computes the matrix-matrix product

C = alpha*A*B + beta*C  (for Side==Left)
C = alpha*B*A + beta*C  (for Side==Right)

where the matrix A is symmetric. Only its upper half or lower half is used, specified by uplo=Upper/Lower.

alpha := complex128(1)
A := matrix.MakeComplex128(3, 3)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 2

B := matrix.MakeComplex128(3, 2)
B[1][0] = 2
B[2][1] = 3

beta := complex128(0)
C := matrix.MakeComplex128(3, 2)
ZSYMM(Left, Upper, alpha, A, B, beta, C)
fmt.Println(A, "*", B, "=", C)

Output:

[[(1+0i) (-1+0i) (0+0i)] [(0+0i) (2+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]] * [[(0+0i) (0+0i)] [(2+0i) (0+0i)] [(0+0i) (3+0i)]] = [[(-2+0i) (0+0i)] [(4+0i) (0+0i)] [(0+0i) (0+0i)]]

func ZSYR2K ¶

func ZSYR2K(uplo Uplo, trans Transpose, alpha complex128, A [][]complex128, B [][]complex128, beta complex128, C [][]complex128)

Computes a rank-2k update of the symmetric matrix C:

C = alpha A*(B^T) + alpha B*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*B + alpha (B^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := complex128(1.0)
A := matrix.MakeComplex128(2, 3)
A[0][0] = 1

B := matrix.MakeComplex128(2, 3)
B[0][0] = 1

beta := complex128(0.0)
C := matrix.MakeComplex128(3, 3)

ZSYR2K(Upper, Trans, alpha, A, B, beta, C)
fmt.Println(C)

Output:

[[(2+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]]

func ZSYRK ¶

func ZSYRK(uplo Uplo, trans Transpose, alpha complex128, A [][]complex128, beta complex128, C [][]complex128)

Computes a rank-k update of the symmetric matrix C:

C = alpha A*(A^T) + beta C (for trans==NoTrans)
C = alpha (A^T)*A + beta C (for trans==Trans)

Since the matrix C is symmetric only its upper half or lower half need to be stored, specified by uplo=Upper/Lower.

alpha := complex128(1)
A := matrix.MakeComplex128(2, 3)
A[0][0] = 1

beta := complex128(0)
C := matrix.MakeComplex128(3, 3)

ZSYRK(Upper, Trans, alpha, A, beta, C)
fmt.Println(C)

Output:

[[(1+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)] [(0+0i) (0+0i) (0+0i)]]

func ZTRMM ¶

func ZTRMM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha complex128, A [][]complex128, B [][]complex128)

Computes the matrix-matrix product

B = alpha op(A) B (for Side is Left)
B = alpha B op(A) (for Side is Right)

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := complex128(1)
A := matrix.MakeComplex128(3, 3)
A[1][1] = 1
A[1][2] = complex(0, 1)
B := matrix.MakeComplex128(2, 3)
B[1][2] = 1

ZTRMM(Right, Upper, ConjTrans, NonUnit, alpha, A, B)
fmt.Println(B)

Output:

[[(0+0i) (0+0i) (0+0i)] [(0+0i) (0-1i) (0+0i)]]

func ZTRMV ¶

func ZTRMV(uplo Uplo, transA Transpose, diag Diag, A [][]complex128, X []complex128, incX int)

Triangular matrix-vector multiplication plus vector with optional matrix transpose. With uplo == Upper or Lower, the upper or lower triangular part of A is used. diag specifies whether the matrix is unit triangular (). When transA == NoTrans this computes:

X = A*X

When transA == Trans this computes:

X = (A^T)*X

Every incX'th element of X is used. Matrices must be allocated with MakeComplex128Matrix to ensure contiguous underlying storage, otherwise this function may panic or return unexpected results.

A := matrix.MakeComplex128(2, 2)
A[0][0] = 1
A[1][1] = 1

A[0][1] = 2

X := []complex128{-1, 4}
incX := 1

fmt.Println(A, "*", X)
ZTRMV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println("=", X)

Output:

[[(1+0i) (2+0i)] [(0+0i) (1+0i)]] * [(-1+0i) (4+0i)]
= [(7+0i) (4+0i)]

func ZTRSM ¶

func ZTRSM(side Side, uplo Uplo, transA Transpose, diag Diag, alpha complex128, A [][]complex128, B [][]complex128)

Computes the inverse-matrix matrix product

B = alpha op(inv(A))B for Side is Left
B = alpha B op(inv(A)) for Side is Right.

The matrix A is triangular and op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of A is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

alpha := complex128(1)
A := matrix.MakeComplex128(3, 3)
A[1][1] = 1
A[1][2] = complex(0, 1)
B := matrix.MakeComplex128(2, 3)
B[1][2] = 1

ZTRSM(Right, Upper, ConjTrans, Unit, alpha, A, B)
fmt.Println(B)

Output:

[[(0+0i) (0+0i) (0+0i)] [(0+0i) (0+1i) (1+0i)]]

func ZTRSV ¶

func ZTRSV(uplo Uplo, transA Transpose, diag Diag, A [][]complex128, X []complex128, incX int)

Computes

inv(op(A)) x for x

where op(A) = A, A^T, A^H for TransA = NoTrans, Trans, ConjTrans. When Uplo is Upper then the upper triangle of A is used, and when Uplo is Lower then the lower triangle of A is used. If Diag is NonUnit then the diagonal of the matrix is used, but if Diag is Unit then the diagonal elements of the matrix A are taken as unity and are not referenced.

// solve:
//  x - y = 2
//      y = 3
// for x, y:
A := matrix.MakeComplex128(2, 2)
A[0][0] = 1
A[0][1] = -1
A[1][1] = 1
X := []complex128{2, 3}
incX := 1
ZTRSV(Upper, NoTrans, NonUnit, A, X, incX)
fmt.Println(X)

Output:

[(5+0i) (3+0i)]