gonum: gonum.org/v1/gonum/internal/asm/c64 Index | Files

package c64

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

Package c64 provides complex64 vector primitives.

Index

Package Files

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

func AxpyInc Uses

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 Uses

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 Uses

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

AxpyUnitary is

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

func AxpyUnitaryTo Uses

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

AxpyUnitaryTo is

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

func DotcInc Uses

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 Uses

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

DotcUnitary is

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

func DotuInc Uses

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 Uses

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

DotuUnitary is

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

func ScalInc Uses

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 Uses

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 Uses

func ScalUnitary(alpha complex64, x []complex64)

ScalUnitary is

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

func ScalUnitaryTo Uses

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

ScalUnitaryTo is

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

func SscalInc Uses

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 Uses

func SscalUnitary(alpha float32, x []complex64)

SscalUnitary is

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

Package c64 is imported by 1 packages. Updated 2019-04-06. Refresh now. Tools for package owners.