fast-ta 0.2.1

High-performance technical analysis indicators with batch, prepared, and streaming APIs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use fast_ta::math_operators::{
    MAXINDEXConfig, ADD, DIV, MAX, MAXINDEX, MIN, MININDEX, MINMAX, MINMAXINDEX, MULT, SUB, SUM,
};
use fast_ta::{Float, OutputRange};

#[test]
fn arithmetic_operators_compute_expected_values() {
    let real0 = [8.0 as Float, 6.0 as Float, 4.0 as Float];
    let real1 = [2.0 as Float, 3.0 as Float, 4.0 as Float];
    let mut output = [0.0 as Float; 3];

    assert_eq!(
        ADD(&real0, &real1, &mut output).unwrap(),
        OutputRange::new(0, 3)
    );
    assert_eq!(output, [10.0 as Float, 9.0 as Float, 8.0 as Float]);

    SUB(&real0, &real1, &mut output).unwrap();
    assert_eq!(output, [6.0 as Float, 3.0 as Float, 0.0 as Float]);

    MULT(&real0, &real1, &mut output).unwrap();
    assert_eq!(output, [16.0 as Float, 18.0 as Float, 16.0 as Float]);

    DIV(&real0, &real1, &mut output).unwrap();
    assert_eq!(output, [4.0 as Float, 2.0 as Float, 1.0 as Float]);
}

#[test]
fn rolling_operators_compute_compact_outputs() {
    let real = [3.0 as Float, 1.0 as Float, 4.0 as Float, 2.0 as Float];
    let mut output = [0.0 as Float; 4];

    assert_eq!(SUM(&real, 2, &mut output).unwrap(), OutputRange::new(1, 3));
    assert_eq!(&output[..3], &[4.0 as Float, 5.0 as Float, 6.0 as Float]);

    MIN(&real, 2, &mut output).unwrap();
    assert_eq!(&output[..3], &[1.0 as Float, 1.0 as Float, 2.0 as Float]);

    MAX(&real, 2, &mut output).unwrap();
    assert_eq!(&output[..3], &[3.0 as Float, 4.0 as Float, 4.0 as Float]);
}

#[test]
fn extrema_index_functions_return_absolute_indexes() {
    let real = [3.0 as Float, 1.0 as Float, 4.0 as Float, 2.0 as Float];
    let mut min_idx = [0; 4];
    let mut max_idx = [0; 4];

    assert_eq!(
        MININDEX(&real, 2, &mut min_idx).unwrap(),
        OutputRange::new(1, 3)
    );
    assert_eq!(&min_idx[..3], &[1, 1, 3]);

    assert_eq!(
        MAXINDEX(&real, 2, &mut max_idx).unwrap(),
        OutputRange::new(1, 3)
    );
    assert_eq!(&max_idx[..3], &[0, 2, 2]);

    let mut min = [0.0 as Float; 4];
    let mut max = [0.0 as Float; 4];
    assert_eq!(
        MINMAX(&real, 2, &mut min, &mut max).unwrap(),
        OutputRange::new(1, 3)
    );
    assert_eq!(&min[..3], &[1.0 as Float, 1.0 as Float, 2.0 as Float]);
    assert_eq!(&max[..3], &[3.0 as Float, 4.0 as Float, 4.0 as Float]);

    MINMAXINDEX(&real, 2, &mut min_idx, &mut max_idx).unwrap();
    assert_eq!(&min_idx[..3], &[1, 1, 3]);
    assert_eq!(&max_idx[..3], &[0, 2, 2]);
}

#[test]
fn operators_reject_bad_lengths_periods_and_non_finite_inputs() {
    let mut output = [0.0 as Float; 3];
    assert!(ADD(&[1.0 as Float, 2.0 as Float], &[1.0 as Float], &mut output).is_err());
    assert!(SUB(
        &[1.0 as Float, Float::NAN],
        &[1.0 as Float, 2.0 as Float],
        &mut output
    )
    .is_err());
    assert!(SUM(&[1.0 as Float, 2.0 as Float], 0, &mut output).is_err());
    assert!(MAX(&[1.0 as Float], 2, &mut output).is_err());

    let mut min_output = [0.0 as Float; 3];
    let mut max_output = [0.0 as Float; 3];
    assert!(MINMAX(
        &[1.0 as Float, Float::INFINITY],
        2,
        &mut min_output,
        &mut max_output,
    )
    .is_err());

    assert!(MAXINDEXConfig::new(0).is_err());
}