math

package

v0.0.0-...-b3872f7 Latest Latest Go to latest Published: Nov 20, 2021 License: MIT Imports: 5 Imported by: 2

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/spatialcurrent/go-math

Links

Open Source Insights

Documentation ¶

Overview ¶

Package math provides math functions that support varied types, but tries to preserve the original type if possible. For example, you can sum a slice of ints and floats.

Index ¶

Variables
func Add(a interface{}, b interface{}) (interface{}, error)
func Compare(a interface{}, b interface{}) (int, error)
func Divide(a interface{}, b interface{}) (out interface{}, err error)
func Max(in interface{}) (interface{}, error)
func Mean(in interface{}) (interface{}, error)
func Min(in interface{}) (interface{}, error)
func Multiply(a interface{}, b interface{}) (interface{}, error)
func Pow(a interface{}, b interface{}) (out interface{}, err error)
func Product(in interface{}) (interface{}, error)
func Subtract(a interface{}, b interface{}) (interface{}, error)
func Sum(in interface{}) (interface{}, error)
type ErrInvalidAddition
- func (e ErrInvalidAddition) Error() string
type ErrInvalidComparison
- func (e ErrInvalidComparison) Error() string
type ErrInvalidDivision
- func (e ErrInvalidDivision) Error() string
type ErrInvalidKind
- func (e ErrInvalidKind) Error() string
type ErrInvalidMultiplication
- func (e ErrInvalidMultiplication) Error() string
type ErrInvalidPower
- func (e ErrInvalidPower) Error() string
type ErrInvalidSubtraction
- func (e ErrInvalidSubtraction) Error() string

Examples ¶

Add (Durations)
Add (Floats)
Add (Int32s)
Add (Int64s)
Add (Ints)
Add (UInt8s)
Compare (Durations)
Compare (Floats)
Compare (Int32s)
Compare (Int64s)
Compare (Ints)
Compare (Times)
Compare (UInt8s)
Divide (DurationInt)
Divide (Durations)
Divide (Floats)
Divide (Int32s)
Divide (Int64s)
Divide (Ints)
Divide (UInt8s)
Max (Durations)
Max (Floats)
Max (Interface)
Max (Ints)
Max (Times)
Max (Uint8s)
Mean (Durations)
Mean (Floats)
Mean (Interface)
Mean (Ints)
Mean (Uint8s)
Min (Durations)
Min (Floats)
Min (Interface)
Min (Ints)
Min (Times)
Min (Uint8s)
Multiply (DurationFloat)
Multiply (DurationInt)
Multiply (Floats)
Multiply (Int32s)
Multiply (Int64s)
Multiply (Ints)
Multiply (UInt8s)
Pow (Floats)
Pow (Int32s)
Pow (Int64s)
Pow (Ints)
Pow (UInt8s)
Product (Duration)
Product (Floats)
Product (Interface)
Product (Ints)
Product (Uint8s)
Subtract (Durations)
Subtract (Floats)
Subtract (Int32s)
Subtract (Int64s)
Subtract (Ints)
Subtract (TimeDuration)
Subtract (UInt8s)
Sum (Durations)
Sum (Floats)
Sum (Interface)
Sum (Ints)
Sum (Uint8s)

Constants ¶

This section is empty.

Variables ¶

View Source

var (
	ErrEmptyInput = errors.New("empty input")
)

Functions ¶

func Add ¶

func Add(a interface{}, b interface{}) (interface{}, error)

Add adds 2 values together while following a few simple rules to convert integers and floats. Supports types uint8, int32, int64, int, float64, and time.Duration. Returns an error if the values cannot be added.

Example (Durations) ¶

