// Makes a copy of A and for all elements pointed by the element of the indexes array
// calculates fn(A[k], values[i]) where k is the i'th value in the indexes array.
func ApplyConstValues(A *matrix.ComplexMatrix, values []complex128, fn func(complex128, complex128) complex128, indexes []int) *matrix.ComplexMatrix {
if A == nil {
return A
}
C := A.Copy()
return C.ApplyConstValues(values, fn, indexes)
}
// Make a copy C of A and apply function fn element wise to C.
// For indexes is not empty then C[indexes[i]] = fn(C[indexes[i]], x).
// Returns a new matrix.
func ApplyConst(A *matrix.ComplexMatrix, x complex128, fn func(complex128, complex128) complex128, indexes ...int) *matrix.ComplexMatrix {
if A == nil {
return nil
}
C := A.Copy()
return C.ApplyConst(x, fn, indexes...)
}
// Return Imag(A).
func Imag(A *matrix.ComplexMatrix) *matrix.FloatMatrix {
C := matrix.FloatZeros(A.Size())
Ar := A.ComplexArray()
Cr := C.FloatArray()
for i, v := range Ar {
Cr[i] = imag(v)
}
return C
}
// See function Asum.
func AsumComplex(X *matrix.ComplexMatrix, opts ...linalg.Option) (v float64, err error) {
v = 0.0
ind := linalg.GetIndexOpts(opts...)
err = check_level1_func(ind, fasum, X, nil)
if err != nil {
return
}
if ind.Nx == 0 {
return
}
Xa := X.ComplexArray()
v = dzasum(ind.Nx, Xa[ind.OffsetX:], ind.IncX)
return
}
// See function Dotc.
func DotcComplex(X, Y *matrix.ComplexMatrix, opts ...linalg.Option) (v complex128, err error) {
v = 0.0
ind := linalg.GetIndexOpts(opts...)
err = check_level1_func(ind, fdot, X, Y)
if err != nil {
return
}
if ind.Nx == 0 {
return
}
Xa := X.ComplexArray()
Ya := Y.ComplexArray()
v = zdotc(ind.Nx, Xa[ind.OffsetX:], ind.IncX, Ya[ind.OffsetY:], ind.IncY)
return
}
// Make copy C of A and compute C[indexes[i]] += values[i]. Indexes are in column-major order.
// Returns a new matrix.
func AddAt(A *matrix.ComplexMatrix, values []complex128, indexes []int) *matrix.ComplexMatrix {
C := A.Copy()
if len(indexes) == 0 {
return C
}
Cr := C.ComplexArray()
N := A.NumElements()
for i, k := range indexes {
if i >= len(values) {
return C
}
if k < 0 {
k = N + k
}
Cr[k] += values[i]
}
return C
}
// Compute element-wise product C[i,j] = A[i,j] * B[i,j]. Returns new matrix.
func Mul(A, B *matrix.ComplexMatrix) *matrix.ComplexMatrix {
if !A.SizeMatch(B.Size()) {
return nil
}
C := A.Copy()
return C.Mul(B)
}
// Compute Abs(A), Returns a new float valued matrix.
func Abs(A *matrix.ComplexMatrix) *matrix.FloatMatrix {
C := matrix.FloatZeros(A.Rows(), A.Cols())
Cr := C.FloatArray()
Ar := A.ComplexArray()
for k, v := range Ar {
Cr[k] = cmplx.Abs(v)
}
return C
}
// Make a copy C of A and compute C += alpha for all elements in the matrix if list of indexes
// is empty. Otherwise compute C[i] += alpha for indexes in column-major order.
func Add(A *matrix.ComplexMatrix, alpha complex128, indexes ...int) *matrix.ComplexMatrix {
C := A.Copy()
return C.Add(alpha, indexes...)
}
// Make a copy C of A and compute inverse C[i] = 1.0/C[i]. If indexes is empty calculates for
// all elements. Returns a new matrix.
func Inv(A *matrix.ComplexMatrix, indexes ...int) *matrix.ComplexMatrix {
C := A.Copy()
return C.Inv()
}
// Compute matrix product C = A * B where A is m*p and B is p*n.
// Returns a new m*n matrix.
func Times(A, B *matrix.ComplexMatrix) *matrix.ComplexMatrix {
if A.Cols() != B.Rows() {
return nil
}
return A.Times(B)
}
