gonum: gonum.org/v1/gonum/floats Index | Examples | Files

package floats

import "gonum.org/v1/gonum/floats"

Package floats provides a set of helper routines for dealing with slices of float64. 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

Package Files

doc.go floats.go

func Add Uses

func Add(dst, s []float64)

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

Code:

// If one wants to store the result in a
// new container, just make a new slice
s1 := []float64{1, 2, 3, 4}
s2 := []float64{5, 6, 7, 8}
s3 := []float64{1, 1, 1, 1}
dst := make([]float64, len(s1))

AddTo(dst, s1, s2)
Add(dst, s3)

fmt.Println("dst =", dst)
fmt.Println("s1 =", s1)
fmt.Println("s2 =", s2)
fmt.Println("s3 =", s3)

Output:

dst = [7 9 11 13]
s1 = [1 2 3 4]
s2 = [5 6 7 8]
s3 = [1 1 1 1]

Code:

// Adding three slices together. Note that
// the result is stored in the first slice
s1 := []float64{1, 2, 3, 4}
s2 := []float64{5, 6, 7, 8}
s3 := []float64{1, 1, 1, 1}
Add(s1, s2)
Add(s1, s3)

fmt.Println("s1 =", s1)
fmt.Println("s2 =", s2)
fmt.Println("s3 =", s3)

Output:

s1 = [7 9 11 13]
s2 = [5 6 7 8]
s3 = [1 1 1 1]

Code:

// If the lengths of the slices are unknown,
// use Eqlen to check
s1 := []float64{1, 2, 3}
s2 := []float64{5, 6, 7, 8}

eq := EqualLengths(s1, s2)
if eq {
    Add(s1, s2)
} else {
    fmt.Println("Unequal lengths")
}

Output:

Unequal lengths

func AddConst Uses

func AddConst(c float64, dst []float64)

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

Code:

s := []float64{1, -2, 3, -4}
c := 5.0

AddConst(c, s)

fmt.Println("s =", s)

Output:

s = [6 3 8 1]

func AddScaled Uses

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

AddScaled performs dst = dst + alpha * s. It panics if the lengths of dst and s are not equal.

func AddScaledTo Uses

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

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

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

func AddTo Uses

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

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

func Argsort Uses

func Argsort(dst []float64, inds []int)

Argsort sorts the elements of dst while tracking their original order. At the conclusion of Argsort, dst will contain the original elements of dst but sorted in increasing order, and inds will contain the original position of the elements in the slice such that dst[i] = origDst[inds[i]]. It panics if the lengths of dst and inds do not match.

func Count Uses

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

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

func CumProd Uses

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

CumProd finds the cumulative product of the first i elements in s and puts them in place into the ith element of the destination dst. A panic will occur if the lengths of arguments do not match.

At the return of the function, dst[i] = s[i] * s[i-1] * s[i-2] * ...

Code:

s := []float64{1, -2, 3, -4}
dst := make([]float64, len(s))

CumProd(dst, s)

fmt.Println("dst =", dst)
fmt.Println("s =", s)

Output:

dst = [1 -2 -6 24]
s = [1 -2 3 -4]

func CumSum Uses

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

CumSum finds the cumulative sum of the first i elements in s and puts them in place into the ith element of the destination dst. A panic will occur if the lengths of arguments do not match.

At the return of the function, dst[i] = s[i] + s[i-1] + s[i-2] + ...

Code:

s := []float64{1, -2, 3, -4}
dst := make([]float64, len(s))

CumSum(dst, s)

fmt.Println("dst =", dst)
fmt.Println("s =", s)

Output:

dst = [1 -1 2 -2]
s = [1 -2 3 -4]

func Distance Uses

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

Distance computes the L-norm of s - t. See Norm for special cases. A panic will occur if the lengths of s and t do not match.

func Div Uses

func Div(dst, s []float64)

Div performs element-wise division dst / s and stores the value in dst. It panics if the lengths of s and t are not equal.

func DivTo Uses

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

DivTo performs element-wise division s / t and stores the value in dst. It panics if the lengths of s, t, and dst are not equal.

func Dot Uses

func Dot(s1, s2 []float64) float64

Dot computes the dot product of s1 and s2, i.e. sum_{i = 1}^N s1[i]*s2[i]. A panic will occur if lengths of arguments do not match.

func Equal Uses

func Equal(s1, s2 []float64) bool

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

func EqualApprox Uses

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

EqualApprox returns true if 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 Uses

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

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

func EqualLengths Uses

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

EqualLengths returns true if all of the slices have equal length, and false otherwise. Returns true if there are no input slices.

func EqualWithinAbs Uses

func EqualWithinAbs(a, b, tol float64) bool

EqualWithinAbs returns true if a and b have an absolute difference of less than tol.

func EqualWithinAbsOrRel Uses

func EqualWithinAbsOrRel(a, b, absTol, relTol float64) bool

EqualWithinAbsOrRel returns true if a and b are equal to within the absolute tolerance.

func EqualWithinRel Uses

func EqualWithinRel(a, b, tol float64) bool

