math

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)

Variables

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)

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)

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)

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)

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

type ErrInvalidAddition

type ErrInvalidAddition struct {
	A interface{}
	B interface{}
}

func (ErrInvalidAddition) Error

func (e ErrInvalidAddition) Error() string

Error returns the error formatted as a string.

type ErrInvalidComparison

type ErrInvalidComparison struct {
	A interface{}
	B interface{}
}

func (ErrInvalidComparison) Error

func (e ErrInvalidComparison) Error() string

Error returns the error formatted as a string.

type ErrInvalidDivision

type ErrInvalidDivision struct {
	A interface{}
	B interface{}
}

func (ErrInvalidDivision) Error

func (e ErrInvalidDivision) Error() string

Error returns the error formatted as a string.

type ErrInvalidKind

type ErrInvalidKind struct {
	Value    reflect.Type
	Expected []reflect.Kind
}

func (ErrInvalidKind) Error

func (e ErrInvalidKind) Error() string

Error returns the error formatted as a string.

type ErrInvalidMultiplication

type ErrInvalidMultiplication struct {
	A interface{}
	B interface{}
}

func (ErrInvalidMultiplication) Error

func (e ErrInvalidMultiplication) Error() string

Error returns the error formatted as a string.

type ErrInvalidPower

type ErrInvalidPower struct {
	A interface{}
	B interface{}
}

func (ErrInvalidPower) Error

func (e ErrInvalidPower) Error() string

Error returns the error formatted as a string.

type ErrInvalidSubtraction

type ErrInvalidSubtraction struct {
	A interface{}
	B interface{}
}

func (ErrInvalidSubtraction) Error

func (e ErrInvalidSubtraction) Error() string

Error returns the error formatted as a string.