Files
2026-10-29 17:29:41 +01:00

183 lines
3.3 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
}
// Min of values.
func Min[T Number](data []T) T {
var min T
for _, v := range data {
if v < min {
min = v
}
}
return min
}
// Max of values.
func Max[T Number](data []T) T {
var max T
for _, v := range data {
if v > max {
max = v
}
}
return max
}
// 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) T {
if len(data) == 0 {
return 0
}
var squares float64
for _, v := range data {
squares += float64(v) * float64(v)
}
return T(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) T {
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 T(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)
}