use traquer::statistic::distribution::*;
mod common;
#[test]
fn test_kurtosis() {
let stats = common::test_data();
let result = kurtosis(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
1.3103030757850638,
1.102747994753904,
3.06719774124363,
2.193365559939223,
-0.9756569944812274,
-0.5481498668335418,
-0.2243968276571402,
-0.9521890050850512,
-0.37669821534673487,
-0.2913451763689965,
-0.7833694623815677,
-0.5970746750197158,
-0.6755548198272634,
-0.6448793229503962,
-0.9854966855493053,
-1.1611158440747498,
-1.00010972265145,
-0.5654849882747519,
-0.9958264091354074,
],
result[16 - 1..]
);
}
#[test]
fn test_skew() {
let stats = common::test_data();
let result = skew(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
1.3535582408038451,
1.298528601661446,
1.6254206574818177,
1.162585198346388,
0.19295159682513383,
0.40411386820995304,
0.6117924727238208,
0.285232085638137,
0.4564095498787098,
0.45766697953883545,
0.20396596725267968,
0.11996720728103474,
0.18545745211753306,
0.27852019344431006,
0.24824251094586902,
0.15953878421297624,
0.1407199604842263,
0.242851303974619,
0.2493021518683219,
],
result[16 - 1..]
);
}
#[test]
fn test_variance() {
let stats = common::test_data();
let result = variance(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
43.90139609932976,
46.75740616903386,
41.57331639003853,
20.183342535580266,
10.74866320257297,
9.298350945759921,
9.048442557741282,
5.976738957513533,
5.0368163517604785,
4.918951663781115,
4.269350375557906,
3.7288959446559033,
4.02582761118515,
5.394361230708228,
6.027443564058331,
7.401350057245281,
8.318585264683861,
10.545326561237516,
9.357811578119936,
],
result[16 - 1..]
);
assert_eq!(
std_dev(&stats.close, 16).collect::<Vec<_>>()[16 - 1..],
result[16 - 1..]
.iter()
.map(|x| x.sqrt())
.collect::<Vec<_>>()
);
}
#[test]
fn test_std_dev() {
let stats = common::test_data();
let result = std_dev(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
6.625812863289285,
6.8379387368587805,
6.44773730777228,
4.49258751006369,
3.278515396116506,
3.049319751315024,
3.0080629244983026,
2.444736991480583,
2.244285265237126,
2.2178709754584722,
2.0662406383473115,
1.9310349413348022,
2.0064465134124934,
2.3225764208542694,
2.45508524578238,
2.720542235887045,
2.8841957743336115,
3.2473568576978904,
3.0590540332135254
],
result[15..]
);
}
#[test]
fn test_zscore() {
let stats = common::test_data();
let result = zscore(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
-1.271259155793192,
-1.0206841722070752,
-1.1880139694813163,
-0.8120318127129288,
-1.047348810068407,
-0.5964443141822275,
-0.2798729861249545,
-0.022752455562283176,
-0.2102560145932557,
1.1407336131745787,
1.6745380685199318,
0.8942736349721612,
1.5509389311366226,
1.9724865138719467,
1.3805525742768725,
1.7071506051200664,
1.7983787172684174,
2.015678119257573,
1.2447672598149504,
],
result[15..]
);
}
#[test]
fn test_mad() {
let stats = common::test_data();
let result = mad(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
5.039296746253967,
5.229140520095825,
4.5250003933906555,
3.3781254291534424,
2.8657814264297485,
2.695000171661377,
2.6033595204353333,
2.09703129529953,
1.829843819141388,
1.8025001883506775,
1.7024999856948853,
1.5822653472423553,
1.6441404223442078,
1.947343647480011,
2.1082810163497925,
2.407577931880951,
2.541874885559082,
2.770625114440918,
2.6209373474121094,
],
result[16 - 1..]
);
}
#[test]
fn test_cv() {
let stats = common::test_data();
let result = cv(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
0.13683158257033826,
0.14210364752937538,
0.13768390530536678,
0.09902519643982984,
0.07398415562575059,
0.06952591506700934,
0.06889449679876426,
0.05658376599695556,
0.052287679715081685,
0.0516986237343169,
0.04825410158953634,
0.04520940441061039,
0.04691453064000403,
0.05386465089357498,
0.05676415631458615,
0.06236110606004932,
0.0652339267899012,
0.07239777237919846,
0.06725089364652528,
],
result[16 - 1..]
);
}
#[test]
fn test_quantile_even() {
let stats = common::test_data();
let result = quantile(&stats.close, 16, 90.0).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
58.77499961853027,
58.77499961853027,
54.10000038146973,
49.885000228881836,
48.44000053405762,
47.275001525878906,
47.275001525878906,
46.57000160217285,
45.96500015258789,
45.790000915527344,
45.790000915527344,
45.21500015258789,
45.65500068664551,
46.079999923706055,
46.459999084472656,
47.170000076293945,
47.98500061035156,
48.83500099182129,
49.34749984741211,
],
result[16 - 1..]
);
assert_eq!(
quantile(&stats.close, 16, 50.0).collect::<Vec<_>>()[16 - 1..],
median(&stats.close, 16).collect::<Vec<_>>()[16 - 1..]
);
}
#[test]
fn test_quantile_odd() {
let stats = common::test_data();
let result = quantile(&stats.close, 15, 90.0).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
58.97999954223633,
58.97999954223633,
54.83000030517577,
49.99800033569336,
48.61600036621094,
47.332001495361325,
47.332001495361325,
46.65400161743164,
46.002000427246095,
45.69000091552734,
45.258000183105466,
45.258000183105466,
45.06999969482422,
45.70000076293945,
46.119999694824216,
46.49599914550781,
47.27600021362305,
48.04200057983398,
48.948001098632815,
49.358000183105474,
],
result[15 - 1..]
);
assert_eq!(
quantile(&stats.close, 15, 50.0).collect::<Vec<_>>()[15 - 1..],
median(&stats.close, 15).collect::<Vec<_>>()[15 - 1..]
);
}
#[test]
fn test_median_even() {
let stats = common::test_data();
let result = median(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
46.07500076293945,
46.060001373291016,
45.875,
45.38999938964844,
44.76499938964844,
43.39999961853027,
42.545000076293945,
42.545000076293945,
42.36000061035156,
42.36000061035156,
42.36000061035156,
42.36000061035156,
42.36000061035156,
42.635000228881836,
42.635000228881836,
42.98500061035156,
43.795000076293945,
44.93499946594238,
45.65500068664551,
],
result[16 - 1..]
);
}
#[test]
fn test_median_odd() {
let stats = common::test_data();
let result = median(&stats.close, 15).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
46.150001525878906,
46.150001525878906,
45.970001220703125,
45.779998779296875,
45.0,
44.529998779296875,
42.27000045776367,
42.27000045776367,
42.27000045776367,
42.27000045776367,
42.27000045776367,
42.27000045776367,
42.27000045776367,
42.45000076293945,
42.45000076293945,
42.81999969482422,
43.150001525878906,
44.439998626708984,
45.43000030517578,
45.880001068115234,
],
result[15 - 1..]
);
}
#[test]
fn test_rank() {
let input = &[0., 2., 3., 2., 0., 2.];
assert_eq!(
rank(input, Some(RankMode::Min)).collect::<Vec<_>>(),
rank(input, None).collect::<Vec<_>>()
);
assert_eq!(
vec![1., 3., 6., 3., 1., 3.],
rank(input, None).collect::<Vec<_>>()
);
assert_eq!(
vec![2., 5., 6., 5., 2., 5.],
rank(input, Some(RankMode::Max)).collect::<Vec<_>>()
);
assert_eq!(
vec![1., 3., 6., 4., 2., 5.],
rank(input, Some(RankMode::Ordinal)).collect::<Vec<_>>()
);
assert_eq!(
vec![1.5, 4.0, 6.0, 4.0, 1.5, 4.0],
rank(input, Some(RankMode::Average)).collect::<Vec<_>>()
);
assert_eq!(
vec![1., 2., 3., 2., 1., 2.],
rank(input, Some(RankMode::Dense)).collect::<Vec<_>>()
);
}
#[test]
fn test_approx_entropy() {
let stats = common::test_data();
let result = approx_entropy(
&stats
.close
.iter()
.zip(&stats.close[1..])
.map(|(x, y)| (y / x).ln())
.collect::<Vec<f64>>(),
16,
Some(2),
Some(0.1),
)
.collect::<Vec<_>>();
assert_eq!(stats.close.len() - 1, result.len());
assert_eq!(
vec![
0.3899689516358784,
0.40809929232328257,
0.25004368014823874,
0.12031030800877052,
0.17403528234884807,
0.15900363263070655,
0.13096809113760582,
0.1104630098022307,
0.1194853281985502,
0.12858861838106073,
0.15395314742114657,
0.11830103980290227,
0.11462052987046589,
0.0758266584781783,
0.06679983850538206,
0.036712468860765346,
0.020434877610718875,
0.016727783315437166
],
result[16 - 1..]
);
let result = approx_entropy(
&stats
.close
.iter()
.zip(&stats.close[1..])
.map(|(x, y)| (y / x).ln())
.collect::<Vec<f64>>(),
16,
Some(2),
None,
)
.collect::<Vec<_>>();
assert_eq!(
vec![
0.06899287148695166,
0.06899287148695166,
0.06899287148695166,
0.06899287148695166,
0.023426752587707433,
0.023426752587707433,
0.11584637666236697,
0.11584637666236697,
0.023426752587707433,
0.023426752587707877,
0.11584637666236697,
0.11584637666236697,
0.11584637666236697,
0.11584637666236697,
0.20826600073702695,
0.18248579418728994,
0.18248579418728994,
0.18248579418728994
],
result[16 - 1..]
);
}
#[test]
fn test_sample_entropy() {
let stats = common::test_data();
let result = sample_entropy(
&stats
.close
.iter()
.zip(&stats.close[1..])
.map(|(x, y)| (y / x).ln())
.collect::<Vec<f64>>(),
16,
Some(2),
Some(0.1),
)
.collect::<Vec<_>>();
assert_eq!(stats.close.len() - 1, result.len());
assert_eq!(
vec![
0.5465437063680699,
0.503905180921417,
0.3764775712349121,
0.2876820724517809,
0.3483066942682157,
0.3184537311185346,
0.2799600263578706,
0.25452986513488046,
0.26469255422708216,
0.27570588140506525,
0.30010459245033816,
0.2635845208727204,
0.2612154992636177,
0.22040006536845885,
0.21007146974685703,
0.18026182383094402,
0.1643030512912763,
0.16077322058775173
],
result[16 - 1..]
);
let result = sample_entropy(
&stats
.close
.iter()
.zip(&stats.close[1..])
.map(|(x, y)| (y / x).ln())
.collect::<Vec<f64>>(),
16,
Some(2),
None,
)
.collect::<Vec<_>>();
assert_eq!(
vec![
-0.0,
-0.0,
-0.0,
-0.0,
36.7368005696771,
36.7368005696771,
37.42994775023705,
37.42994775023705,
36.7368005696771,
36.7368005696771,
37.42994775023705,
37.42994775023705,
37.42994775023705,
37.42994775023705,
37.83541285834521,
1.3862943611198906,
1.3862943611198906,
1.3862943611198906
],
result[16 - 1..]
);
}