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) }