mirror of
https://github.com/vlang/v.git
synced 2023-08-10 21:13:21 +03:00
tools: make v test-cleancode test everything by default (#10050)
This commit is contained in:
Delyan Angelov
@ -26,7 +26,6 @@ import math
|
||||
// range - Range of the Array ( max - min )
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
|
||||
// Measure of Occurance
|
||||
// Frequency of a given number
|
||||
// Based on
|
||||
@ -56,7 +55,7 @@ pub fn mean(arr []f64) f64 {
|
||||
for v in arr {
|
||||
sum += v
|
||||
}
|
||||
return sum/f64(arr.len)
|
||||
return sum / f64(arr.len)
|
||||
}
|
||||
|
||||
// Measure of Central Tendancy
|
||||
@ -71,7 +70,7 @@ pub fn geometric_mean(arr []f64) f64 {
|
||||
for v in arr {
|
||||
sum *= v
|
||||
}
|
||||
return math.pow(sum,f64(1)/arr.len)
|
||||
return math.pow(sum, f64(1) / arr.len)
|
||||
}
|
||||
|
||||
// Measure of Central Tendancy
|
||||
@ -84,9 +83,9 @@ pub fn harmonic_mean(arr []f64) f64 {
|
||||
}
|
||||
mut sum := f64(0)
|
||||
for v in arr {
|
||||
sum += f64(1)/v
|
||||
sum += f64(1) / v
|
||||
}
|
||||
return f64(arr.len)/sum
|
||||
return f64(arr.len) / sum
|
||||
}
|
||||
|
||||
// Measure of Central Tendancy
|
||||
@ -98,11 +97,10 @@ pub fn median(arr []f64) f64 {
|
||||
return f64(0)
|
||||
}
|
||||
if arr.len % 2 == 0 {
|
||||
mid := (arr.len/2)-1
|
||||
return (arr[mid] + arr[mid+1])/f64(2)
|
||||
}
|
||||
else {
|
||||
return arr[((arr.len-1)/2)]
|
||||
mid := (arr.len / 2) - 1
|
||||
return (arr[mid] + arr[mid + 1]) / f64(2)
|
||||
} else {
|
||||
return arr[((arr.len - 1) / 2)]
|
||||
}
|
||||
}
|
||||
|
||||
@ -116,10 +114,10 @@ pub fn mode(arr []f64) f64 {
|
||||
}
|
||||
mut freqs := []int{}
|
||||
for v in arr {
|
||||
freqs<<freq(arr,v)
|
||||
freqs << freq(arr, v)
|
||||
}
|
||||
mut max := 0
|
||||
for i in 0..freqs.len {
|
||||
for i in 0 .. freqs.len {
|
||||
if freqs[i] > freqs[max] {
|
||||
max = i
|
||||
}
|
||||
@ -136,9 +134,9 @@ pub fn rms(arr []f64) f64 {
|
||||
}
|
||||
mut sum := f64(0)
|
||||
for v in arr {
|
||||
sum += math.pow(v,2)
|
||||
sum += math.pow(v, 2)
|
||||
}
|
||||
return math.sqrt(sum/f64(arr.len))
|
||||
return math.sqrt(sum / f64(arr.len))
|
||||
}
|
||||
|
||||
// Measure of Dispersion / Spread
|
||||
@ -152,9 +150,9 @@ pub fn population_variance(arr []f64) f64 {
|
||||
m := mean(arr)
|
||||
mut sum := f64(0)
|
||||
for v in arr {
|
||||
sum += math.pow(v-m,2)
|
||||
sum += math.pow(v - m, 2)
|
||||
}
|
||||
return sum/f64(arr.len)
|
||||
return sum / f64(arr.len)
|
||||
}
|
||||
|
||||
// Measure of Dispersion / Spread
|
||||
@ -168,9 +166,9 @@ pub fn sample_variance(arr []f64) f64 {
|
||||
m := mean(arr)
|
||||
mut sum := f64(0)
|
||||
for v in arr {
|
||||
sum += math.pow(v-m,2)
|
||||
sum += math.pow(v - m, 2)
|
||||
}
|
||||
return sum/f64(arr.len-1)
|
||||
return sum / f64(arr.len - 1)
|
||||
}
|
||||
|
||||
// Measure of Dispersion / Spread
|
||||
@ -206,9 +204,9 @@ pub fn mean_absdev(arr []f64) f64 {
|
||||
amean := mean(arr)
|
||||
mut sum := f64(0)
|
||||
for v in arr {
|
||||
sum += math.abs(v-amean)
|
||||
sum += math.abs(v - amean)
|
||||
}
|
||||
return sum/f64(arr.len)
|
||||
return sum / f64(arr.len)
|
||||
}
|
||||
|
||||
// Minimum of the given input array
|
||||
|
||||
@ -3,12 +3,12 @@ import math
|
||||
|
||||
fn test_freq() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
data := [f64(10.0),f64(10.0),f64(5.9),f64(2.7)]
|
||||
mut o := stats.freq(data,10.0)
|
||||
data := [f64(10.0), f64(10.0), f64(5.9), f64(2.7)]
|
||||
mut o := stats.freq(data, 10.0)
|
||||
assert o == 2
|
||||
o = stats.freq(data,2.7)
|
||||
o = stats.freq(data, 2.7)
|
||||
assert o == 1
|
||||
o = stats.freq(data,15)
|
||||
o = stats.freq(data, 15)
|
||||
assert o == 0
|
||||
}
|
||||
|
||||
@ -21,15 +21,15 @@ fn tst_res(str1 string, str2 string) bool {
|
||||
|
||||
fn test_mean() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '5.762500')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '17.650000')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '37.708000')
|
||||
@ -37,31 +37,32 @@ fn test_mean() {
|
||||
|
||||
fn test_geometric_mean() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.geometric_mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(),'5.15993')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
assert tst_res(o.str(), '5.15993')
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.geometric_mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert o.str().eq('nan') || o.str().eq('-nan') || o.str().eq('-1.#IND00') || o == f64(0) || o.str().eq('-nan(ind)') // Because in math it yields a complex number
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
assert o.str().eq('nan') || o.str().eq('-nan') || o.str().eq('-1.#IND00') || o == f64(0)
|
||||
|| o.str().eq('-nan(ind)') // Because in math it yields a complex number
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.geometric_mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(),'25.064496')
|
||||
assert tst_res(o.str(), '25.064496')
|
||||
}
|
||||
|
||||
fn test_harmonic_mean() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.harmonic_mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '4.626519')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.harmonic_mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '9.134577')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.harmonic_mean(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '16.555477')
|
||||
@ -72,56 +73,58 @@ fn test_median() {
|
||||
// Assumes sorted array
|
||||
|
||||
// Even
|
||||
mut data := [f64(2.7),f64(4.45),f64(5.9),f64(10.0)]
|
||||
mut data := [f64(2.7), f64(4.45), f64(5.9), f64(10.0)]
|
||||
mut o := stats.median(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '5.175000')
|
||||
data = [f64(-3.0),f64(1.89),f64(4.4),f64(67.31)]
|
||||
data = [f64(-3.0), f64(1.89), f64(4.4), f64(67.31)]
|
||||
o = stats.median(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '3.145000')
|
||||
data = [f64(7.88),f64(12.0),f64(54.83),f64(76.122)]
|
||||
data = [f64(7.88), f64(12.0), f64(54.83), f64(76.122)]
|
||||
o = stats.median(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '33.415000')
|
||||
|
||||
// Odd
|
||||
data = [f64(2.7),f64(4.45),f64(5.9),f64(10.0),f64(22)]
|
||||
data = [f64(2.7), f64(4.45), f64(5.9), f64(10.0), f64(22)]
|
||||
o = stats.median(data)
|
||||
assert o == f64(5.9)
|
||||
data = [f64(-3.0),f64(1.89),f64(4.4),f64(9),f64(67.31)]
|
||||
data = [f64(-3.0), f64(1.89), f64(4.4), f64(9), f64(67.31)]
|
||||
o = stats.median(data)
|
||||
assert o == f64(4.4)
|
||||
data = [f64(7.88),f64(3.3),f64(12.0),f64(54.83),f64(76.122)]
|
||||
data = [f64(7.88), f64(3.3), f64(12.0), f64(54.83), f64(76.122)]
|
||||
o = stats.median(data)
|
||||
assert o == f64(12.0)
|
||||
}
|
||||
|
||||
fn test_mode() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(2.7),f64(2.7),f64(4.45),f64(5.9),f64(10.0)]
|
||||
mut data := [f64(2.7), f64(2.7), f64(4.45), f64(5.9), f64(10.0)]
|
||||
mut o := stats.mode(data)
|
||||
assert o == f64(2.7)
|
||||
data = [f64(-3.0),f64(1.89),f64(1.89),f64(1.89),f64(9),f64(4.4),f64(4.4),f64(9),f64(67.31)]
|
||||
data = [f64(-3.0), f64(1.89), f64(1.89), f64(1.89), f64(9), f64(4.4), f64(4.4), f64(9),
|
||||
f64(67.31),
|
||||
]
|
||||
o = stats.mode(data)
|
||||
assert o == f64(1.89)
|
||||
// Testing greedy nature
|
||||
data = [f64(2.0),f64(4.0),f64(2.0),f64(4.0)]
|
||||
data = [f64(2.0), f64(4.0), f64(2.0), f64(4.0)]
|
||||
o = stats.mode(data)
|
||||
assert o == f64(2.0)
|
||||
}
|
||||
|
||||
fn test_rms() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.rms(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '6.362046')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.rms(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '33.773393')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.rms(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '47.452561')
|
||||
@ -129,15 +132,15 @@ fn test_rms() {
|
||||
|
||||
fn test_population_variance() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.population_variance(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '7.269219')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.population_variance(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '829.119550')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.population_variance(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '829.852282')
|
||||
@ -145,15 +148,15 @@ fn test_population_variance() {
|
||||
|
||||
fn test_sample_variance() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.sample_variance(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '9.692292')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.sample_variance(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '1105.492733')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.sample_variance(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '1106.469709')
|
||||
@ -161,15 +164,15 @@ fn test_sample_variance() {
|
||||
|
||||
fn test_population_stddev() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.population_stddev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '2.696149')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.population_stddev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '28.794436')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.population_stddev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '28.807157')
|
||||
@ -177,15 +180,15 @@ fn test_population_stddev() {
|
||||
|
||||
fn test_sample_stddev() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.sample_stddev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '3.113245')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.sample_stddev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '33.248951')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.sample_stddev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '33.263639')
|
||||
@ -193,15 +196,15 @@ fn test_sample_stddev() {
|
||||
|
||||
fn test_mean_absdev() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.mean_absdev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '2.187500')
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.mean_absdev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '24.830000')
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.mean_absdev(data)
|
||||
// Some issue with precision comparison in f64 using == operator hence serializing to string
|
||||
assert tst_res(o.str(), '27.768000')
|
||||
@ -209,46 +212,46 @@ fn test_mean_absdev() {
|
||||
|
||||
fn test_min() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.min(data)
|
||||
assert o == f64(2.7)
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.min(data)
|
||||
assert o == f64(-3.0)
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.min(data)
|
||||
assert o == f64(7.88)
|
||||
}
|
||||
|
||||
fn test_max() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.max(data)
|
||||
assert o == f64(10.0)
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.max(data)
|
||||
assert o == f64(67.31)
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.max(data)
|
||||
assert o == f64(76.122)
|
||||
}
|
||||
|
||||
fn test_range() {
|
||||
// Tests were also verified on Wolfram Alpha
|
||||
mut data := [f64(10.0),f64(4.45),f64(5.9),f64(2.7)]
|
||||
mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
|
||||
mut o := stats.range(data)
|
||||
assert o == f64(7.3)
|
||||
data = [f64(-3.0),f64(67.31),f64(4.4),f64(1.89)]
|
||||
data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
|
||||
o = stats.range(data)
|
||||
assert o == f64(70.31)
|
||||
data = [f64(12.0),f64(7.88),f64(76.122),f64(54.83)]
|
||||
data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
|
||||
o = stats.range(data)
|
||||
assert o == f64(68.242)
|
||||
}
|
||||
|
||||
fn test_passing_empty() {
|
||||
data := []f64{}
|
||||
assert stats.freq(data,0) == 0
|
||||
assert stats.freq(data, 0) == 0
|
||||
assert stats.mean(data) == f64(0)
|
||||
assert stats.geometric_mean(data) == f64(0)
|
||||
assert stats.harmonic_mean(data) == f64(0)
|
||||
|
||||
Reference in New Issue
Block a user