Documentation

Overview

    Package c64 provides complex64 vector primitives.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

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

                                                    Types

                                                    This section is empty.