EqualWithinRel returns true if the difference between a and b is not greater than tol times the greater value.

func EqualWithinULP Uses

func EqualWithinULP(a, b float64, ulp uint) bool

EqualWithinULP returns true if a and b are equal to within the specified number of floating point units in the last place.

func Find Uses

func Find(inds []int, f func(float64) bool, s []float64, 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 Uses

func HasNaN(s []float64) bool

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

func LogSpan Uses

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

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 LogSumExp Uses

func LogSumExp(s []float64) float64

LogSumExp returns the log of the sum of the exponentials of the values in s. Panics if s is an empty slice.

func Max Uses

func Max(s []float64) float64

Max returns the maximum value in the input slice. If the slice is empty, Max will panic.

func MaxIdx Uses

func MaxIdx(s []float64) int

MaxIdx returns the index of the maximum value in the input slice. If several entries have the maximum value, the first such index is returned. If the slice is empty, MaxIdx will panic.

func Min Uses

func Min(s []float64) float64

Min returns the maximum value in the input slice. If the slice is empty, Min will panic.

func MinIdx Uses

func MinIdx(s []float64) int

MinIdx returns the index of the minimum value in the input slice. If several entries have the maximum value, the first such index is returned. If the slice is empty, MinIdx will panic.

func Mul Uses

func Mul(dst, s []float64)

Mul performs element-wise multiplication between dst and s and stores the value in dst. Panics if the lengths of s and t are not equal.

func MulTo Uses

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

MulTo performs element-wise multiplication between s and t and stores the value in dst. Panics if the lengths of s, t, and dst are not equal.

func NaNPayload Uses

func NaNPayload(f float64) (payload uint64, ok bool)

NaNPayload returns the lowest 51 bits payload of an IEEE 754 "quiet not-a-number". For values of f other than quiet-NaN, NaNPayload returns zero and false.

func NaNWith Uses

func NaNWith(payload uint64) float64

NaNWith returns an IEEE 754 "quiet not-a-number" value with the payload specified in the low 51 bits of payload. The NaN returned by math.NaN has a bit pattern equal to NaNWith(1).

func NearestIdx Uses

func NearestIdx(s []float64, v float64) 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. NearestIdx panics if len(s) == 0.

func NearestIdxForSpan Uses

func NearestIdxForSpan(n int, l, u float64, v float64) int

NearestIdxForSpan return the index of a hypothetical vector created by Span with length n and bounds l and u whose value is closest to v. That is, NearestIdxForSpan(n, l, u, v) is equivalent to Nearest(Span(make([]float64, n),l,u),v) without an allocation. NearestIdxForSpan panics if n is less than two.

func Norm Uses

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

Norm returns the L norm of the slice S, defined as (sum_{i=1}^N 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 ParseWithNA Uses

func ParseWithNA(s, missing string) (v, w float64, err error)

ParseWithNA converts the string s to a float64 in v. If s equals missing, w is returned as 0, otherwise 1.

Code:

// Calculate the mean of a list of numbers
// ignoring missing values.
const data = `6
missing
4
`

var vals, weights []float64
sc := bufio.NewScanner(strings.NewReader(data))
for sc.Scan() {
    v, w, err := floats.ParseWithNA(sc.Text(), "missing")
    if err != nil {
        log.Fatal(err)
    }
    vals = append(vals, v)
    weights = append(weights, w)
}
err := sc.Err()
if err != nil {
    log.Fatal(err)
}
fmt.Println(stat.Mean(vals, weights))

Output:

5

func Prod Uses

func Prod(s []float64) float64

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

func Reverse Uses

func Reverse(s []float64)

Reverse reverses the order of elements in the slice.

func Round Uses

func Round(x float64, prec int) float64

Round returns the half away from zero rounded value of x with prec precision.

Special cases are:

Round(±0) = +0
Round(±Inf) = ±Inf
Round(NaN) = NaN

func RoundEven Uses

func RoundEven(x float64, prec int) float64

RoundEven returns the half even rounded value of x with prec precision.

Special cases are:

RoundEven(±0) = +0
RoundEven(±Inf) = ±Inf
RoundEven(NaN) = NaN

func Same Uses

func Same(s, t []float64) bool

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

func Scale Uses

func Scale(c float64, dst []float64)

Scale multiplies every element in dst by the scalar c.

func ScaleTo Uses

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

ScaleTo multiplies the elements in s by c and stores the result in dst.

func Span Uses

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

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.

Panics if len(dst) < 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 Uses

func Sub(dst, s []float64)

Sub subtracts, element-wise, the elements of s from dst. Panics if the lengths of dst and s do not match.

func SubTo Uses

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

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

func Sum Uses

func Sum(s []float64) float64

Sum returns the sum of the elements of the slice.

func Within Uses

func Within(s []float64, v float64) int

Within returns the first index i where s[i] <= v < s[i+1]. Within panics if:

- len(s) < 2
- s is not sorted

Package floats imports 5 packages (graph) and is imported by 110 packages. Updated 2019-10-26. Refresh now. Tools for package owners.