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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
//! # Kand
//!
//! A high-performance technical analysis library for Rust, inspired by TA-Lib.
//!
//! ## Overview
//!
//! Kand provides a comprehensive suite of technical analysis tools for financial market data analysis.
//! Built with Rust's safety and performance in mind, it offers a modern alternative to traditional
//! technical analysis libraries.
//!
//! ## Features
//!
//! - **High Performance**: Written in pure Rust with zero dependencies on external C libraries
//! - **Type Safety**: Leverages Rust's type system to prevent common errors at compile time
//! - **Flexible Types**: Supports both standard (32-bit) and extended (64-bit) precision modes
//! - **Comprehensive Indicators**: Implements popular technical indicators including:
//! - Moving Averages (SMA, EMA, WMA)
//! - Momentum Indicators (RSI, MACD)
//! - Volume Indicators (OBV)
//! - And more...
//!
//! ## Quick Start
//!
//! ```rust
//! use kand::ohlcv::sma;
//!
//! // Input price data
//! let prices = vec![2.0, 4.0, 6.0, 8.0, 10.0];
//! let period = 3;
//! let mut sma_values = vec![0.0; prices.len()];
//!
//! // Calculate SMA
//! sma::sma(&prices, period, &mut sma_values).unwrap();
//! // First (period-1) values will be NaN, then: [NaN, NaN, 4.0, 6.0, 8.0]
//!
//! // Calculate next SMA value incrementally
//! let prev_sma = 8.0; // Last SMA value
//! let new_price = 12.0; // New price to include
//! let old_price = 6.0; // Oldest price to remove
//!
//! let next_sma = sma::sma_inc(prev_sma, new_price, old_price, period).unwrap();
//! // next_sma = 10.0 ((8.0 + 10.0 + 12.0) / 3)
//! ```
//!
//! ## Feature Flags
//!
//! Kand can be configured through feature flags:
//!
//! ### Precision Modes
//! - `default = ["extended", "check"]`: 64-bit precision with basic validation checks
//! - `standard = ["f32", "i32"]`: Standard precision mode using 32-bit types
//! - `extended = ["f64", "i64"]`: Extended precision mode using 64-bit types
//!
//! ### Type Selection
//! - `f32`: Use 32-bit floating point numbers
//! - `f64`: Use 64-bit floating point numbers
//! - `i32`: Use 32-bit integers
//! - `i64`: Use 64-bit integers
//!
//! ### Validation
//! - `check`: Enable basic validation checks
//! - `deep-check = ["check"]`: Enable extended validation (includes basic checks)
//!
//! ## Safety and Error Handling
//!
//! All functions in Kand return a `Result` type, properly handling edge cases and
//! invalid inputs. Common error cases include:
//!
//! - `InvalidParameter`: Invalid input parameters (e.g., period < 2)
//! - `InvalidData`: Empty or invalid input data
//! - `LengthMismatch`: Input and output slice lengths don't match
//! - `InsufficientData`: Not enough data points for calculation
//! - `NaNDetected`: NaN values in input data (with `deep-check` feature)
//!
//! ## Performance Considerations
//!
//! The library is optimized for both speed and memory usage:
//!
//! - Incremental calculation support for real-time updates
//! - Configurable precision modes (standard/extended)
//! - In-place calculations to minimize memory allocations
//! - Optional validation checks that can be disabled for maximum performance
pub use *;
pub use ;
/// Default floating-point precision type used across the library.
///
/// This type is determined by the enabled features:
/// - With feature "f64": Uses f64 (recommended for most cases)
/// - With feature "f32": Uses f32 (for memory-constrained environments)
/// - With no features enabled: Defaults to f64
///
/// The default configuration (feature "extended") provides f64 for:
/// - Higher precision calculations (15-17 decimal digits)
/// - Better handling of large price values
/// - More accurate technical indicator results
pub type TAFloat = f32;
pub type TAFloat = f64; // Default to f64 when no features are enabled
/// Default integer type used for indicator outputs.
///
/// This type is determined by the enabled features:
/// - With feature "i64": Uses i64 (recommended for most cases)
/// - With feature "i32": Uses i32 (for memory-constrained environments)
/// - With no features enabled: Defaults to i32
///
/// The default configuration (feature "extended") provides i64 for:
/// - Larger value range (-2^63 to 2^63-1)
/// - Better precision in accumulation operations
/// - Future-proof for high-frequency data analysis
pub type TAInt = i32;
pub type TAInt = i64; // Default to i64 when no features are enabled
/// Global EPSILON value used for floating-point comparisons
/// to account for rounding errors in calculations.
pub const EPSILON: TAFloat = 0.000_000_000_1; // 10^-10