use traquer::volatility;
mod common;
#[test]
fn test_mass() {
let stats = common::test_data();
let result = volatility::mass(&stats.high, &stats.low, 9, 6).collect::<Vec<_>>();
assert_eq!(stats.high.len(), result.len());
assert_eq!(
vec![
4.520707218752633,
4.57207750331251,
4.6318245383826735,
4.680054893601096,
4.7327145765178855,
4.827573448286292,
4.970401688240842,
5.218891609600159,
5.444846247296847,
5.597926479420781,
5.709803845941307,
5.942103734664013,
6.0808751147235265,
],
result[16 + 5..]
);
}
#[test]
fn test_keltner() {
let stats = common::test_data();
let result = volatility::keltner(&stats.high, &stats.low, &stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
(47.56628692851347, 59.468162424424115, 35.664411432602826,),
(46.57848825091722, 58.04149635667207, 35.115480145162365,),
(46.00690154148026, 57.3509719648747, 34.66283111808582,),
(45.4037367799079, 56.49630325960386, 34.31117030021194,),
(45.008003148804306, 55.66478439518065, 34.351221902427966,),
(44.75059097774783, 55.0210737433631, 34.480108212132556,),
(44.56228633635148, 54.38086398633625, 34.7437086863667,),
(44.313782151244176, 53.806199079574625, 34.82136522291373,),
(44.44510193405966, 53.81286787303401, 35.077335995085306,),
(44.66097215114639, 53.874502814302275, 35.4474414879905,),
(44.634975265918456, 53.59828520540664, 35.67166532643027,),
(44.78144888970631, 53.59205222500529, 35.97084555440733,),
(45.12480793361609, 53.8746234002416, 36.37499246699058,),
(45.30306575197284, 53.813517637493334, 36.79261386645234,),
(45.65211689383058, 54.034415479285585, 37.26981830837558,),
(46.09304449760097, 54.317699459612015, 37.86838953558993,),
(46.717392383280725, 55.14800620035773, 38.28677856620372,),
(47.02064012277067, 55.31809076701522, 38.72318947852612,),
],
result[16..]
);
}
#[test]
fn test_gri() {
let stats = common::test_data();
let result = volatility::gri(&stats.high, &stats.low, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
1.2845807635148472,
1.2882486699344737,
1.2944794556504038,
1.1807530970142432,
1.041478000063852,
0.9518387305144009,
0.9518387305144009,
0.9489937567570867,
0.8910945979665684,
0.8910945979665684,
0.8910945979665684,
0.8818302331128451,
0.8818302331128451,
0.9048239475184171,
0.9048239475184171,
0.9115406774766412,
0.9245547128348174,
1.0386539306425049,
1.0386539306425049,
],
result[15..]
);
}
#[test]
fn test_tr() {
let stats = common::test_data();
let result = volatility::tr(&stats.high, &stats.low, &stats.close).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
15.939998626708984,
15.10000228881836,
9.490001678466797,
8.650001525878906,
4.924999237060547,
7.349998474121094,
4.69000244140625,
3.3300018310546875,
3.6100006103515625,
4.1399993896484375,
2.5900001525878906,
3.279998779296875,
4.340000152587891,
2.3699989318847656,
2.5900001525878906,
2.8199996948242188,
2.4399986267089844,
4.780002593994141,
3.660003662109375,
2.0600013732910156,
2.2380027770996094,
1.5200004577636719,
2.3000030517578125,
3.7490005493164063,
3.450000762939453,
2.604999542236328,
3.2600021362304688,
3.918998718261726,
2.4599990844726563,
3.229999542236328,
2.9300003051757813,
5.759998321533203,
3.1500015258789063,
],
result[1..]
);
}
#[test]
fn test_atr() {
let stats = common::test_data();
let result = volatility::atr(&stats.high, &stats.low, &stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
5.950937747955322,
5.731504052877426,
5.672035211697221,
5.54628323984798,
5.32839062318817,
5.135241382807635,
4.909288824992387,
4.7462084641652265,
4.6838829694871755,
4.606765331577943,
4.481654969744092,
4.405301667649491,
4.374907733312755,
4.255225942760249,
4.191149292727504,
4.112327481005521,
4.215306908538501,
4.148725322122276,
],
result[16..]
);
}
#[test]
fn test_typical() {
let stats = common::test_data();
let result = volatility::typical(&stats.high, &stats.low, &stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
48.82131250699361,
48.41006247202555,
47.38204161326091,
45.67329160372416,
44.58475001653036,
43.98891671498617,
43.760937531789146,
43.422812620798744,
43.03031253814698,
42.92550015449524,
42.935500065485634,
42.83081253369649,
42.84727080663045,
43.15249999364217,
43.33354179064433,
43.67937509218853,
44.2075002193451,
44.90875029563905,
45.53729192415874,
],
result[15..]
);
}
#[test]
fn test_std_dev() {
let stats = common::test_data();
let result = volatility::std_dev(&stats.close, 16, None).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
13.25162572657857,
13.675877473717561,
12.89547461554456,
8.98517502012738,
6.557030792233012,
6.098639502630048,
6.016125848996605,
4.889473982961166,
4.488570530474252,
4.4357419509169445,
4.132481276694623,
3.8620698826696045,
4.012893026824987,
4.645152841708539,
4.91017049156476,
5.44108447177409,
5.768391548667223,
6.494713715395781,
6.118108066427051,
],
result[15..]
);
}
#[test]
fn test_bbands() {
let stats = common::test_data();
let result = volatility::bbands(&stats.close, 16, None, None).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
(61.674750993607375, 48.42312526702881, 35.17149954045024),
(61.24216440223103, 47.56628692851347, 33.89040945479591),
(59.473962866461775, 46.57848825091722, 33.68301363537266),
(54.99207656160764, 46.00690154148026, 37.02172652135288),
(51.96076757214092, 45.4037367799079, 38.84670598767489),
(51.106642651434356, 45.008003148804306, 38.909363646174256),
(50.76671682674443, 44.75059097774783, 38.734465128751225),
(49.45176031931264, 44.56228633635148, 39.67281235339031),
(48.80235268171843, 44.313782151244176, 39.82521162076992),
(48.8808438849766, 44.44510193405966, 40.009359983142716),
(48.793453427841015, 44.66097215114639, 40.52849087445176),
(48.49704514858806, 44.634975265918456, 40.772905383248855),
(48.794341916531295, 44.78144888970631, 40.76855586288133),
(49.76996077532463, 45.12480793361609, 40.47965509190755),
(50.2132362435376, 45.30306575197284, 40.392895260408075),
(51.09320136560467, 45.65211689383058, 40.21103242205649),
(51.861436046268196, 46.09304449760097, 40.324652948933746),
(53.21210609867651, 46.717392383280725, 40.22267866788494),
(53.13874818919772, 47.02064012277067, 40.902532056343624)
],
result[15..]
);
}
#[test]
fn test_donchian() {
let stats = common::test_data();
let result = volatility::donchian(&stats.high, &stats.low, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
(74.9000015258789, 57.290000915527344, 39.68000030517578),
(74.9000015258789, 57.11000061035156, 39.31999969482422),
(74.9000015258789, 56.80000114440918, 38.70000076293945),
(63.7599983215332, 50.55499839782715, 37.349998474121094),
(55.29999923706055, 46.32499885559082, 37.349998474121094),
(51.349998474121094, 44.349998474121094, 37.349998474121094),
(51.349998474121094, 44.349998474121094, 37.349998474121094),
(51.2400016784668, 44.295000076293945, 37.349998474121094),
(49.18000030517578, 43.26499938964844, 37.349998474121094),
(49.18000030517578, 43.26499938964844, 37.349998474121094),
(49.18000030517578, 43.26499938964844, 37.349998474121094),
(48.880001068115234, 43.114999771118164, 37.349998474121094),
(48.880001068115234, 43.114999771118164, 37.349998474121094),
(49.63899993896485, 43.49449920654297, 37.349998474121094),
(49.63899993896485, 43.49449920654297, 37.349998474121094),
(49.869998931884766, 43.60999870300293, 37.349998474121094),
(50.33000183105469, 43.84000015258789, 37.349998474121094),
(55.15999984741211, 46.2549991607666, 37.349998474121094),
(55.15999984741211, 46.2549991607666, 37.349998474121094)
],
result[15..]
);
}
#[test]
fn test_fbands() {
let stats = common::test_data();
let result = volatility::fbands(&stats.high, &stats.low).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
(74.9000015258789, 0.0,),
(74.9000015258789, 0.0,),
(74.9000015258789, 0.0,),
(74.9000015258789, 0.0,),
(74.9000015258789, 44.0,),
(74.9000015258789, 44.0,),
(74.9000015258789, 44.0,),
(74.9000015258789, 44.68000030517578,),
(49.18000030517578, 44.68000030517578,),
(49.18000030517578, 44.68000030517578,),
(49.18000030517578, 41.720001220703125,),
(49.18000030517578, 41.720001220703125,),
(49.18000030517578, 41.720001220703125,),
(49.18000030517578, 41.720001220703125,),
(49.18000030517578, 41.720001220703125,),
(49.18000030517578, 41.720001220703125,),
(49.18000030517578, 37.349998474121094,),
(49.18000030517578, 37.349998474121094,),
(49.18000030517578, 37.349998474121094,),
(44.060001373291016, 37.349998474121094,),
(44.060001373291016, 37.349998474121094,),
(44.060001373291016, 40.849998474121094,),
(44.060001373291016, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
(48.880001068115234, 40.849998474121094,),
],
result[4..]
);
}
#[test]
fn test_hv() {
let stats = common::test_data();
let result = volatility::hv(&stats.close, 16, None).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
1.5426523650567059,
1.0814850225220476,
1.0485549292793799,
0.9782010217271724,
0.8181908667315462,
0.7854803744652038,
0.6801589758647922,
0.6334127247577533,
0.6878195293244158,
0.6744749472856001,
0.6825716435084193,
0.6876958317470336,
0.6413496021691397,
0.618520803889366,
0.5858264543082782,
0.5264279426082943,
0.5334323440731333,
0.5205135758451463,
],
result[16..]
);
}
#[test]
fn test_starc() {
let stats = common::test_data();
let result =
volatility::starc(&stats.high, &stats.low, &stats.close, 16, 5, None).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
(49.147125053405766, 34.86487445831299,),
(48.29980422258377, 34.54419449567795,),
(47.66644210144878, 34.053557593375444,),
(47.2375398573, 33.92646008166485,),
(47.384068900413695, 34.595931404762084,),
(47.48828987299221, 35.16371055425388,),
(48.013147475000636, 36.2308542950189,),
(47.963450950455304, 36.572550636458764,),
(48.79866020425376, 37.55734107748453,),
(49.55411861151658, 38.49788181572952,),
(49.72798596369291, 38.972014036307094,),
(50.18236190962666, 39.609637907267874,),
(51.19588918842257, 40.696110628471956,),
(51.294270856654094, 41.0817285940295,),
(51.61537921230816, 41.55662090976215,),
(52.51279361807577, 42.643207663662515,),
(53.74036902266808, 43.623632442175676,),
(53.979470600169776, 44.02252982707631,),
],
result[16..]
);
}
#[test]
fn test_cvi() {
let stats = common::test_data();
let result = volatility::cvi(&stats.high, &stats.low, 16, 2).collect::<Vec<_>>();
assert_eq!(stats.high.len(), result.len());
assert_eq!(
vec![
-12.903778070881856,
-7.712487202835517,
-3.1188656632364697,
-9.341946193517892,
-12.034597148362437,
-12.814471005826123,
-13.271361266019388,
-6.439924966331101,
-2.0112332700986557,
-4.867518373670898,
-4.142244814924245,
0.7501021543131925,
-1.5573115591711928,
-4.07753627445564,
-2.062093533894327,
6.497958034939444,
5.52228653707274,
],
result[15 + 2..]
);
}
#[test]
fn test_relative_vol() {
let stats = common::test_data();
let result = volatility::relative_vol(&stats.close, 6, 10).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
28.460365094239744,
26.713556078390294,
30.72456832552668,
28.997752032109624,
33.13828781265631,
31.892848868843004,
34.49622014712077,
37.56620902000314,
41.13195840990312,
39.710861993052106,
43.70526288007951,
48.09010520437329,
44.653045101155534,
48.72492734457978,
53.15308104161818,
50.1657395923798,
53.718765471687156,
58.056260543528104,
62.43245885296475,
56.96821515395683,
],
result[5 + 9..]
);
}
#[test]
fn test_inertia() {
let stats = common::test_data();
let result = volatility::inertia(&stats.close, 6, 10).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
33.846695422163236,
37.0863925832691,
41.457100533424686,
46.70720708567886,
50.28458647020866,
54.88569652125601,
59.86174805509194,
60.99043440008858,
62.713158542656664,
66.72034985001046,
65.77887218682976,
66.53332690661519,
69.28895272009414,
73.87374050904741,
71.82880194892938,
],
result[10 + 9..]
);
}
#[test]
fn test_chop() {
let stats = common::test_data();
let result = volatility::chop(&stats.high, &stats.low, &stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
35.50305865709021,
29.36528182694797,
35.868470870431715,
46.723552778406344,
51.86692089009291,
50.1850201980578,
46.525910593875786,
50.565671194602146,
50.87870056760242,
50.759486846471894,
50.521735095671616,
51.03451151332367,
49.217489689326946,
47.77952890236684,
47.7727684616789,
46.73089304040272,
37.49049080789503,
37.995427183993165,
],
result[16..]
);
}
#[test]
fn test_vhf() {
let stats = common::test_data();
let result = volatility::vhf(&stats.high, &stats.low, &stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
0.5669216159971233,
0.7107794587594408,
0.5482664867838217,
0.4309723520119755,
0.40721343838432617,
0.44011310017913846,
0.5021691775026703,
0.4751003004570894,
0.4435695260250405,
0.4595960007629394,
0.4405808834558327,
0.4357521288992697,
0.4843910183060343,
0.5122550500601386,
0.5359587346575249,
0.5841583342518132,
0.7716635213608084,
0.7671760704973449,
],
result[16..]
);
}
#[test]
fn test_heikin_ashi() {
let stats = common::test_data();
let result = volatility::heikin_ashi(&stats.open, &stats.high, &stats.low, &stats.close)
.collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
(
47.44000053405762,
51.0,
45.34000015258789,
47.80500030517578,
),
(
47.6225004196167,
61.939998626708984,
46.08000183105469,
53.72749996185303,
),
(
50.67500019073486,
74.9000015258789,
50.67500019073486,
67.73250007629395,
),
(
59.203750133514404,
63.7599983215332,
55.619998931884766,
60.22249889373779,
),
(
59.7131245136261,
59.7131245136261,
49.099998474121094,
52.05999946594238,
),
(
55.88656198978424,
55.88656198978424,
44.39500045776367,
47.14875030517578,
),
(
51.51765614748001,
51.51765614748001,
44.0,
47.71374988555908,
),
(
49.61570301651955,
51.2400016784668,
46.54999923706055,
48.6200008392334,
),
(
49.11785192787647,
49.11785192787647,
45.099998474121094,
46.5024995803833,
),
(
47.81017575412989,
48.290000915527344,
44.68000030517578,
46.55250072479248,
),
(
47.18133823946118,
49.18000030517578,
45.040000915527344,
47.0575008392334,
),
(
47.11941953934729,
47.4900016784668,
44.900001525878906,
45.94750118255615,
),
(
46.53346036095172,
46.53346036095172,
41.720001220703125,
43.10200023651123,
),
(
44.817730298731476,
46.349998474121094,
42.0099983215332,
43.73499870300293,
),
(
44.2763645008672,
44.2763645008672,
42.15999984741211,
42.94000053405762,
),
(
43.60818251746241,
43.60818251746241,
39.68000030517578,
40.929999351501465,
),
(
42.26909093448194,
42.26909093448194,
39.31999969482422,
40.77499961853027,
),
(
41.522045276506105,
41.522045276506105,
38.70000076293945,
39.71875,
),
(
40.62039763825305,
42.130001068115234,
37.349998474121094,
40.0,
),
(
40.310198819126526,
43.83000183105469,
40.16999816894531,
41.36250019073486,
),
(
40.836349504930695,
42.56999969482422,
40.5099983215332,
41.5,
),
(
41.16817475246535,
44.060001373291016,
41.16817475246535,
42.692999839782715,
),
(
41.93058729612403,
43.970001220703125,
41.93058729612403,
43.0575008392334,
),
(
42.494044067678715,
42.63999938964844,
40.849998474121094,
41.894999504089355,
),
(
42.194521785884035,
46.19900131225586,
42.194521785884035,
44.31475067138672,
),
(
43.25463622863538,
48.880001068115234,
43.25463622863538,
46.76499938964844,
),
(
45.00981780914191,
46.755001068115234,
44.150001525878906,
45.20375061035156,
),
(
45.106784209746735,
47.70000076293945,
44.599998474121094,
45.76249980926514,
),
(
45.434642009505936,
49.63899993896485,
45.434642009505936,
47.417250633239746,
),
(
46.42594632137284,
48.70000076293945,
46.2400016784668,
47.50500011444092,
),
(
46.965473217906876,
49.869998931884766,
46.75,
47.97000026702881,
),
(
47.46773674246784,
50.33000183105469,
47.400001525878906,
48.71500110626221,
),
(
48.09136892436503,
55.15999984741211,
48.09136892436503,
52.81500053405762,
),
(
50.45318472921132,
51.099998474121094,
48.25,
49.9712495803833,
),
],
result
);
}
#[test]
fn test_wcp() {
let stats = common::test_data();
let result = volatility::wcp(&stats.high, &stats.low, &stats.close).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
47.08500003814697,
56.90499973297119,
67.08250045776367,
58.71999931335449,
50.75999927520752,
46.4037504196167,
49.0625,
47.942501068115234,
46.272499084472656,
47.02250099182129,
46.630001068115234,
45.597500801086426,
42.6245002746582,
44.35499858856201,
42.640000343322754,
40.44499969482422,
40.93499946594238,
39.4112491607666,
40.730000495910645,
41.44000053405762,
41.78999996185303,
42.880499839782715,
43.1800012588501,
42.09749984741211,
44.92725086212158,
46.82249927520752,
44.94624996185303,
46.015000343322754,
47.68975067138672,
47.05500030517578,
48.28999996185303,
49.13250160217285,
51.915000915527344,
49.48499870300293,
],
result
);
}
#[test]
fn test_cc_hv() {
let stats = common::test_data();
let result = volatility::cc_hv(&stats.close, 16).collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
1.5466252225674613,
1.1600956142944576,
1.1377538069208708,
1.0365183751845641,
0.8333933231891163,
0.7886313354821333,
0.6976132908975086,
0.6413848562022525,
0.6878616751364196,
0.6750178844345274,
0.6835988364394175,
0.6879642217531283,
0.6532534112956555,
0.6202239625971376,
0.6004459227341106,
0.5665520605752907,
0.5773661957866805,
0.5683025268885697
],
result[16..]
);
}
#[test]
fn test_gkyz_hv() {
let stats = common::test_data();
let result = volatility::gkyz_hv(&stats.open, &stats.high, &stats.low, &stats.close, 16)
.collect::<Vec<_>>();
assert_eq!(stats.close.len(), result.len());
assert_eq!(
vec![
1.2449176146400096,
1.1032341200989624,
0.9166361517142042,
0.9043585332042633,
0.8544447166060107,
0.8287797413114523,
0.7613077936213194,
0.744867758696185,
0.7420973336106507,
0.7402566589618695,
0.7225740295183557,
0.7325311315992543,
0.7480130797826274,
0.7207898315110103,
0.7295291396594658,
0.7351330923035614,
0.8608114872074828,
0.8604757592723771
],
result[16..]
);
}