fast-ta 0.1.0

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
100
101
102
103
104
105
106
107
108
109
110
111
112

//! CDLENGULFING local definition and concrete execution types.

use super::engine::{CandleColor, PatternDefinition, RecognitionContext, WideCandle};
use super::{CandleSettingType, CandleSettings, PatternDirection, PatternSignal, PatternStrength};

// Setting-free: owned Candle Settings do not affect its fixed Lookback or results.
define_pattern_config!(
    CDLENGULFINGConfig,
    CDLENGULFINGBatchRunner,
    CDLENGULFINGStream
);

#[inline]
fn engulfing_signal(
    current: WideCandle,
    previous: WideCandle,
    current_color: CandleColor,
    previous_color: CandleColor,
) -> PatternSignal {
    let bullish = current_color == CandleColor::White
        && previous_color == CandleColor::Black
        && ((current.close >= previous.open && current.open < previous.close)
            || (current.close > previous.open && current.open <= previous.close));
    let bearish = current_color == CandleColor::Black
        && previous_color == CandleColor::White
        && ((current.open >= previous.close && current.close < previous.open)
            || (current.open > previous.close && current.close <= previous.open));

    if !bullish && !bearish {
        return PatternSignal::NoMatch;
    }

    let direction = if current_color == CandleColor::White {
        PatternDirection::Bullish
    } else {
        PatternDirection::Bearish
    };
    let strength = if current.open != previous.close && current.close != previous.open {
        PatternStrength::Standard
    } else {
        PatternStrength::Partial
    };
    PatternSignal::Match {
        direction,
        strength,
    }
}

impl CDLENGULFINGConfig {
    /// Returns the Warm-up tick count, identical to Lookback.
    #[inline]
    pub fn warm_up(&self) -> usize {
        super::engine::maximum_average_period(self.candle_settings, &[]) + 2
    }
}

impl PatternDefinition for CDLENGULFINGConfig {
    type State = ();

    fn name(&self) -> &'static str {
        "CDLENGULFING"
    }

    fn settings(&self) -> CandleSettings {
        self.candle_settings
    }

    fn referenced_settings(&self) -> &'static [CandleSettingType] {
        &[]
    }

    fn lookback(&self) -> usize {
        2
    }

    fn transition_start(&self) -> usize {
        2
    }

    fn initial_state(&self) -> Self::State {}

    fn transition(
        &self,
        context: &RecognitionContext<'_>,
        _state: &mut Self::State,
    ) -> PatternSignal {
        engulfing_signal(
            context.candle(0),
            context.candle(1),
            context.color(0),
            context.color(1),
        )
    }

    fn compute_batch_into(
        &self,
        input: super::CandleInput<'_>,
        output: &mut [PatternSignal],
    ) -> bool {
        for (output_value, source_index) in output.iter_mut().zip(self.lookback()..input.len()) {
            let current = input.candle(source_index);
            let previous = input.candle(source_index - 1);
            *output_value = engulfing_signal(
                current.into(),
                previous.into(),
                current.color(),
                previous.color(),
            );
        }
        true
    }
}