Back to godoc.org
gorgonia.org/vecf64

Package vecf64

v0.9.0
Latest Go to latest

The highest tagged major version is .

Published: Sep 4, 2019 | License: MIT | Module: gorgonia.org/vecf64

Overview

Package vecf64 provides common functions and methods for slices of float64.

Name

In the days of yore, scientists who computed with computers would use arrays to represent vectors, each value representing magnitude and/or direction. Then came the C++ Standard Templates Library, which sought to provide this data type in the standard library. Now, everyone conflates a term "vector" with dynamic arrays.

In the C++ book, Bjarne Stroustrup has this to say:

One could argue that valarray should have been called vector because is is a traditional mathematical vector
and that vector should have been called array.
However, this is not the way that the terminology evolved.
A valarray is a vector optimized for numeric computation;
a vector is a flexible container designed for holding and manipulating objects of a wide variety of types;
and an array is a low-level built-in type

Go has a better name for representing dynamically allocated arrays of any type - "slice". However, "slice" is both a noun and verb and many libraries that I use already use "slice"-as-a-verb as a name, so I had to settle for the second best name: "vector".

It should be noted that while the names used in this package were definitely mathematically inspired, they bear only little resemblance the actual mathematical operations performed.

Naming Convention

The names of the operations assume you're working with slices of float64s. Hence `Add` performs elementwise addition between two []float64.

Operations between []float64 and float64 are also supported, however they are differently named. Here are the equivalents:

+------------------------+--------------------------------------+
| []float64-[]float64 Op |         []float64-float64 Op         |
+------------------------+--------------------------------------+
| Add(a, b []float64)    | Trans(a float64, b []float64)        |
| Sub(a, b []float64)    | Trans/TransR(a float64, b []float64) |
| Mul(a, b []float64)    | Scale(a float64, b []float64)        |
| Div(a, b []float64)    | Scale/DivR(a float64, b []float64)   |
| Pow(a, b []float64)    | PowOf/PowOfR(a float64, b []float64) |
+------------------------+--------------------------------------+

You may note that for the []float64 - float64 binary operations, the scalar (float64) is always the first operand. In operations that are not commutative, an additional function is provided, suffixed with "R" (for reverse)

Range Check and BCE

This package does not provide range checking. If indices are out of range, the functions will panic. This package should play well with BCE.

TODO: provide SIMD vectorization for Incr and []float32-float64 functions. Pull requests accepted

Index

func Add

func Add(a, b []float64)

Add performs a̅ + b̅. a̅ will be clobbered

func Argmax

func Argmax(a []float64) int

Argmax returns the index of the min in a slice

func Argmin

func Argmin(a []float64) int

Argmin returns the index of the min in a slice

func Div

func Div(a, b []float64)

Div performs a̅ ÷ b̅. a̅ will be clobbered

func IncrAdd

func IncrAdd(a, b, incr []float64)

IncrAdd performs a̅ + b̅ and then adds it elementwise to the incr slice

func IncrDiv

func IncrDiv(a, b, incr []float64)

func IncrMod

func IncrMod(a, b, incr []float64)

IncrMod performs a̅ % b̅ then adds it to incr

func IncrMul

func IncrMul(a, b, incr []float64)

IncrMul performs a̅ × b̅ and then adds it elementwise to the incr slice

func IncrPow

func IncrPow(a, b, incr []float64)

IncrDiv performs a̅ ÷ b̅. a̅ will be clobbered

func IncrPowOf

func IncrPowOf(a []float64, s float64, incr []float64)

IncrPowOf performs elementwise power function and then increments the incr slice

incr += a̅ ^ s

func IncrPowOfR

func IncrPowOfR(a []float64, s float64, incr []float64)

PowOfR performs elementwise power function below and then increments the incr slice.

incr += s ^ a̅

func IncrScale

func IncrScale(a []float64, s float64, incr []float64)

Scale multiplies all values in the slice by the scalar and then increments the incr slice

incr += a̅ * s

func IncrScaleInv

func IncrScaleInv(a []float64, s float64, incr []float64)

IncrScaleInv divides all values in the slice by the scalar and then increments the incr slice

incr += a̅ / s

func IncrScaleInvR

func IncrScaleInvR(a []float64, s float64, incr []float64)

/ IncrScaleInvR divides all numbers in the slice by a scalar and then increments the incr slice

incr += s / a̅

func IncrSub

func IncrSub(a, b, incr []float64)

IncrSub performs a̅ = b̅ and then adds it elementwise to the incr slice

func IncrTrans

func IncrTrans(a []float64, s float64, incr []float64)

IncrTrans adds all the values in the slice by a scalar and then increments the incr slice

incr += a̅ + s

func IncrTransInv

func IncrTransInv(a []float64, s float64, incr []float64)

IncrTransInv subtracts all the values in the slice by a scalar and then increments the incr slice

incr += a̅ - s

func IncrTransInvR

func IncrTransInvR(a []float64, s float64, incr []float64)

IncrTransInvR subtracts all the numbers in a slice from a scalar and then increments the incr slice

incr += s - a̅

func InvSqrt

func InvSqrt(a []float64)

InvSqrt performs 1/√a̅ elementwise. a̅ will be clobbered

func Max

func Max(a, b []float64)

Max takes two slices, a̅ + b̅, and compares them elementwise. The highest value is put into a̅.

func MaxOf

func MaxOf(a []float64) (retVal float64)

MaxOf finds the max of a []float64. it panics if the slice is empty

func Min

func Min(a, b []float64)

Min takes two slices, a̅ + b̅ and compares them elementwise. The lowest value is put into a̅.

func MinOf

func MinOf(a []float64) (retVal float64)

MinOf finds the max of a []float64. it panics if the slice is empty

func Mod

func Mod(a, b []float64)

func Mul

func Mul(a, b []float64)

Mul performs a̅ × b̅. a̅ will be clobbered

func Pow

func Pow(a, b []float64)

Pow performs elementwise

a̅ ^ b̅

func PowOf

func PowOf(a []float64, s float64)

PowOf performs elementwise

a̅ ^ s

func PowOfR

func PowOfR(a []float64, s float64)

PowOfR performs elementwise

s ^ a̅

func Range

func Range(start, end int) []float64

Range is a function to create arithmetic progressions of float32

func Reduce

func Reduce(f func(a, b float64) float64, def float64, l ...float64) (retVal float64)

Reduce takes a function to reduce by, a defalut, and a splatted list of float64s

func Scale

func Scale(a []float64, s float64)

Scale multiplies all values in the slice by the scalar. It performs elementwise

a̅ * s

func ScaleInv

func ScaleInv(a []float64, s float64)

ScaleInv divides all values in the slice by the scalar. It performs elementwise

a̅ / s

func ScaleInvR

func ScaleInvR(a []float64, s float64)

/ ScaleInvR divides all numbers in the slice by a scalar

s / a̅

func Sqrt

func Sqrt(a []float64)

Sqrt performs √a̅ elementwise. a̅ will be clobbered

func Sub

func Sub(a, b []float64)

Sub performs a̅ - b̅. a̅ will be clobbered

func Sum

func Sum(a []float64) float64

Sum sums a slice of float64 and returns a float64

func Trans

func Trans(a []float64, s float64)

Trans adds all the values in the slice by a scalar

a̅ + s

func TransInv

func TransInv(a []float64, s float64)

TransInv subtracts all the values in the slice by a scalar

a̅ - s

func TransInvR

func TransInvR(a []float64, s float64)

TransInvR subtracts all the numbers in a slice from a scalar

s - a̅
Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier