README

Gonum cmplxs GoDoc

Package cmplxs provides a set of helper routines for dealing with slices of complex128. The functions avoid allocations to allow for use within tight loops without garbage collection overhead.

Expand ▾ Collapse ▴

Documentation

Overview

    Package cmplxs provides a set of helper routines for dealing with slices of complex128. The functions avoid allocations to allow for use within tight loops without garbage collection overhead.

    The convention used is that when a slice is being modified in place, it has the name dst.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func Abs

    func Abs(dst []float64, s []complex128)

      Abs calculates the absolute values of the elements of s, and stores them in dst. It panics if the argument lengths do not match.

      func Add

      func Add(dst, s []complex128)

        Add adds, element-wise, the elements of s and dst, and stores the result in dst. It panics if the argument lengths do not match.

        Example (Newslice)
        Output:
        
        dst = [(7+10i) (9+11i) (11+12i) (13+14i)]
        s1 = [(1+1i) (2+2i) (3+3i) (4+4i)]
        s2 = [(5+7i) (6+7i) (7+7i) (8+8i)]
        s3 = [(1+2i) (1+2i) (1+2i) (1+2i)]
        
        Example (Simple)
        Output:
        
        s1 = [(7+10i) (9+11i) (11+12i) (13+14i)]
        s2 = [(5+7i) (6+7i) (7+7i) (8+8i)]
        s3 = [(1+2i) (1+2i) (1+2i) (1+2i)]
        
        Example (Unequallengths)
        Output:
        
        Unequal lengths
        

        func AddConst

        func AddConst(c complex128, dst []complex128)

          AddConst adds the scalar c to all of the values in dst.

          Example
          Output:
          
          s = [(6+0i) (3+0i) (8+0i) (1+0i)]
          

          func AddScaled

          func AddScaled(dst []complex128, alpha complex128, s []complex128)

            AddScaled performs dst = dst + alpha * s. It panics if the slice argument lengths do not match.

            func AddScaledTo

            func AddScaledTo(dst, y []complex128, alpha complex128, s []complex128) []complex128

              AddScaledTo performs dst = y + alpha * s, where alpha is a scalar, and dst, y and s are all slices. It panics if the slice argument lengths do not match.

              At the return of the function, dst[i] = y[i] + alpha * s[i]

              func AddTo

              func AddTo(dst, s, t []complex128) []complex128

                AddTo adds, element-wise, the elements of s and t and stores the result in dst. It panics if the argument lengths do not match.

                func Complex

                func Complex(dst []complex128, real, imag []float64) []complex128

                  Complex fills each of the elements of dst with the complex number constructed from the corresponding elements of real and imag. It panics if the argument lengths do not match.

                  func Count

                  func Count(f func(complex128) bool, s []complex128) int

                    Count applies the function f to every element of s and returns the number of times the function returned true.

                    func CumProd

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

                      CumProd finds the cumulative product of elements of s and store it in place into dst so that

                      dst[i] = s[i] * s[i-1] * s[i-2] * ... * s[0]
                      

                      It panics if the argument lengths do not match.

                      Example
                      Output:
                      
                      dst = [(1+1i) (0-4i) (12-12i) (-96+0i)]
                      s = [(1+1i) (-2-2i) (3+3i) (-4-4i)]
                      

                      func CumSum

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

                        CumSum finds the cumulative sum of elements of s and stores it in place into dst so that

                        dst[i] = s[i] + s[i-1] + s[i-2] + ... + s[0]
                        

                        It panics if the argument lengths do not match.

                        Example
                        Output:
                        
                        dst = [(1+1i) (-1-1i) (2+2i) (-2-2i)]
                        s = [(1+1i) (-2-2i) (3+3i) (-4-4i)]
                        

                        func Distance

                        func Distance(s, t []complex128, L float64) float64

                          Distance computes the L-norm of s - t. See Norm for special cases. It panics if the slice argument lengths do not match.

                          func Div

                          func Div(dst, s []complex128)

                            Div performs element-wise division dst / s and stores the result in dst. It panics if the argument lengths do not match.

                            func DivTo

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

                              DivTo performs element-wise division s / t and stores the result in dst. It panics if the argument lengths do not match.

                              func Dot

                              func Dot(s1, s2 []complex128) complex128

                                Dot computes the dot product of s1 and s2, i.e. sum_{i = 1}^N conj(s1[i])*s2[i]. It panics if the argument lengths do not match.

                                func Equal

                                func Equal(s1, s2 []complex128) bool

                                  Equal returns true when the slices have equal lengths and all elements are numerically identical.

                                  func EqualApprox

                                  func EqualApprox(s1, s2 []complex128, tol float64) bool

                                    EqualApprox returns true when the slices have equal lengths and all element pairs have an absolute tolerance less than tol or a relative tolerance less than tol.

                                    func EqualFunc

                                    func EqualFunc(s1, s2 []complex128, f func(complex128, complex128) bool) bool

                                      EqualFunc returns true when the slices have the same lengths and the function returns true for all element pairs.

                                      func EqualLengths

                                      func EqualLengths(slices ...[]complex128) bool

                                        EqualLengths returns true when all of the slices have equal length, and false otherwise. It also eturns true when there are no input slices.

                                        func Find

                                        func Find(inds []int, f func(complex128) bool, s []complex128, k int) ([]int, error)

                                          Find applies f to every element of s and returns the indices of the first k elements for which the f returns true, or all such elements if k < 0. Find will reslice inds to have 0 length, and will append found indices to inds. If k > 0 and there are fewer than k elements in s satisfying f, all of the found elements will be returned along with an error. At the return of the function, the input inds will be in an undetermined state.

                                          func HasNaN

                                          func HasNaN(s []complex128) bool

                                            HasNaN returns true when the slice s has any values that are NaN and false otherwise.

                                            func Imag

                                            func Imag(dst []float64, src []complex128) []float64

                                              Imag places the imaginary components of src into dst. It panics if the argument lengths do not match.

                                              func LogSpan

                                              func LogSpan(dst []complex128, l, u complex128) []complex128

                                                LogSpan returns a set of n equally spaced points in log space between, l and u where N is equal to len(dst). The first element of the resulting dst will be l and the final element of dst will be u. Panics if len(dst) < 2 Note that this call will return NaNs if either l or u are negative, and will return all zeros if l or u is zero. Also returns the mutated slice dst, so that it can be used in range, like:

                                                for i, x := range LogSpan(dst, l, u) { ... }
                                                

                                                func MaxAbs

                                                func MaxAbs(s []complex128) complex128

                                                  MaxAbs returns the maximum absolute value in the input slice. It panics if s is zero length.

                                                  func MaxAbsIdx

                                                  func MaxAbsIdx(s []complex128) int

                                                    MaxAbsIdx returns the index of the maximum absolute value in the input slice. If several entries have the maximum absolute value, the first such index is returned. It panics if s is zero length.

                                                    func MinAbs

                                                    func MinAbs(s []complex128) complex128

                                                      MinAbs returns the minimum absolute value in the input slice. It panics if s is zero length.

                                                      func MinAbsIdx

                                                      func MinAbsIdx(s []complex128) int

                                                        MinAbsIdx returns the index of the minimum absolute value in the input slice. If several entries have the minimum absolute value, the first such index is returned. It panics if s is zero length.

                                                        func Mul

                                                        func Mul(dst, s []complex128)

                                                          Mul performs element-wise multiplication between dst and s and stores the result in dst. It panics if the argument lengths do not match.

                                                          func MulTo

                                                          func MulTo(dst, s, t []complex128) []complex128

                                                            MulTo performs element-wise multiplication between s and t and stores the result in dst. It panics if the argument lengths do not match.

                                                            func NearestIdx

                                                            func NearestIdx(s []complex128, v complex128) int

                                                              NearestIdx returns the index of the element in s whose value is nearest to v. If several such elements exist, the lowest index is returned. It panics if s is zero length.

                                                              func Norm

                                                              func Norm(s []complex128, L float64) float64

                                                                Norm returns the L-norm of the slice S, defined as (sum_{i=1}^N abs(s[i])^L)^{1/L} Special cases: L = math.Inf(1) gives the maximum absolute value. Does not correctly compute the zero norm (use Count).

                                                                func Prod

                                                                func Prod(s []complex128) complex128

                                                                  Prod returns the product of the elements of the slice. Returns 1 if len(s) = 0.

                                                                  func Real

                                                                  func Real(dst []float64, src []complex128) []float64

                                                                    Real places the real components of src into dst. It panics if the argument lengths do not match.

                                                                    func Reverse

                                                                    func Reverse(s []complex128)

                                                                      Reverse reverses the order of elements in the slice.

                                                                      func Same

                                                                      func Same(s, t []complex128) bool

                                                                        Same returns true when the input slices have the same length and all elements have the same value with NaN treated as the same.

                                                                        func Scale

                                                                        func Scale(c complex128, dst []complex128)

                                                                          Scale multiplies every element in dst by the scalar c.

                                                                          func ScaleTo

                                                                          func ScaleTo(dst []complex128, c complex128, s []complex128) []complex128

                                                                            ScaleTo multiplies the elements in s by c and stores the result in dst. It panics if the slice argument lengths do not match.

                                                                            func Span

                                                                            func Span(dst []complex128, l, u complex128) []complex128

                                                                              Span returns a set of N equally spaced points between l and u, where N is equal to the length of the destination. The first element of the destination is l, the final element of the destination is u. It panics if the length of dst is less than 2.

                                                                              Span also returns the mutated slice dst, so that it can be used in range expressions, like:

                                                                              for i, x := range Span(dst, l, u) { ... }
                                                                              

                                                                              func Sub

                                                                              func Sub(dst, s []complex128)

                                                                                Sub subtracts, element-wise, the elements of s from dst. It panics if the argument lengths do not match.

                                                                                func SubTo

                                                                                func SubTo(dst, s, t []complex128) []complex128

                                                                                  SubTo subtracts, element-wise, the elements of t from s and stores the result in dst. It panics if the argument lengths do not match.

                                                                                  func Sum

                                                                                  func Sum(s []complex128) complex128

                                                                                    Sum returns the sum of the elements of the slice.

                                                                                    Types

                                                                                    This section is empty.

                                                                                    Source Files

                                                                                    Directories

                                                                                    Path Synopsis
                                                                                    Package cscalar provides a set of helper routines for dealing with complex128 values.
                                                                                    Package cscalar provides a set of helper routines for dealing with complex128 values.