Initial project import
This commit is contained in:
Agila Forge Importer committed
commit
23f2d29e32
11957 files changed
+1754577
No files matched your search
@@ -0,0 +1,545 @@
|
||||
module stats
|
||||
|
||||
import math
|
||||
|
||||
// freq calculates the Measure of Occurrence
|
||||
// Frequency of a given number
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/frequency-distribution.html
|
||||
pub fn freq[T](data []T, val T) int {
|
||||
if data.len == 0 {
|
||||
return 0
|
||||
}
|
||||
mut count := 0
|
||||
for v in data {
|
||||
if v == val {
|
||||
count++
|
||||
}
|
||||
}
|
||||
return count
|
||||
}
|
||||
|
||||
// mean calculates the average
|
||||
// of the given input array, sum(data)/data.len
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/central-measures.html
|
||||
pub fn mean[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut sum := T(0)
|
||||
for v in data {
|
||||
sum += v
|
||||
}
|
||||
return T(sum / data.len)
|
||||
}
|
||||
|
||||
// geometric_mean calculates the central tendency
|
||||
// of the given input array, product(data)**1/data.len
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/numbers/geometric-mean.html
|
||||
pub fn geometric_mean[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut sum := T(1)
|
||||
for v in data {
|
||||
sum *= v
|
||||
}
|
||||
$if T is f64 {
|
||||
return math.pow(sum, f64(1.0) / data.len)
|
||||
} $else {
|
||||
// use f32 for f32/int/...
|
||||
return T(math.powf(f32(sum), f32(1.0) / data.len))
|
||||
}
|
||||
}
|
||||
|
||||
// harmonic_mean calculates the reciprocal of the average of reciprocals
|
||||
// of the given input array
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/numbers/harmonic-mean.html
|
||||
pub fn harmonic_mean[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
$if T is f64 {
|
||||
mut sum := f64(0)
|
||||
for v in data {
|
||||
sum += f64(1.0) / v
|
||||
}
|
||||
return f64(f64(data.len) / sum)
|
||||
} $else {
|
||||
// use f32 for f32/int/...
|
||||
mut sum := f32(0)
|
||||
for v in data {
|
||||
sum += f32(1.0) / f32(v)
|
||||
}
|
||||
return T(f32(data.len) / sum)
|
||||
}
|
||||
}
|
||||
|
||||
// median returns the middlemost value of the given input array ( input array is assumed to be sorted )
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/central-measures.html
|
||||
pub fn median[T](sorted_data []T) T {
|
||||
if sorted_data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
if sorted_data.len % 2 == 0 {
|
||||
mid := (sorted_data.len / 2) - 1
|
||||
return (sorted_data[mid] + sorted_data[mid + 1]) / T(2)
|
||||
} else {
|
||||
return sorted_data[((sorted_data.len - 1) / 2)]
|
||||
}
|
||||
}
|
||||
|
||||
// mode calculates the highest occurring value of the given input array
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/central-measures.html
|
||||
pub fn mode[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut freqs := []int{}
|
||||
for v in data {
|
||||
freqs << freq(data, v)
|
||||
}
|
||||
mut max_idx := 0
|
||||
for i := 0; i < freqs.len; i++ {
|
||||
if freqs[i] > freqs[max_idx] {
|
||||
max_idx = i
|
||||
}
|
||||
}
|
||||
return data[max_idx]
|
||||
}
|
||||
|
||||
// rms, Root Mean Square, calculates the sqrt of the mean of the squares of the given input array
|
||||
// Based on
|
||||
// https://en.wikipedia.org/wiki/Root_mean_square
|
||||
pub fn rms[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
|
||||
$if T is f64 {
|
||||
mut sum := f64(0)
|
||||
for v in data {
|
||||
sum += math.pow(v, 2)
|
||||
}
|
||||
return math.sqrt(sum / data.len)
|
||||
} $else {
|
||||
// use f32 for f32/int/...
|
||||
mut sum := f32(0)
|
||||
for v in data {
|
||||
sum += math.powf(f32(v), 2)
|
||||
}
|
||||
return T(math.sqrtf(sum / data.len))
|
||||
}
|
||||
}
|
||||
|
||||
// population_variance is the Measure of Dispersion / Spread
|
||||
// of the given input array
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
@[inline]
|
||||
pub fn population_variance[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
data_mean := mean[T](data)
|
||||
return population_variance_mean[T](data, data_mean)
|
||||
}
|
||||
|
||||
// population_variance_mean is the Measure of Dispersion / Spread
|
||||
// of the given input array, with the provided mean
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
pub fn population_variance_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
|
||||
mut sum := T(0)
|
||||
for v in data {
|
||||
sum += T((v - mean) * (v - mean))
|
||||
}
|
||||
return T(sum / data.len)
|
||||
}
|
||||
|
||||
// sample_variance calculates the spread of dataset around the mean
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
@[inline]
|
||||
pub fn sample_variance[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
data_mean := mean[T](data)
|
||||
return sample_variance_mean[T](data, data_mean)
|
||||
}
|
||||
|
||||
// sample_variance calculates the spread of dataset around the provided mean
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
pub fn sample_variance_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut sum := T(0)
|
||||
for v in data {
|
||||
sum += T((v - mean) * (v - mean))
|
||||
}
|
||||
return T(sum / (data.len - 1))
|
||||
}
|
||||
|
||||
// population_stddev calculates how spread out the dataset is
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
@[inline]
|
||||
pub fn population_stddev[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
$if T is f64 {
|
||||
return math.sqrt(population_variance[T](data))
|
||||
} $else {
|
||||
return T(math.sqrtf(f32(population_variance[T](data))))
|
||||
}
|
||||
}
|
||||
|
||||
// population_stddev_mean calculates how spread out the dataset is, with the provide mean
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
@[inline]
|
||||
pub fn population_stddev_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
$if T is f64 {
|
||||
return math.sqrt(population_variance_mean[T](data, mean))
|
||||
} $else {
|
||||
return T(math.sqrtf(f32(population_variance_mean[T](data, mean))))
|
||||
}
|
||||
}
|
||||
|
||||
// Measure of Dispersion / Spread
|
||||
// Sample Standard Deviation of the given input array
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
@[inline]
|
||||
pub fn sample_stddev[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
$if T is f64 {
|
||||
return math.sqrt(sample_variance[T](data))
|
||||
} $else {
|
||||
return T(math.sqrtf(f32(sample_variance[T](data))))
|
||||
}
|
||||
}
|
||||
|
||||
// Measure of Dispersion / Spread
|
||||
// Sample Standard Deviation of the given input array
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/standard-deviation.html
|
||||
@[inline]
|
||||
pub fn sample_stddev_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
$if T is f64 {
|
||||
return math.sqrt(sample_variance_mean[T](data, mean))
|
||||
} $else {
|
||||
return T(math.sqrtf(sample_variance_mean[T](data, mean)))
|
||||
}
|
||||
}
|
||||
|
||||
// absdev calculates the average distance between each data point and the mean
|
||||
// Based on
|
||||
// https://en.wikipedia.org/wiki/Average_absolute_deviation
|
||||
@[inline]
|
||||
pub fn absdev[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
data_mean := mean[T](data)
|
||||
return absdev_mean[T](data, data_mean)
|
||||
}
|
||||
|
||||
// absdev_mean calculates the average distance between each data point and the provided mean
|
||||
// Based on
|
||||
// https://en.wikipedia.org/wiki/Average_absolute_deviation
|
||||
pub fn absdev_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut sum := T(0)
|
||||
for v in data {
|
||||
sum += math.abs(v - mean)
|
||||
}
|
||||
return T(sum / data.len)
|
||||
}
|
||||
|
||||
// tts, Sum of squares, calculates the sum over all squared differences between values and overall mean
|
||||
@[inline]
|
||||
pub fn tss[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
data_mean := mean[T](data)
|
||||
return tss_mean[T](data, data_mean)
|
||||
}
|
||||
|
||||
// tts_mean, Sum of squares, calculates the sum over all squared differences between values and the provided mean
|
||||
pub fn tss_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut sum_sq := T(0)
|
||||
for v in data {
|
||||
sum_sq += T((v - mean) * (v - mean))
|
||||
}
|
||||
return sum_sq
|
||||
}
|
||||
|
||||
// min finds the minimum value from the dataset
|
||||
pub fn min[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut lo := data[0]
|
||||
for v in data {
|
||||
if v < lo {
|
||||
lo = v
|
||||
}
|
||||
}
|
||||
return lo
|
||||
}
|
||||
|
||||
// max finds the maximum value from the dataset
|
||||
pub fn max[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut hi := data[0]
|
||||
for v in data {
|
||||
if v > hi {
|
||||
hi = v
|
||||
}
|
||||
}
|
||||
return hi
|
||||
}
|
||||
|
||||
// minmax finds the minimum and maximum value from the dataset
|
||||
pub fn minmax[T](data []T) (T, T) {
|
||||
if data.len == 0 {
|
||||
return T(0), T(0)
|
||||
}
|
||||
mut hi := data[0]
|
||||
mut lo := data[0]
|
||||
for v in data[1..] {
|
||||
if v > hi {
|
||||
hi = v
|
||||
}
|
||||
if v < lo {
|
||||
lo = v
|
||||
}
|
||||
}
|
||||
return lo, hi
|
||||
}
|
||||
|
||||
// min_index finds the first index of the minimum value
|
||||
pub fn min_index[T](data []T) int {
|
||||
if data.len == 0 {
|
||||
return 0
|
||||
}
|
||||
mut lo := data[0]
|
||||
mut lo_idx := 0
|
||||
for i, v in data {
|
||||
if v < lo {
|
||||
lo = v
|
||||
lo_idx = i
|
||||
}
|
||||
}
|
||||
return lo_idx
|
||||
}
|
||||
|
||||
// max_index finds the first index of the maximum value
|
||||
pub fn max_index[T](data []T) int {
|
||||
if data.len == 0 {
|
||||
return 0
|
||||
}
|
||||
mut hi := data[0]
|
||||
mut hi_idx := 0
|
||||
for i, v in data {
|
||||
if v > hi {
|
||||
hi = v
|
||||
hi_idx = i
|
||||
}
|
||||
}
|
||||
return hi_idx
|
||||
}
|
||||
|
||||
// minmax_index finds the first index of the minimum and maximum value
|
||||
pub fn minmax_index[T](data []T) (int, int) {
|
||||
if data.len == 0 {
|
||||
return 0, 0
|
||||
}
|
||||
mut lo := data[0]
|
||||
mut hi := data[0]
|
||||
mut lo_idx := 0
|
||||
mut hi_idx := 0
|
||||
for i, v in data {
|
||||
if v < lo {
|
||||
lo = v
|
||||
lo_idx = i
|
||||
}
|
||||
if v > hi {
|
||||
hi = v
|
||||
hi_idx = i
|
||||
}
|
||||
}
|
||||
return lo_idx, hi_idx
|
||||
}
|
||||
|
||||
// range calculates the difference between the min and max
|
||||
// Range ( Maximum - Minimum ) of the given input array
|
||||
// Based on
|
||||
// https://www.mathsisfun.com/data/range.html
|
||||
pub fn range[T](data []T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
lo, hi := minmax[T](data)
|
||||
return hi - lo
|
||||
}
|
||||
|
||||
// covariance calculates directional association between datasets
|
||||
// positive value denotes variables move in same direction and negative denotes variables move in opposite directions
|
||||
@[inline]
|
||||
pub fn covariance[T](data1 []T, data2 []T) T {
|
||||
mean1 := mean[T](data1)
|
||||
mean2 := mean[T](data2)
|
||||
return covariance_mean[T](data1, data2, mean1, mean2)
|
||||
}
|
||||
|
||||
// covariance_mean computes the covariance of a dataset with means provided
|
||||
// the recurrence relation
|
||||
pub fn covariance_mean[T](data1 []T, data2 []T, mean1 T, mean2 T) T {
|
||||
n := int(math.min(data1.len, data2.len))
|
||||
if n == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut cov := T(0)
|
||||
for i in 0 .. n {
|
||||
delta1 := data1[i] - mean1
|
||||
delta2 := data2[i] - mean2
|
||||
cov += T((delta1 * delta2 - cov) / (T(i) + T(1)))
|
||||
}
|
||||
return cov
|
||||
}
|
||||
|
||||
// lag1_autocorrelation_mean calculates the correlation between values that are one time period apart
|
||||
// of a dataset, based on the mean
|
||||
@[inline]
|
||||
pub fn lag1_autocorrelation[T](data []T) T {
|
||||
data_mean := mean[T](data)
|
||||
return lag1_autocorrelation_mean[T](data, data_mean)
|
||||
}
|
||||
|
||||
// lag1_autocorrelation_mean calculates the correlation between values that are one time period apart
|
||||
// of a dataset, using
|
||||
// the recurrence relation
|
||||
pub fn lag1_autocorrelation_mean[T](data []T, mean T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut q := T(0)
|
||||
mut v := (data[0] * mean) - (data[0] * mean)
|
||||
for i := 1; i < data.len; i++ {
|
||||
delta0 := data[i - 1] - mean
|
||||
delta1 := data[i] - mean
|
||||
d01 := delta0 * delta1
|
||||
d11 := delta1 * delta1
|
||||
ti1 := T(i) + T(1)
|
||||
q += T((d01 - q) / ti1)
|
||||
v += T((d11 - v) / ti1)
|
||||
}
|
||||
return T(q / v)
|
||||
}
|
||||
|
||||
// kurtosis calculates the measure of the 'tailedness' of the data by finding mean and standard of deviation
|
||||
@[inline]
|
||||
pub fn kurtosis[T](data []T) T {
|
||||
data_mean := mean[T](data)
|
||||
sd := population_stddev_mean[T](data, data_mean)
|
||||
return kurtosis_mean_stddev[T](data, data_mean, sd)
|
||||
}
|
||||
|
||||
// kurtosis_mean_stddev calculates the measure of the 'tailedness' of the data
|
||||
// using the fourth moment the deviations, normalized by the sd
|
||||
pub fn kurtosis_mean_stddev[T](data []T, mean T, sd T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut avg := T(0) // find the fourth moment the deviations, normalized by the sd
|
||||
/*
|
||||
we use a recurrence relation to stably update a running value so
|
||||
* there aren't any large sums that can overflow
|
||||
*/
|
||||
for i, v in data {
|
||||
x := (v - mean) / sd
|
||||
x4 := x * x * x * x
|
||||
ti1 := (T(i) + T(1))
|
||||
avg += T((x4 - avg) / ti1)
|
||||
}
|
||||
return avg - T(3)
|
||||
}
|
||||
|
||||
// skew calculates the mean and standard of deviation to find the skew from the data
|
||||
@[inline]
|
||||
pub fn skew[T](data []T) T {
|
||||
data_mean := mean[T](data)
|
||||
sd := population_stddev_mean[T](data, data_mean)
|
||||
return skew_mean_stddev[T](data, data_mean, sd)
|
||||
}
|
||||
|
||||
// skew_mean_stddev calculates the skewness of data
|
||||
pub fn skew_mean_stddev[T](data []T, mean T, sd T) T {
|
||||
if data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
mut total := T(0) // find the sum of the cubed deviations, normalized by the sd.
|
||||
/*
|
||||
we use a recurrence relation to stably update a running value so
|
||||
* there aren't any large sums that can overflow
|
||||
*/
|
||||
for i, v in data {
|
||||
x := (v - mean) / sd
|
||||
x3 := x * x * x
|
||||
total += T((x3 - total) / (T(i) + T(1)))
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
// quantile calculates quantile points
|
||||
// for more reference
|
||||
// https://en.wikipedia.org/wiki/Quantile
|
||||
pub fn quantile[T](sorted_data []T, f T) !T {
|
||||
if sorted_data.len == 0 {
|
||||
return T(0)
|
||||
}
|
||||
index := f * (sorted_data.len - 1)
|
||||
lhs := int(index)
|
||||
if lhs < 0 || lhs >= sorted_data.len {
|
||||
return error('index out of range')
|
||||
} else if lhs == sorted_data.len - 1 {
|
||||
return sorted_data[lhs]
|
||||
} else {
|
||||
if lhs >= sorted_data.len - 1 {
|
||||
return error('index out of range')
|
||||
}
|
||||
delta := index - T(lhs)
|
||||
return T((1 - delta) * sorted_data[lhs] + delta * sorted_data[(lhs + 1)])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,577 @@
|
||||
import math
|
||||
import math.stats
|
||||
|
||||
fn test_freq() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
data := [10.0, 10.0, 5.9, 2.7]
|
||||
mut o := stats.freq(data, 10.0)
|
||||
assert o == 2
|
||||
o = stats.freq(data, 2.7)
|
||||
assert o == 1
|
||||
o = stats.freq(data, 15)
|
||||
assert o == 0
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.freq[int]([1, 3, 5, 7], 5) == 1
|
||||
assert stats.freq[i64]([i64(1), 3, 5, 7], 5) == 1
|
||||
assert stats.freq[f32]([f32(1.0), 3, 5, 7], 3.0) == 1
|
||||
}
|
||||
|
||||
fn test_mean() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.mean(data)
|
||||
assert math.alike(o, 5.7625)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.mean(data)
|
||||
assert math.alike(o, 17.65)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.mean(data)
|
||||
assert math.alike(o, 37.708)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.mean[int]([1, 2]) == 1
|
||||
assert stats.mean[i64]([i64(1), 2]) == 1
|
||||
o = stats.mean[f32]([f32(1.0), 3, 5, 7])
|
||||
assert math.alike(o, 4.0)
|
||||
}
|
||||
|
||||
fn test_geometric_mean() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.geometric_mean(data)
|
||||
assert math.alike(o, 5.159931624158176)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.geometric_mean(data)
|
||||
assert math.is_nan(o) // Because in math it yields a complex number
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.geometric_mean(data)
|
||||
assert math.alike(o, 25.064495926603378)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.geometric_mean[int]([1, 3, 5, 7]) == 3
|
||||
assert stats.geometric_mean[i64]([i64(1), 3, 5, 7]) == 3
|
||||
o = stats.geometric_mean[f32]([f32(1.0), 3, 5, 7])
|
||||
assert math.alike(o, 3.2010858058929443)
|
||||
}
|
||||
|
||||
fn test_harmonic_mean() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.harmonic_mean(data)
|
||||
assert math.alike(o, 4.626518526616179)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.harmonic_mean(data)
|
||||
assert math.alike(o, 9.134577425605814)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.harmonic_mean(data)
|
||||
assert math.alike(o, 16.555477040152685)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.harmonic_mean[int]([1, 2]) == 1
|
||||
assert stats.harmonic_mean[i64]([i64(1), 2]) == 1
|
||||
o = stats.harmonic_mean[f32]([f32(1.0), 3, 5, 7])
|
||||
assert math.alike(o, 2.3863635063171387)
|
||||
}
|
||||
|
||||
fn test_median() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
// Assumes sorted array
|
||||
|
||||
// Even
|
||||
mut data := [2.7, 4.45, 5.9, 10.0]
|
||||
mut o := stats.median(data)
|
||||
assert math.alike(o, 5.175000000000001)
|
||||
data = [-3.0, 1.89, 4.4, 67.31]
|
||||
o = stats.median(data)
|
||||
assert math.alike(o, 3.145)
|
||||
data = [7.88, 12.0, 54.83, 76.122]
|
||||
o = stats.median(data)
|
||||
assert math.alike(o, 33.415)
|
||||
|
||||
// Odd
|
||||
data = [2.7, 4.45, 5.9, 10.0, 22]
|
||||
o = stats.median(data)
|
||||
assert math.alike(o, 5.9)
|
||||
data = [-3.0, 1.89, 4.4, 9, 67.31]
|
||||
o = stats.median(data)
|
||||
assert math.alike(o, 4.4)
|
||||
data = [7.88, 3.3, 12.0, 54.83, 76.122]
|
||||
o = stats.median(data)
|
||||
assert math.alike(o, 12.0)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.median[int]([1, 2, 3]) == 2
|
||||
assert stats.median[i64]([i64(1), 2, 3]) == 2
|
||||
o = stats.median[f32]([f32(1.0), 3, 5, 7])
|
||||
assert math.alike(o, 4)
|
||||
}
|
||||
|
||||
fn test_mode() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [2.7, 2.7, 4.45, 5.9, 10.0]
|
||||
mut o := stats.mode(data)
|
||||
assert math.alike(o, 2.7)
|
||||
data = [-3.0, 1.89, 1.89, 1.89, 9, 4.4, 4.4, 9, 67.31]
|
||||
o = stats.mode(data)
|
||||
assert math.alike(o, 1.89)
|
||||
// Testing greedy nature
|
||||
data = [2.0, 4.0, 2.0, 4.0]
|
||||
o = stats.mode(data)
|
||||
assert math.alike(o, 2.0)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.mode[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.mode[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.mode[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 3)
|
||||
}
|
||||
|
||||
fn test_rms() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.rms(data)
|
||||
assert math.alike(o, 6.362045661577729)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.rms(data)
|
||||
assert math.alike(o, 33.77339263384714)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.rms(data)
|
||||
assert math.alike(o, 47.45256100570337)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.rms[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.rms[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.rms[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 4.312771797180176)
|
||||
}
|
||||
|
||||
fn test_population_variance() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.population_variance(data)
|
||||
assert math.alike(o, 7.269218749999999)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.population_variance(data)
|
||||
assert math.alike(o, 829.119550)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.population_variance(data)
|
||||
assert math.alike(o, 829.852282)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.population_variance[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.population_variance[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.population_variance[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 4.159999847412109)
|
||||
}
|
||||
|
||||
fn test_sample_variance() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.sample_variance(data)
|
||||
assert math.alike(o, 9.692291666666666)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.sample_variance(data)
|
||||
assert math.alike(o, 1105.4927333333333)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.sample_variance(data)
|
||||
assert math.alike(o, 1106.4697093333332)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.sample_variance[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.sample_variance[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.sample_variance[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 5.199999809265137)
|
||||
}
|
||||
|
||||
fn test_population_stddev() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.population_stddev(data)
|
||||
assert math.alike(o, 2.6961488738569312)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.population_stddev(data)
|
||||
assert math.alike(o, 28.794436094495754)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.population_stddev(data)
|
||||
assert math.alike(o, 28.80715678438259)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.population_stddev[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.population_stddev[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.population_stddev[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 2.0396077632904053)
|
||||
}
|
||||
|
||||
fn test_sample_stddev() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.sample_stddev(data)
|
||||
assert math.alike(o, 3.1132445561932114)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.sample_stddev(data)
|
||||
assert math.alike(o, 33.2489508606412)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.sample_stddev(data)
|
||||
assert math.alike(o, 33.26363944810208)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.sample_stddev[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.sample_stddev[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.sample_stddev[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 2.280350923538208)
|
||||
}
|
||||
|
||||
fn test_absdev() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.absdev(data)
|
||||
assert o == 2.1875
|
||||
assert math.alike(o, 2.1875)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.absdev(data)
|
||||
assert o == 24.830000000000002
|
||||
assert math.alike(o, 24.830000000000002)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.absdev(data)
|
||||
assert o == 27.768
|
||||
assert math.alike(o, 27.768)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.absdev[int]([1, 2, 3, 1]) == 0
|
||||
assert stats.absdev[i64]([i64(1), 2, 3, 1]) == 0
|
||||
o = stats.absdev[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 1.7599999904632568)
|
||||
}
|
||||
|
||||
fn test_tss() {
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.tss(data)
|
||||
assert math.alike(o, 29.076874999999998)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.tss(data)
|
||||
assert math.alike(o, 3316.4782)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.tss(data)
|
||||
assert math.alike(o, 3319.409128)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.tss[int]([1, 2, 3, 1]) == 5
|
||||
assert stats.tss[i64]([i64(1), 2, 3, 1]) == 5
|
||||
o = stats.tss[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 20.799999237060547)
|
||||
}
|
||||
|
||||
fn test_min() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.min(data)
|
||||
assert math.alike(o, 2.7)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.min(data)
|
||||
assert math.alike(o, -3.0)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.min(data)
|
||||
assert math.alike(o, 7.88)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.min[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.min[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.min[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 1.0)
|
||||
}
|
||||
|
||||
fn test_max() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.max(data)
|
||||
assert math.alike(o, 10.0)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.max(data)
|
||||
assert math.alike(o, 67.31)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.max(data)
|
||||
assert math.alike(o, 76.122)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.max[int]([1, 2, 3, 1]) == 3
|
||||
assert stats.max[i64]([i64(1), 2, 3, 1]) == 3
|
||||
o = stats.max[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 7.0)
|
||||
}
|
||||
|
||||
fn test_minmax() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o_min, mut o_max := stats.minmax(data)
|
||||
assert [o_min, o_max] == [2.7, 10.0]
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o_min, o_max = stats.minmax(data)
|
||||
assert [o_min, o_max] == [-3.0, 67.31]
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o_min, o_max = stats.minmax(data)
|
||||
assert [o_min, o_max] == [7.88, 76.122]
|
||||
|
||||
// test for int, i64, f32 array
|
||||
o_min_int, o_max_int := stats.minmax[int]([1, 2, 3, 1])
|
||||
assert [o_min_int, o_max_int] == [1, 3]
|
||||
o_min_i64, o_max_i64 := stats.minmax[i64]([i64(1), 2, 3, 1])
|
||||
assert [o_min_i64, o_max_i64] == [i64(1), 3]
|
||||
o_min_f32, o_max_f32 := stats.minmax[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert [o_min_f32, o_max_f32] == [f32(1.0), 7]
|
||||
}
|
||||
|
||||
fn test_min_index() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.min_index(data)
|
||||
assert o == 3
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.min_index(data)
|
||||
assert o == 0
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.min_index(data)
|
||||
assert o == 1
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.min_index[int]([1, 2, 3, 1]) == 0
|
||||
assert stats.min_index[i64]([i64(1), 2, 3, 1]) == 0
|
||||
assert stats.min_index[f32]([f32(1.0), 3, 5, 7, 3]) == 0
|
||||
}
|
||||
|
||||
fn test_max_index() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.max_index(data)
|
||||
assert o == 0
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.max_index(data)
|
||||
assert o == 1
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.max_index(data)
|
||||
assert o == 2
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.max_index[int]([1, 2, 3, 1]) == 2
|
||||
assert stats.max_index[i64]([i64(1), 2, 3, 1]) == 2
|
||||
assert stats.max_index[f32]([f32(1.0), 3, 5, 7, 3]) == 3
|
||||
}
|
||||
|
||||
fn test_minmax_index() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o_min, mut o_max := stats.minmax_index(data)
|
||||
assert [o_min, o_max] == [3, 0]
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o_min, o_max = stats.minmax_index(data)
|
||||
assert [o_min, o_max] == [0, 1]
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o_min, o_max = stats.minmax_index(data)
|
||||
assert [o_min, o_max] == [1, 2]
|
||||
|
||||
// test for int, i64, f32 array
|
||||
o_min, o_max = stats.minmax_index[int]([1, 2, 3, 1])
|
||||
assert [o_min, o_max] == [0, 2]
|
||||
o_min, o_max = stats.minmax_index[i64]([i64(1), 2, 3, 1])
|
||||
assert [o_min, o_max] == [0, 2]
|
||||
o_min, o_max = stats.minmax_index[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert [o_min, o_max] == [0, 3]
|
||||
}
|
||||
|
||||
fn test_range() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.range(data)
|
||||
assert math.alike(o, 7.3)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.range(data)
|
||||
assert math.alike(o, 70.31)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.range(data)
|
||||
assert math.alike(o, 68.242)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.range[int]([1, 2, 3, 1]) == 2
|
||||
assert stats.range[i64]([i64(1), 2, 3, 1]) == 2
|
||||
assert stats.range[f32]([f32(1.0), 3, 5, 7, 3]) == 6.0
|
||||
}
|
||||
|
||||
fn test_covariance() {
|
||||
mut data0 := [10.0, 4.45, 5.9, 2.7]
|
||||
mut data1 := [5.0, 14.45, -15.9, 22.7]
|
||||
mut o := stats.covariance(data0, data1)
|
||||
assert math.alike(o, -17.37078125)
|
||||
data0 = [-3.0, 67.31, 4.4, 1.89]
|
||||
data1 = [5.0, 77.31, 44.4, 11.89]
|
||||
o = stats.covariance(data0, data1)
|
||||
assert math.alike(o, 740.06955)
|
||||
data0 = [12.0, 7.88, 76.122, 54.83]
|
||||
data1 = [2.0, 5.88, 7.122, 5.83]
|
||||
o = stats.covariance(data0, data1)
|
||||
assert math.alike(o, 36.650282000000004)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
data0_int := [1, 2, 3, 1]
|
||||
data1_int := [11, 22, 33, 11]
|
||||
o_int := stats.covariance[int](data0_int, data1_int)
|
||||
assert o_int == 8
|
||||
data0_i64 := [i64(1), 2, 3, 1]
|
||||
data1_i64 := [i64(11), 22, 33, 11]
|
||||
o_i64 := stats.covariance[i64](data0_i64, data1_i64)
|
||||
assert o_i64 == 8
|
||||
data0_f32 := [f32(1.0), 2, 3, 1]
|
||||
data1_f32 := [f32(11.0), 22, 33, 11]
|
||||
o_f32 := stats.covariance[f32](data0_f32, data1_f32)
|
||||
assert math.alike(o_f32, 7.562500476837158)
|
||||
}
|
||||
|
||||
fn test_lag1_autocorrelation() {
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.lag1_autocorrelation(data)
|
||||
mut e := 0.0
|
||||
assert math.alike(o, -0.5542285481446095)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.lag1_autocorrelation(data)
|
||||
assert math.alike(o, -0.5102510654033415)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.lag1_autocorrelation(data)
|
||||
e = 0.10484450460892072
|
||||
assert math.alike(o, e), diff(o, e)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.lag1_autocorrelation[int]([1, 2, 3, 1]) == 0
|
||||
assert stats.lag1_autocorrelation[i64]([i64(1), 2, 3, 1]) == 0
|
||||
o = stats.lag1_autocorrelation[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
assert math.alike(o, 0.1975308507680893)
|
||||
}
|
||||
|
||||
fn diff(actual f64, expected f64) string {
|
||||
return '\n actual:${actual:40.35f}\nexpected:${expected:40.35f}\n diff:${actual - expected:40.35f}'
|
||||
}
|
||||
|
||||
fn test_kurtosis() {
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.kurtosis(data)
|
||||
mut e := -1.0443212849233845
|
||||
assert math.close(o, e), diff(o, e)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.kurtosis(data)
|
||||
e = -0.6884953374814851
|
||||
assert math.close(o, e), diff(o, e)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.kurtosis(data)
|
||||
assert math.alike(o, -1.7323772836921467)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.kurtosis[int]([1, 2, 3, 1]) == 1
|
||||
assert stats.kurtosis[i64]([i64(1), 2, 3, 1]) == 1
|
||||
o = stats.kurtosis[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
e = -1.044378399848938
|
||||
assert math.alike(o, e), diff(o, e)
|
||||
}
|
||||
|
||||
fn test_skew() {
|
||||
mut data := [10.0, 4.45, 5.9, 2.7]
|
||||
mut o := stats.skew(data)
|
||||
mut e := 0.5754021106320453
|
||||
assert math.veryclose(o, e), diff(o, e)
|
||||
data = [-3.0, 67.31, 4.4, 1.89]
|
||||
o = stats.skew(data)
|
||||
e = 1.1248733711136492
|
||||
assert math.veryclose(o, e), diff(o, e)
|
||||
data = [12.0, 7.88, 76.122, 54.83]
|
||||
o = stats.skew(data)
|
||||
e = 0.19007911706827735
|
||||
assert math.alike(o, e), diff(o, e)
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.skew[int]([1, 2, 3, 1]) == 2
|
||||
assert stats.skew[i64]([i64(1), 2, 3, 1]) == 2
|
||||
o = stats.skew[f32]([f32(1.0), 3, 5, 7, 3])
|
||||
e = 0.27154541015625
|
||||
assert math.alike(o, e), diff(o, e)
|
||||
}
|
||||
|
||||
fn test_quantile() {
|
||||
// Assumes sorted array
|
||||
|
||||
mut data := [2.7, 4.45, 5.9, 10.0]
|
||||
mut o := stats.quantile(data, 0.1)!
|
||||
assert math.alike(o, 3.225)
|
||||
data = [-3.0, 1.89, 4.4, 67.31]
|
||||
o = stats.quantile(data, 0.2)!
|
||||
assert math.alike(o, -0.06599999999999961)
|
||||
data = [7.88, 12.0, 54.83, 76.122]
|
||||
o = stats.quantile(data, 0.3)!
|
||||
assert math.alike(o, 11.588)
|
||||
|
||||
stats.quantile(data, -0.3) or { assert err.msg() == 'index out of range' }
|
||||
|
||||
stats.quantile(data, 2) or { assert err.msg() == 'index out of range' }
|
||||
|
||||
// test for int, i64, f32 array
|
||||
assert stats.quantile[int]([1, 2, 3], 1)! == 3
|
||||
assert stats.quantile[i64]([i64(1), 2, 3], 1)! == 3
|
||||
o = stats.quantile[f32]([f32(1.0), 3, 5, 7], 0.22)!
|
||||
assert math.alike(o, 2.319999933242798)
|
||||
}
|
||||
|
||||
fn test_passing_empty() {
|
||||
data := []f64{}
|
||||
assert stats.freq(data, 0) == 0
|
||||
assert stats.mean(data) == 0
|
||||
assert stats.geometric_mean(data) == 0
|
||||
assert stats.harmonic_mean(data) == 0
|
||||
assert stats.median(data) == 0
|
||||
assert stats.mode(data) == 0
|
||||
assert stats.rms(data) == 0
|
||||
assert stats.population_variance(data) == 0
|
||||
assert stats.sample_variance(data) == 0
|
||||
assert stats.population_stddev(data) == 0
|
||||
assert stats.sample_stddev(data) == 0
|
||||
assert stats.absdev(data) == 0
|
||||
assert stats.min(data) == 0
|
||||
assert stats.max(data) == 0
|
||||
o_min, o_max := stats.minmax(data)
|
||||
assert [o_min, o_max] == [f64(0), 0]
|
||||
assert stats.min_index(data) == 0
|
||||
assert stats.max_index(data) == 0
|
||||
o_min_index, o_max_index := stats.minmax_index(data)
|
||||
assert [o_min_index, o_max_index] == [0, 0]
|
||||
assert stats.range(data) == 0
|
||||
assert stats.covariance(data, data) == 0
|
||||
assert stats.lag1_autocorrelation(data) == 0
|
||||
assert stats.kurtosis(data) == 0
|
||||
assert stats.skew(data) == 0
|
||||
assert stats.quantile(data, 0)! == 0
|
||||
}
|
||||
|
||||
fn test_passing_one() {
|
||||
data := [100.0]
|
||||
assert stats.freq(data, 100.0) == 1
|
||||
assert stats.mean(data) == 100.0
|
||||
assert stats.geometric_mean(data) == 100.0
|
||||
assert stats.harmonic_mean(data) == 100.0
|
||||
assert stats.median(data) == 100.0
|
||||
assert stats.mode(data) == 100.0
|
||||
assert stats.rms(data) == 100.0
|
||||
assert stats.population_variance(data) == 0.0
|
||||
assert math.is_nan(stats.sample_variance(data))
|
||||
assert stats.population_stddev(data) == 0.0
|
||||
assert math.is_nan(stats.sample_stddev(data))
|
||||
assert stats.absdev(data) == 0.0
|
||||
assert stats.min(data) == 100.0
|
||||
assert stats.max(data) == 100.0
|
||||
o_min, o_max := stats.minmax(data)
|
||||
assert [o_min, o_max] == [f64(100), 100]
|
||||
assert stats.min_index(data) == 0
|
||||
assert stats.max_index(data) == 0
|
||||
o_min_index, o_max_index := stats.minmax_index(data)
|
||||
assert [o_min_index, o_max_index] == [0, 0]
|
||||
assert stats.range(data) == 0
|
||||
assert stats.covariance(data, data) == 0
|
||||
assert math.is_nan(stats.lag1_autocorrelation(data))
|
||||
assert math.is_nan(stats.kurtosis(data))
|
||||
assert math.is_nan(stats.skew(data))
|
||||
assert stats.quantile(data, 0)! == 100
|
||||
}
|
||||
Reference in new issue
Block a user