161 lines
3.0 KiB
Go
161 lines
3.0 KiB
Go
package calc
|
|
|
|
import "math"
|
|
|
|
// Complex is a constraint that permits any complex numeric type.
|
|
type Complex interface {
|
|
~complex64 | ~complex128
|
|
}
|
|
|
|
// Float is a constraint that permits any floating-point type.
|
|
type Float interface {
|
|
~float32 | ~float64
|
|
}
|
|
|
|
// Integer is a constraint that permits any integer type.
|
|
type Integer interface {
|
|
Signed | Unsigned
|
|
}
|
|
|
|
// Signed is a constraint that permits any signed integer type.
|
|
type Signed interface {
|
|
~int | ~int8 | ~int16 | ~int32 | ~int64
|
|
}
|
|
|
|
// Unsigned is a constraint that permits any unsigned integer type.
|
|
type Unsigned interface {
|
|
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
|
|
}
|
|
|
|
// Number are real valued number types.
|
|
type Number interface {
|
|
Integer | Float
|
|
}
|
|
|
|
// Sum of values.
|
|
func Sum[T Number](data []T) T {
|
|
if len(data) == 0 {
|
|
return 0
|
|
}
|
|
|
|
var sum T
|
|
for _, v := range data {
|
|
sum += v
|
|
}
|
|
return sum
|
|
}
|
|
|
|
// Mean of values.
|
|
func Mean[T Number](data []T) float64 {
|
|
if len(data) == 0 {
|
|
return 0
|
|
}
|
|
|
|
// an algorithm that attempts to retain accuracy
|
|
// with widely different values.
|
|
var parts []float64
|
|
for _, v := range data {
|
|
var (
|
|
x = float64(v)
|
|
i int
|
|
)
|
|
for _, p := range parts {
|
|
sum := p + x
|
|
var err float64
|
|
switch ax, ap := math.Abs(x), math.Abs(p); {
|
|
case ax < ap:
|
|
err = x - (sum - p)
|
|
case ap < ax:
|
|
err = p - (sum - x)
|
|
}
|
|
if err != 0 {
|
|
parts[i] = err
|
|
i++
|
|
}
|
|
x = sum
|
|
}
|
|
parts = append(parts[:i], x)
|
|
}
|
|
|
|
var sum float64
|
|
for _, x := range parts {
|
|
sum += x
|
|
}
|
|
return sum / float64(len(data))
|
|
}
|
|
|
|
// MeanOffset is the mean of values every offset starting at start.
|
|
func MeanOffset[T Number](data []T, start, offset int) float64 {
|
|
if len(data)/offset == 0 {
|
|
return 0
|
|
}
|
|
|
|
// an algorithm that attempts to retain accuracy
|
|
// with widely different values.
|
|
var parts []float64
|
|
for j, l := start, len(data); j < l; j += offset {
|
|
var (
|
|
x = float64(data[j])
|
|
i int
|
|
)
|
|
for _, p := range parts {
|
|
sum := p + x
|
|
var err float64
|
|
switch ax, ap := math.Abs(x), math.Abs(p); {
|
|
case ax < ap:
|
|
err = x - (sum - p)
|
|
case ap < ax:
|
|
err = p - (sum - x)
|
|
}
|
|
if err != 0 {
|
|
parts[i] = err
|
|
i++
|
|
}
|
|
x = sum
|
|
}
|
|
parts = append(parts[:i], x)
|
|
}
|
|
|
|
var sum float64
|
|
for _, x := range parts {
|
|
sum += x
|
|
}
|
|
return sum / float64(len(data))
|
|
}
|
|
|
|
// RMS is the root mean square of values.
|
|
func RMS[T Number](data []T) float64 {
|
|
if len(data) == 0 {
|
|
return 0
|
|
}
|
|
|
|
var squares float64
|
|
for _, v := range data {
|
|
squares += float64(v) * float64(v)
|
|
}
|
|
|
|
return math.Sqrt(squares / float64(len(data)))
|
|
}
|
|
|
|
// RMSOffset is the root mean square of values every offset.
|
|
func RMSOffset[T Number](data []T, start, offset int) float64 {
|
|
if len(data)/offset == 0 {
|
|
return 0
|
|
}
|
|
|
|
var squares float64
|
|
for i, l := start, len(data); i < l; i += offset {
|
|
squares += float64(data[i]) * float64(data[i])
|
|
}
|
|
|
|
return math.Sqrt(squares / float64(len(data)/offset))
|
|
}
|
|
|
|
func Eq(a, b, epsilon float32) bool {
|
|
return math.Abs(float64(a-b)) < float64(epsilon)
|
|
}
|
|
|
|
func AlmostEq(a, b float32) bool {
|
|
return Eq(a, b, 1e-20)
|
|
}
|