out, err := Add(time.Hour*1, time.Hour*2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3h0m0s

Example (Floats) ¶

out, err := Add(1.11, 2.22)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3.33

Example (Int32s) ¶

out, err := Add(int32(1), int32(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3

Example (Int64s) ¶

out, err := Add(int64(1), int64(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3

Example (Ints) ¶

out, err := Add(1, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3

Example (UInt8s) ¶

out, err := Add(uint8(1), uint8(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3

func Compare ¶

func Compare(a interface{}, b interface{}) (int, error)

Compare compares 2 values and follows a few simple rules to compare integers and floats. Supports types uint8, int32, int64, int, float64, and time.Time. Returns an error if not comparable. Return value of -1 indicates a is less than b. Return value of 1 indicates a is greater than b. Return value of 0 indicates a is equivalent to b by value.

Example (Durations) ¶

out, err := Compare(time.Hour*1, time.Hour*2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Floats) ¶

out, err := Compare(1.11, 2.22)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Int32s) ¶

out, err := Compare(int32(1), int32(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Int64s) ¶

out, err := Compare(int64(1), int64(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Ints) ¶

out, err := Compare(1, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Times) ¶

now := time.Now()
out, err := Compare(now, now.Add(time.Hour*1))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

Example (UInt8s) ¶

out, err := Compare(uint8(1), uint8(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

func Divide ¶

func Divide(a interface{}, b interface{}) (out interface{}, err error)

Divide divides a by b while following a few simple rules to maximize precision. Rather than truncating integers, this function converts the input to floats if a is not divisible by b.

If integer a is divisible by integer b, then returns an integer.
If integer a is not divisible by integer b, then converts both numbers to floats and returns the remainder.

Supports types uint8, int32, int64, int, float64, and time.Duration. Catches divide by zero panics and returns as errors. Returns an error if a cannot be divided by b.

Example (DurationInt) ¶

out, err := Divide(time.Hour*4, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2h0m0s

Example (Durations) ¶

out, err := Divide(time.Hour*3, time.Hour*2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1.5

Example (Floats) ¶

out, err := Divide(1.11, 2.22)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

0.5

Example (Int32s) ¶

out, err := Divide(int32(1), int32(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

0.5

Example (Int64s) ¶

out, err := Divide(int64(1), int64(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

0.5

Example (Ints) ¶

out, err := Divide(1, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

0.5

Example (UInt8s) ¶

out, err := Divide(uint8(4), uint8(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

func Max ¶

func Max(in interface{}) (interface{}, error)

Max returns the maximum value from the array or slice of durations, floats, ints, and times.

Example (Durations) ¶

out, err := Max([]time.Duration{
	time.Hour * 2,
	time.Hour * 3,
	time.Hour * 1,
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3h0m0s

Example (Floats) ¶

out, err := Max([]float64{1.11, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2.22

Example (Interface) ¶

out, err := Max([]interface{}{10, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

10

Example (Ints) ¶

out, err := Max([]int{10, 20})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

20

Example (Times) ¶

out, err := Max([]time.Time{
	time.Now(),
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

Example (Uint8s) ¶

out, err := Max([]uint8{1, 2, 3})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3

func Mean ¶

func Mean(in interface{}) (interface{}, error)

Mean returns the mean value from the array or slice of ints, floats, or durations. For durations, returns the average duration. For ints and floats, returns a float64.

Example (Durations) ¶

out, err := Mean([]time.Duration{
	time.Hour * 2,
	time.Hour * 1,
	time.Hour * 3,
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2h0m0s

Example (Floats) ¶

out, err := Mean([]float64{1.11, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1.665

Example (Interface) ¶

out, err := Mean([]interface{}{10, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

6.11

Example (Ints) ¶

out, err := Mean([]int{10, 20})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

15

Example (Uint8s) ¶

out, err := Mean([]uint8{1, 2, 3})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

func Min ¶

func Min(in interface{}) (interface{}, error)

Min returns the minimum value from the array or slice of durations, floats, ints, and times.

Example (Durations) ¶

out, err := Min([]time.Duration{
	time.Hour * 2,
	time.Hour * 3,
	time.Hour * 1,
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1h0m0s

Example (Floats) ¶

out, err := Min([]float64{1.11, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1.11

Example (Interface) ¶

out, err := Min([]interface{}{10, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2.22

Example (Ints) ¶

out, err := Min([]int{10, 20})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

10

Example (Times) ¶

out, err := Min([]time.Time{
	time.Now(),
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

Example (Uint8s) ¶

out, err := Min([]uint8{1, 2, 3})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1

func Multiply ¶

func Multiply(a interface{}, b interface{}) (interface{}, error)

Multiply multiplies 2 values together while following a few simple rules to convert integers and floats. Supports types uint8, int32, int64, int, float64, and time.Duration. Returns an error if the values cannot be multiplied.

Example (DurationFloat) ¶

out, err := Multiply(0.5, time.Hour*3)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1h30m0s

Example (DurationInt) ¶

out, err := Multiply(2, time.Hour*1)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2h0m0s

Example (Floats) ¶

out, err := Multiply(0.5, 3.0)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1.5

Example (Int32s) ¶

out, err := Multiply(int32(1), int32(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

Example (Int64s) ¶

out, err := Multiply(int64(1), int64(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

Example (Ints) ¶

out, err := Multiply(1, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

Example (UInt8s) ¶

out, err := Multiply(uint8(1), uint8(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

func Pow ¶

func Pow(a interface{}, b interface{}) (out interface{}, err error)

Pow raises a to the power of b (a^b). If a and b are both (unsigned-)integers, then returns an int. Otherwise, returns a float64. Supports types uint8, int32, int64, int, and float64.

Example (Floats) ¶

out, err := Pow(1.11, 2.22)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1.2607152693942678

Example (Int32s) ¶

out, err := Pow(int32(1), int32(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1

Example (Int64s) ¶

out, err := Pow(int64(1), int64(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1

Example (Ints) ¶

out, err := Pow(1, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1

Example (UInt8s) ¶

out, err := Pow(uint8(4), uint8(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

16

func Product ¶

func Product(in interface{}) (interface{}, error)

Product returns the total product (multiplied value) from the array or slice of ints, floats, or durations.

Example (Duration) ¶

out, err := Product([]interface{}{
	time.Hour * 1,
	2,
	4,
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

8h0m0s

Example (Floats) ¶

out, err := Product([]float64{1.5, 3.0})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

4.5

Example (Interface) ¶

out, err := Product([]interface{}{10, 2.5})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

25

Example (Ints) ¶

out, err := Product([]int{10, 20})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

200

Example (Uint8s) ¶

out, err := Product([]uint8{1, 2, 3})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

6

func Subtract ¶

func Subtract(a interface{}, b interface{}) (interface{}, error)

Subtract subtracts the second value from the first value while following a few simple rules to convert integers and floats. Supports types uint8, int32, int64, int, float64, time.Time, and time.Duration. Returns an error if the values cannot be added.

Example (Durations) ¶

out, err := Subtract(time.Hour*3, time.Hour*2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

1h0m0s

Example (Floats) ¶

out, err := Subtract(1.11, 2.22)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1.11

Example (Int32s) ¶

out, err := Subtract(int32(1), int32(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Int64s) ¶

out, err := Subtract(int64(1), int64(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (Ints) ¶

out, err := Subtract(1, 2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

-1

Example (TimeDuration) ¶

out, err := Subtract(time.Now(), time.Hour*2)
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

Example (UInt8s) ¶

out, err := Subtract(uint8(4), uint8(2))
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

2

func Sum ¶

func Sum(in interface{}) (interface{}, error)

Sum returns the total value from the array or slice of ints, floats, or durations.

Example (Durations) ¶

out, err := Sum([]time.Duration{
	time.Hour * 2,
	time.Hour * 1,
	time.Hour * 3,
})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

6h0m0s

Example (Floats) ¶

out, err := Sum([]float64{1.11, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

3.33

Example (Interface) ¶

out, err := Sum([]interface{}{10, 2.22})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

12.22

Example (Ints) ¶

out, err := Sum([]int{10, 20})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

30

Example (Uint8s) ¶

out, err := Sum([]uint8{1, 2, 3})
if err != nil {
	panic(err)
}
fmt.Println(out)

Output:

6

Types ¶