package c64

import "gonum.org/v1/gonum/internal/asm/c64"

Package c64 provides complex64 vector primitives.

Index

Functions

func Add 

func Add(dst, s []complex64)

Add is 

for i, v := range s {
	dst[i] += v
}

func AddConst 

func AddConst(alpha complex64, x []complex64)

AddConst is 

for i := range x {
	x[i] += alpha
}

func AxpyInc 

func AxpyInc(alpha complex64, x, y []complex64, n, incX, incY, ix, iy uintptr)

AxpyInc is 

for i := 0; i < int(n); i++ {
	y[iy] += alpha * x[ix]
	ix += incX
	iy += incY
}

func AxpyIncTo 

func AxpyIncTo(dst []complex64, incDst, idst uintptr, alpha complex64, x, y []complex64, n, incX, incY, ix, iy uintptr)

AxpyIncTo is 

for i := 0; i < int(n); i++ {
	dst[idst] = alpha*x[ix] + y[iy]
	ix += incX
	iy += incY
	idst += incDst
}

func AxpyUnitary 

func AxpyUnitary(alpha complex64, x, y []complex64)

AxpyUnitary is 

for i, v := range x {
	y[i] += alpha * v
}

func AxpyUnitaryTo 

func AxpyUnitaryTo(dst []complex64, alpha complex64, x, y []complex64)

AxpyUnitaryTo is 

for i, v := range x {
	dst[i] = alpha*v + y[i]
}

func CumProd 

func CumProd(dst, s []complex64) []complex64

CumProd is 

if len(s) == 0 {
	return dst
}
dst[0] = s[0]
for i, v := range s[1:] {
	dst[i+1] = dst[i] * v
}
return dst

func CumSum 

func CumSum(dst, s []complex64) []complex64

CumSum is 

if len(s) == 0 {
	return dst
}
dst[0] = s[0]
for i, v := range s[1:] {
	dst[i+1] = dst[i] + v
}
return dst

func Div 

func Div(dst, s []complex64)

Div is 

for i, v := range s {
	dst[i] /= v
}

func DivTo 

func DivTo(dst, s, t []complex64) []complex64

DivTo is 

for i, v := range s {
	dst[i] = v / t[i]
}
return dst

func DotUnitary 

func DotUnitary(x, y []complex64) (sum complex64)

DotUnitary is 

for i, v := range x {
	sum += conj(v) * y[i]
}
return sum

func DotcInc 

func DotcInc(x, y []complex64, n, incX, incY, ix, iy uintptr) (sum complex64)

DotcInc is 

for i := 0; i < int(n); i++ {
	sum += y[iy] * conj(x[ix])
	ix += incX
	iy += incY
}
return sum

func DotcUnitary 

func DotcUnitary(x, y []complex64) (sum complex64)

DotcUnitary is 

for i, v := range x {
	sum += y[i] * conj(v)
}
return sum

func DotuInc 

func DotuInc(x, y []complex64, n, incX, incY, ix, iy uintptr) (sum complex64)

DotuInc is 

for i := 0; i < int(n); i++ {
	sum += y[iy] * x[ix]
	ix += incX
	iy += incY
}
return sum

func DotuUnitary 

func DotuUnitary(x, y []complex64) (sum complex64)

DotuUnitary is 

for i, v := range x {
	sum += y[i] * v
}
return sum

func L2DistanceUnitary 

func L2DistanceUnitary(x, y []complex64) (norm float32)

L2DistanceUnitary returns the L2-norm of x-y.

func L2NormUnitary 

func L2NormUnitary(x []complex64) (norm float32)

L2NormUnitary returns the L2-norm of x.

func ScalInc 

func ScalInc(alpha complex64, x []complex64, n, incX uintptr)

ScalInc is 

var ix uintptr
for i := 0; i < int(n); i++ {
	x[ix] *= alpha
	ix += incX
}

func ScalIncTo 

func ScalIncTo(dst []complex64, incDst uintptr, alpha complex64, x []complex64, n, incX uintptr)

ScalIncTo is 

var idst, ix uintptr
for i := 0; i < int(n); i++ {
	dst[idst] = alpha * x[ix]
	ix += incX
	idst += incDst
}

func ScalUnitary 

func ScalUnitary(alpha complex64, x []complex64)

ScalUnitary is 

for i := range x {
	x[i] *= alpha
}

func ScalUnitaryTo 

func ScalUnitaryTo(dst []complex64, alpha complex64, x []complex64)

ScalUnitaryTo is 

for i, v := range x {
	dst[i] = alpha * v
}

func SscalInc 

func SscalInc(alpha float32, x []complex64, n, inc uintptr)

SscalInc is 

var ix uintptr
for i := 0; i < int(n); i++ {
	x[ix] = complex(real(x[ix])*alpha, imag(x[ix])*alpha)
	ix += inc
}

func SscalUnitary 

func SscalUnitary(alpha float32, x []complex64)

SscalUnitary is 

for i, v := range x {
	x[i] = complex(real(v)*alpha, imag(v)*alpha)
}

func Sum 

func Sum(x []complex64) complex64

Sum is 

var sum complex64
for i := range x {
    sum += x[i]
}

Source Files

conj.go doc.go scal.go stubs.go stubs_amd64.go

Version
v0.15.1 (latest)
Published
Aug 16, 2024
Platform
linux/amd64
Imports
2 packages
Last checked
1 day ago –

Tools for package owners.