diff --git a/CHANGELOG.md b/CHANGELOG.md index 18c04a29..64cb9466 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] +- **Modified MA Stop** — Modified MA Stop — SMMA-ratcheted trailing stop with directional flip (`MODIFIED_MA_STOP`). +- **Time-Based Stop** — Time-Based Stop — bar-count timer that fires after a fixed holding period (`TIME_BASED_STOP`). +- **NRTR** — NRTR (Nick Rypock Trailing Reverse) — percentage trailing-reverse stop (`NRTR`). +- **ATR Ratchet** — ATR Ratchet — Kaufman per-bar tightening volatility trailing stop (`ATR_RATCHET`). +- **Elder SafeZone** — Elder SafeZone Stop — average noise-penetration trailing stop with directional flip (`ELDER_SAFE_ZONE`). +- **Kase DevStop** — Kase DevStop volatility trailing stop using standard-deviation of two-bar true range (`KASE_DEV_STOP`). ## [0.6.1] - 2026-06-07 - **Projection Oscillator** — Widner projection oscillator: close position inside the projection bands, scaled 0..100 (`ProjectionOscillator`). diff --git a/README.md b/README.md index 82e22c8f..5a2161aa 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

- Wickra — streaming-first technical indicators + Wickra — streaming-first technical indicators

[![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml) @@ -48,7 +48,7 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**: [Node](https://docs.wickra.org/Quickstart-Node), [WASM](https://docs.wickra.org/Quickstart-WASM). - **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for - every one of the 434 indicators; start at the + every one of the 440 indicators; start at the [indicators overview](https://docs.wickra.org/Indicators-Overview). - **Reference** — [warmup periods](https://docs.wickra.org/Warmup-Periods), [streaming vs batch](https://docs.wickra.org/Streaming-vs-Batch), @@ -79,7 +79,7 @@ Plenty of TA libraries are fast. Each one forces a trade-off Wickra does not: | finta | clean | no | Python | ~80 | stale | | talipp | clean | yes | Python | ~40 | yes | -Wickra's edge is **breadth with reach**: 434 indicators that all update in O(1) +Wickra's edge is **breadth with reach**: 440 indicators that all update in O(1) per tick and ship natively to Python, Node.js, WebAssembly and Rust from a single engine. @@ -188,7 +188,7 @@ python -m benchmarks.compare_libraries ## Indicators -434 streaming-first indicators across twenty-four families. Every one passes the +440 streaming-first indicators across twenty-four families. Every one passes the `batch == streaming` equivalence test, reference-value tests, and reset semantics tests. Each has a per-indicator deep dive (formula, parameters, warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview). @@ -201,7 +201,7 @@ warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview). | Price Oscillators | PPO, DPO, Coppock, Accelerator Oscillator, Balance of Power, APO, AO Histogram, CFO, Zero-Lag MACD, Elder Impulse, STC, TSF Oscillator, MACD Histogram, PPO Histogram | | Volatility & Bands | ATR, Bollinger Bands, Keltner Channels, Donchian Channels, NATR, StdDev, Ulcer Index, Historical Volatility, Bollinger Bandwidth, %B, True Range, Chaikin Volatility, RVI (Relative Volatility Index), Parkinson Volatility, Garman-Klass Volatility, Rogers-Satchell Volatility, Yang-Zhang Volatility, Volatility Cone | | Bands & Channels | MA Envelope, Acceleration Bands, STARC Bands, ATR Bands, Hurst Channel, LinReg Channel, Standard Error Bands, Double Bollinger Bands, TTM Squeeze, Fractal Chaos Bands, VWAP StdDev Bands, Quartile Bands, Bomar Bands, Median Channel, Projection Bands, Projection Oscillator | -| Trailing Stops | Parabolic SAR, Parabolic SAR Extended (SAREXT), SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop, HiLo Activator, Volty Stop, Yo-Yo Exit, Donchian Channel Stop, Percentage Trailing Stop, Step Trailing Stop, Renko Trailing Stop | +| Trailing Stops | Parabolic SAR, Parabolic SAR Extended (SAREXT), SuperTrend, Chandelier Exit, Chande Kroll Stop, ATR Trailing Stop, HiLo Activator, Volty Stop, Yo-Yo Exit, Donchian Channel Stop, Percentage Trailing Stop, Step Trailing Stop, Renko Trailing Stop, Kase DevStop, Elder SafeZone, ATR Ratchet, NRTR, Time-Based Stop, Modified MA Stop | | Volume | OBV, VWAP (cumulative + rolling), ADL, Volume-Price Trend, Chaikin Money Flow, Chaikin Oscillator, Force Index, Ease of Movement, Klinger Volume Oscillator, Volume Oscillator, NVI, PVI, Williams A/D, Anchored VWAP, Demand Index, TSV, VZO, Market Facilitation Index | | Price Statistics | Typical Price, Median Price, Weighted Close, Linear Regression, Linear Regression Slope, Z-Score, Linear Regression Angle, Variance, Coefficient of Variation, Skewness, Kurtosis, Standard Error, Detrended StdDev, R², Median Absolute Deviation, Autocorrelation, Hurst Exponent, Pearson Correlation, Beta, Pairwise Beta, Pair Spread Z-Score, Lead-Lag Cross-Correlation, Cointegration, Relative Strength A-vs-B, Spearman Correlation, Mid Price, Mid Point, Average Price, Linear Regression Intercept, Time Series Forecast, Rolling Correlation, Rolling Covariance, OU Half-Life, Spread Hurst, Distance SSD, Beta-Neutral Spread, Variance Ratio, Granger Causality, Kalman Hedge Ratio, Spread Bollinger Bands, Spread AR(1) Coefficient | | Ehlers / Cycle (DSP) | MAMA, FAMA, Fisher Transform, Inverse Fisher Transform, SuperSmoother, Hilbert Dominant Cycle, Hilbert Phasor, Hilbert DC Phase, Hilbert Trend Mode, Sine Wave, Decycler, Decycler Oscillator, Roofing Filter, Center of Gravity, Cybernetic Cycle, Adaptive Cycle, Empirical Mode Decomposition, Ehlers Stochastic, Instantaneous Trendline | @@ -297,7 +297,7 @@ A Python live-trading example using the public `websockets` package lives at ``` wickra/ ├── crates/ -│ ├── wickra-core/ core engine + all 434 indicators +│ ├── wickra-core/ core engine + all 440 indicators │ ├── wickra/ top-level facade crate (publishes on crates.io) + benches/ │ ├── wickra-data/ CSV reader, tick aggregator, live exchange feeds │ └── wickra-bench/ internal cross-library benchmark harness (not published) diff --git a/bindings/node/__tests__/indicators.test.js b/bindings/node/__tests__/indicators.test.js index 9c4621c4..e89c64c8 100644 --- a/bindings/node/__tests__/indicators.test.js +++ b/bindings/node/__tests__/indicators.test.js @@ -356,6 +356,7 @@ const candleScalar = { Qstick: { make: () => new wickra.Qstick(10), step: (ind, i) => ind.update(open[i], close[i]), batch: (ind) => ind.batch(open, close) }, VolatilityRatio: { make: () => new wickra.VolatilityRatio(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, ProjectionOscillator: { make: () => new wickra.ProjectionOscillator(14), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, + TimeBasedStop: { make: () => new wickra.TimeBasedStop(5), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, }; for (const [name, d] of Object.entries(candleScalar)) { @@ -447,6 +448,11 @@ const multi = { BomarBands: { make: () => new wickra.BomarBands(4, 0.85), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) }, MedianChannel: { make: () => new wickra.MedianChannel(5, 2.0), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(close[i]), batch: (ind) => ind.batch(close) }, ProjectionBands: { make: () => new wickra.ProjectionBands(3), fields: ['upper', 'middle', 'lower'], step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) }, + KaseDevStop: { make: () => new wickra.KaseDevStop(3, 1.0), fields: ['value', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, + ElderSafeZone: { make: () => new wickra.ElderSafeZone(14, 2.0), fields: ['value', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, + AtrRatchet: { make: () => new wickra.AtrRatchet(14, 4.0, 0.1), fields: ['value', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, + Nrtr: { make: () => new wickra.Nrtr(2.0), fields: ['value', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, + ModifiedMaStop: { make: () => new wickra.ModifiedMaStop(14), fields: ['value', 'direction'], step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) }, }; for (const [name, d] of Object.entries(multi)) { diff --git a/bindings/node/index.d.ts b/bindings/node/index.d.ts index c765a89a..50234a86 100644 --- a/bindings/node/index.d.ts +++ b/bindings/node/index.d.ts @@ -149,6 +149,26 @@ export interface DonchianStopValue { stopLong: number stopShort: number } +export interface KaseDevStopValue { + value: number + direction: number +} +export interface ElderSafeZoneValue { + value: number + direction: number +} +export interface AtrRatchetValue { + value: number + direction: number +} +export interface NrtrValue { + value: number + direction: number +} +export interface ModifiedMaStopValue { + value: number + direction: number +} /** Vortex Indicator pair: `VI+` and `VI-`. */ export interface VortexValue { plus: number @@ -1668,6 +1688,15 @@ export declare class ProjectionOscillator { isReady(): boolean warmupPeriod(): number } +export type TimeBasedStopNode = TimeBasedStop +export declare class TimeBasedStop { + constructor(maxBars: number) + update(high: number, low: number, close: number): number | null + batch(high: Array, low: Array, close: Array): Array + reset(): void + isReady(): boolean + warmupPeriod(): number +} export type StochNode = Stochastic export declare class Stochastic { constructor(kPeriod: number, dPeriod: number) @@ -2328,6 +2357,71 @@ export declare class RenkoTrailingStop { isReady(): boolean warmupPeriod(): number } +export type KaseDevStopNode = KaseDevStop +export declare class KaseDevStop { + constructor(period: number, dev: number) + update(high: number, low: number, close: number): KaseDevStopValue | null + /** + * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + * Warmup positions are `NaN`. + */ + batch(high: Array, low: Array, close: Array): Array + reset(): void + isReady(): boolean + warmupPeriod(): number +} +export type ElderSafeZoneNode = ElderSafeZone +export declare class ElderSafeZone { + constructor(period: number, coeff: number) + update(high: number, low: number, close: number): ElderSafeZoneValue | null + /** + * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + * Warmup positions are `NaN`. + */ + batch(high: Array, low: Array, close: Array): Array + reset(): void + isReady(): boolean + warmupPeriod(): number +} +export type AtrRatchetNode = AtrRatchet +export declare class AtrRatchet { + constructor(atrPeriod: number, startMult: number, increment: number) + update(high: number, low: number, close: number): AtrRatchetValue | null + /** + * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + * Warmup positions are `NaN`. + */ + batch(high: Array, low: Array, close: Array): Array + reset(): void + isReady(): boolean + warmupPeriod(): number +} +export type NrtrNode = Nrtr +export declare class Nrtr { + constructor(pct: number) + update(high: number, low: number, close: number): NrtrValue | null + /** + * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + * Warmup positions are `NaN`. + */ + batch(high: Array, low: Array, close: Array): Array + reset(): void + isReady(): boolean + warmupPeriod(): number +} +export type ModifiedMaStopNode = ModifiedMaStop +export declare class ModifiedMaStop { + constructor(period: number) + update(high: number, low: number, close: number): ModifiedMaStopValue | null + /** + * Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + * Warmup positions are `NaN`. + */ + batch(high: Array, low: Array, close: Array): Array + reset(): void + isReady(): boolean + warmupPeriod(): number +} export type TypicalPriceNode = TypicalPrice export declare class TypicalPrice { constructor() diff --git a/bindings/node/index.js b/bindings/node/index.js index 4575a232..4c0339a6 100644 --- a/bindings/node/index.js +++ b/bindings/node/index.js @@ -310,7 +310,7 @@ if (!nativeBinding) { throw new Error(`Failed to load native binding`) } -const { version, SMA, EMA, WMA, RSI, DEMA, TEMA, HMA, ROC, TRIX, SMMA, TRIMA, ZLEMA, MOM, CMO, DPO, StdDev, UlcerIndex, VerticalHorizontalFilter, ZScore, McGinleyDynamic, FRAMA, SuperSmoother, FisherTransform, Decycler, CenterOfGravity, CyberneticCycle, InstantaneousTrendline, EhlersStochastic, RVIVolatility, Variance, CoefficientOfVariation, Skewness, Kurtosis, StandardError, DetrendedStdDev, RSquared, MedianAbsoluteDeviation, MIDPOINT, ROCP, ROCR, ROCR100, LINEARREG_INTERCEPT, TSF, LogReturn, RealizedVolatility, RollingIqr, RollingPercentileRank, TrendLabel, WinRate, Expectancy, SWMA, GMA, EHMA, MedianMA, AdaptiveLaguerre, DisparityIndex, FisherRSI, RSX, DynamicMomentumIndex, TREND_STRENGTH_INDEX, TsfOscillator, BipowerVariation, EwmaVolatility, Garch11, VolatilityOfVolatility, VolatilityCone, JumpIndicator, RegimeLabel, RollingQuantile, Autocorrelation, HurstExponent, PearsonCorrelation, Beta, PairwiseBeta, SpreadAr1Coefficient, SpearmanCorrelation, RollingCorrelation, RollingCovariance, OuHalfLife, SpreadHurst, DistanceSsd, BetaNeutralSpread, PairSpreadZScore, LeadLagCrossCorrelation, Cointegration, RelativeStrengthAB, VarianceRatio, GrangerCausality, KalmanHedgeRatio, SpreadBollingerBands, MACD, MACDFIX, MACDEXT, BollingerBands, ATR, PLUS_DM, MINUS_DM, PLUS_DI, MINUS_DI, DX, MIDPRICE, AVGPRICE, SAREXT, HT_PHASOR, CloseVsOpen, BodySizePct, WickRatio, HighLowRange, StochasticCCI, IMI, QQE, ElderRay, TTM_TREND, Qstick, POLARIZED_FRACTAL_EFFICIENCY, WAVE_PM, GatorOscillator, KasePermissionStochastic, VolatilityRatio, ProjectionOscillator, Stochastic, OBV, ADX, ADXR, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, Inertia, ConnorsRSI, LaguerreRSI, SMI, KST, PGO, RVI, AwesomeOscillatorHistogram, STC, ElderImpulse, ZeroLagMACD, CFO, APO, KAMA, EVWMA, Alligator, JMA, VIDYA, ALMA, T3, GD, HoltWinters, RMI, DerivativeOscillator, MacdHistogram, PpoHistogram, TSI, PMO, TII, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, NVI, PVI, VolumeOscillator, KVO, WilliamsAD, AnchoredRSI, AnchoredVWAP, DemandIndex, TSV, VZO, MarketFacilitationIndex, EaseOfMovement, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, HiLoActivator, VoltyStop, YoyoExit, DonchianStop, PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, YangZhangVolatility, RogersSatchellVolatility, GarmanKlassVolatility, ParkinsonVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, WaveTrend, RWI, Vortex, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA, MaEnvelope, AccelerationBands, StarcBands, AtrBands, HurstChannel, LinRegChannel, StandardErrorBands, QuartileBands, BomarBands, MedianChannel, ProjectionBands, DoubleBollinger, TtmSqueeze, FractalChaosBands, VwapStdDevBands, ClassicPivots, FibonacciPivots, Camarilla, WoodiePivots, DemarkPivots, WilliamsFractals, ZigZag, TDSetup, TDSequential, TDDeMarker, TDREI, TDPressure, TDCombo, TDCountdown, TDLines, TDRangeProjection, TDDifferential, TDOpen, TDRiskLevel, InverseFisherTransform, DecyclerOscillator, RoofingFilter, EmpiricalModeDecomposition, HT_DCPHASE, HT_TRENDMODE, HilbertDominantCycle, AdaptiveCycle, SineWave, MAMA, FAMA, Ichimoku, HeikinAshi, ValueArea, VolumeProfile, TpoProfile, InitialBalance, OpeningRange, Doji, Hammer, InvertedHammer, HangingMan, ShootingStar, Engulfing, Harami, MorningEveningStar, ThreeSoldiersOrCrows, PiercingDarkCloud, Marubozu, Tweezer, SpinningTop, ThreeInside, ThreeOutside, TwoCrows, UpsideGapTwoCrows, IdenticalThreeCrows, ThreeLineStrike, ThreeStarsInSouth, AbandonedBaby, AdvanceBlock, BeltHold, Breakaway, Counterattack, DojiStar, DragonflyDoji, GravestoneDoji, LongLeggedDoji, RickshawMan, EveningDojiStar, MorningDojiStar, GapSideBySideWhite, HighWave, Hikkake, HikkakeModified, HomingPigeon, OnNeck, InNeck, Thrusting, SeparatingLines, Kicking, KickingByLength, LadderBottom, MatHold, MatchingLow, LongLine, ShortLine, RisingThreeMethods, FallingThreeMethods, UpsideGapThreeMethods, DownsideGapThreeMethods, StalledPattern, StickSandwich, Takuri, ClosingMarubozu, OpeningMarubozu, TasukiGap, UniqueThreeRiver, ConcealingBabySwallow, DoubleTopBottom, TripleTopBottom, HeadAndShoulders, Triangle, Wedge, FlagPennant, RectangleRange, CupAndHandle, Abcd, Gartley, Butterfly, Bat, Crab, Shark, Cypher, ThreeDrives, OrderBookImbalanceTop1, OrderBookImbalanceFull, Microprice, QuotedSpread, DepthSlope, OrderBookImbalanceTopN, SignedVolume, CumulativeVolumeDelta, TradeImbalance, OrderFlowImbalance, Vpin, AmihudIlliquidity, RollMeasure, EffectiveSpread, RealizedSpread, KylesLambda, Footprint, FundingRate, FundingRateMean, FundingRateZScore, FundingBasis, OpenInterestDelta, OIPriceDivergence, OIWeighted, LongShortRatio, TakerBuySellRatio, LiquidationFeatures, TermStructureBasis, CalendarSpread, AdvanceDecline, AdvanceDeclineRatio, AdVolumeLine, McClellanOscillator, McClellanSummationIndex, Trin, BreadthThrust, NewHighsNewLows, HighLowIndex, PercentAboveMa, UpDownVolumeRatio, BullishPercentIndex, CumulativeVolumeIndex, AbsoluteBreadthIndex, TickIndex, SharpeRatio, SortinoRatio, CalmarRatio, OmegaRatio, MaxDrawdown, AverageDrawdown, DrawdownDuration, PainIndex, ValueAtRisk, ConditionalValueAtRisk, ProfitFactor, GainLossRatio, RecoveryFactor, KellyCriterion, TreynorRatio, InformationRatio, RenkoBars, KagiBars, PointAndFigureBars, Alpha, SessionVwap, OvernightGap, SeasonalZScore, TimeOfDayReturnProfile, IntradayVolatilityProfile, VolumeByTimeProfile, DayOfWeekProfile, AverageDailyRange, TurnOfMonth, SessionHighLow, SessionRange, OvernightIntradayReturn, FibRetracement, FibExtension, FibProjection, AutoFib, GoldenPocket, FibConfluence, FibFan, FibArcs, FibChannel, FibTimeZones } = nativeBinding +const { version, SMA, EMA, WMA, RSI, DEMA, TEMA, HMA, ROC, TRIX, SMMA, TRIMA, ZLEMA, MOM, CMO, DPO, StdDev, UlcerIndex, VerticalHorizontalFilter, ZScore, McGinleyDynamic, FRAMA, SuperSmoother, FisherTransform, Decycler, CenterOfGravity, CyberneticCycle, InstantaneousTrendline, EhlersStochastic, RVIVolatility, Variance, CoefficientOfVariation, Skewness, Kurtosis, StandardError, DetrendedStdDev, RSquared, MedianAbsoluteDeviation, MIDPOINT, ROCP, ROCR, ROCR100, LINEARREG_INTERCEPT, TSF, LogReturn, RealizedVolatility, RollingIqr, RollingPercentileRank, TrendLabel, WinRate, Expectancy, SWMA, GMA, EHMA, MedianMA, AdaptiveLaguerre, DisparityIndex, FisherRSI, RSX, DynamicMomentumIndex, TREND_STRENGTH_INDEX, TsfOscillator, BipowerVariation, EwmaVolatility, Garch11, VolatilityOfVolatility, VolatilityCone, JumpIndicator, RegimeLabel, RollingQuantile, Autocorrelation, HurstExponent, PearsonCorrelation, Beta, PairwiseBeta, SpreadAr1Coefficient, SpearmanCorrelation, RollingCorrelation, RollingCovariance, OuHalfLife, SpreadHurst, DistanceSsd, BetaNeutralSpread, PairSpreadZScore, LeadLagCrossCorrelation, Cointegration, RelativeStrengthAB, VarianceRatio, GrangerCausality, KalmanHedgeRatio, SpreadBollingerBands, MACD, MACDFIX, MACDEXT, BollingerBands, ATR, PLUS_DM, MINUS_DM, PLUS_DI, MINUS_DI, DX, MIDPRICE, AVGPRICE, SAREXT, HT_PHASOR, CloseVsOpen, BodySizePct, WickRatio, HighLowRange, StochasticCCI, IMI, QQE, ElderRay, TTM_TREND, Qstick, POLARIZED_FRACTAL_EFFICIENCY, WAVE_PM, GatorOscillator, KasePermissionStochastic, VolatilityRatio, ProjectionOscillator, TimeBasedStop, Stochastic, OBV, ADX, ADXR, CCI, WilliamsR, MFI, PSAR, Keltner, Donchian, VWAP, RollingVWAP, AwesomeOscillator, Aroon, Inertia, ConnorsRSI, LaguerreRSI, SMI, KST, PGO, RVI, AwesomeOscillatorHistogram, STC, ElderImpulse, ZeroLagMACD, CFO, APO, KAMA, EVWMA, Alligator, JMA, VIDYA, ALMA, T3, GD, HoltWinters, RMI, DerivativeOscillator, MacdHistogram, PpoHistogram, TSI, PMO, TII, ADL, VolumePriceTrend, ChaikinMoneyFlow, ChaikinOscillator, ForceIndex, NVI, PVI, VolumeOscillator, KVO, WilliamsAD, AnchoredRSI, AnchoredVWAP, DemandIndex, TSV, VZO, MarketFacilitationIndex, EaseOfMovement, SuperTrend, ChandelierExit, ChandeKrollStop, AtrTrailingStop, HiLoActivator, VoltyStop, YoyoExit, DonchianStop, PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, KaseDevStop, ElderSafeZone, AtrRatchet, Nrtr, ModifiedMaStop, TypicalPrice, MedianPrice, WeightedClose, LinearRegression, LinRegSlope, AcceleratorOscillator, BalanceOfPower, ChoppinessIndex, TrueRange, ChaikinVolatility, YangZhangVolatility, RogersSatchellVolatility, GarmanKlassVolatility, ParkinsonVolatility, LinRegAngle, BollingerBandwidth, PercentB, NATR, HistoricalVolatility, AroonOscillator, WaveTrend, RWI, Vortex, MassIndex, StochRSI, UltimateOscillator, PPO, Coppock, VWMA, MaEnvelope, AccelerationBands, StarcBands, AtrBands, HurstChannel, LinRegChannel, StandardErrorBands, QuartileBands, BomarBands, MedianChannel, ProjectionBands, DoubleBollinger, TtmSqueeze, FractalChaosBands, VwapStdDevBands, ClassicPivots, FibonacciPivots, Camarilla, WoodiePivots, DemarkPivots, WilliamsFractals, ZigZag, TDSetup, TDSequential, TDDeMarker, TDREI, TDPressure, TDCombo, TDCountdown, TDLines, TDRangeProjection, TDDifferential, TDOpen, TDRiskLevel, InverseFisherTransform, DecyclerOscillator, RoofingFilter, EmpiricalModeDecomposition, HT_DCPHASE, HT_TRENDMODE, HilbertDominantCycle, AdaptiveCycle, SineWave, MAMA, FAMA, Ichimoku, HeikinAshi, ValueArea, VolumeProfile, TpoProfile, InitialBalance, OpeningRange, Doji, Hammer, InvertedHammer, HangingMan, ShootingStar, Engulfing, Harami, MorningEveningStar, ThreeSoldiersOrCrows, PiercingDarkCloud, Marubozu, Tweezer, SpinningTop, ThreeInside, ThreeOutside, TwoCrows, UpsideGapTwoCrows, IdenticalThreeCrows, ThreeLineStrike, ThreeStarsInSouth, AbandonedBaby, AdvanceBlock, BeltHold, Breakaway, Counterattack, DojiStar, DragonflyDoji, GravestoneDoji, LongLeggedDoji, RickshawMan, EveningDojiStar, MorningDojiStar, GapSideBySideWhite, HighWave, Hikkake, HikkakeModified, HomingPigeon, OnNeck, InNeck, Thrusting, SeparatingLines, Kicking, KickingByLength, LadderBottom, MatHold, MatchingLow, LongLine, ShortLine, RisingThreeMethods, FallingThreeMethods, UpsideGapThreeMethods, DownsideGapThreeMethods, StalledPattern, StickSandwich, Takuri, ClosingMarubozu, OpeningMarubozu, TasukiGap, UniqueThreeRiver, ConcealingBabySwallow, DoubleTopBottom, TripleTopBottom, HeadAndShoulders, Triangle, Wedge, FlagPennant, RectangleRange, CupAndHandle, Abcd, Gartley, Butterfly, Bat, Crab, Shark, Cypher, ThreeDrives, OrderBookImbalanceTop1, OrderBookImbalanceFull, Microprice, QuotedSpread, DepthSlope, OrderBookImbalanceTopN, SignedVolume, CumulativeVolumeDelta, TradeImbalance, OrderFlowImbalance, Vpin, AmihudIlliquidity, RollMeasure, EffectiveSpread, RealizedSpread, KylesLambda, Footprint, FundingRate, FundingRateMean, FundingRateZScore, FundingBasis, OpenInterestDelta, OIPriceDivergence, OIWeighted, LongShortRatio, TakerBuySellRatio, LiquidationFeatures, TermStructureBasis, CalendarSpread, AdvanceDecline, AdvanceDeclineRatio, AdVolumeLine, McClellanOscillator, McClellanSummationIndex, Trin, BreadthThrust, NewHighsNewLows, HighLowIndex, PercentAboveMa, UpDownVolumeRatio, BullishPercentIndex, CumulativeVolumeIndex, AbsoluteBreadthIndex, TickIndex, SharpeRatio, SortinoRatio, CalmarRatio, OmegaRatio, MaxDrawdown, AverageDrawdown, DrawdownDuration, PainIndex, ValueAtRisk, ConditionalValueAtRisk, ProfitFactor, GainLossRatio, RecoveryFactor, KellyCriterion, TreynorRatio, InformationRatio, RenkoBars, KagiBars, PointAndFigureBars, Alpha, SessionVwap, OvernightGap, SeasonalZScore, TimeOfDayReturnProfile, IntradayVolatilityProfile, VolumeByTimeProfile, DayOfWeekProfile, AverageDailyRange, TurnOfMonth, SessionHighLow, SessionRange, OvernightIntradayReturn, FibRetracement, FibExtension, FibProjection, AutoFib, GoldenPocket, FibConfluence, FibFan, FibArcs, FibChannel, FibTimeZones } = nativeBinding module.exports.version = version module.exports.SMA = SMA @@ -433,6 +433,7 @@ module.exports.GatorOscillator = GatorOscillator module.exports.KasePermissionStochastic = KasePermissionStochastic module.exports.VolatilityRatio = VolatilityRatio module.exports.ProjectionOscillator = ProjectionOscillator +module.exports.TimeBasedStop = TimeBasedStop module.exports.Stochastic = Stochastic module.exports.OBV = OBV module.exports.ADX = ADX @@ -504,6 +505,11 @@ module.exports.DonchianStop = DonchianStop module.exports.PercentageTrailingStop = PercentageTrailingStop module.exports.StepTrailingStop = StepTrailingStop module.exports.RenkoTrailingStop = RenkoTrailingStop +module.exports.KaseDevStop = KaseDevStop +module.exports.ElderSafeZone = ElderSafeZone +module.exports.AtrRatchet = AtrRatchet +module.exports.Nrtr = Nrtr +module.exports.ModifiedMaStop = ModifiedMaStop module.exports.TypicalPrice = TypicalPrice module.exports.MedianPrice = MedianPrice module.exports.WeightedClose = WeightedClose diff --git a/bindings/node/src/lib.rs b/bindings/node/src/lib.rs index bbd0f177..0ebaa9ff 100644 --- a/bindings/node/src/lib.rs +++ b/bindings/node/src/lib.rs @@ -2922,6 +2922,59 @@ impl ProjectionOscillatorNode { } } +#[napi(js_name = "TimeBasedStop")] +pub struct TimeBasedStopNode { + inner: wc::TimeBasedStop, +} + +#[napi] +impl TimeBasedStopNode { + #[napi(constructor)] + pub fn new(max_bars: u32) -> napi::Result { + Ok(Self { + inner: wc::TimeBasedStop::new(max_bars as usize).map_err(map_err)?, + }) + } + #[napi] + pub fn update(&mut self, high: f64, low: f64, close: f64) -> napi::Result> { + Ok(self.inner.update(cnd(high, low, close, 0.0)?)) + } + #[napi] + pub fn batch( + &mut self, + high: Vec, + low: Vec, + close: Vec, + ) -> napi::Result> { + if high.len() != low.len() || low.len() != close.len() { + return Err(NapiError::from_reason( + "high, low, close must be equal length".to_string(), + )); + } + let mut out = Vec::with_capacity(high.len()); + for i in 0..high.len() { + out.push( + self.inner + .update(cnd(high[i], low[i], close[i], 0.0)?) + .unwrap_or(f64::NAN), + ); + } + Ok(out) + } + #[napi] + pub fn reset(&mut self) { + self.inner.reset(); + } + #[napi(js_name = "isReady")] + pub fn is_ready(&self) -> bool { + self.inner.is_ready() + } + #[napi(js_name = "warmupPeriod")] + pub fn warmup_period(&self) -> u32 { + self.inner.warmup_period() as u32 + } +} + #[napi(object)] pub struct StochValue { pub k: f64, @@ -6591,6 +6644,372 @@ impl RenkoTrailingStopNode { } } +// ============================== Kase DevStop ============================== + +#[napi(object)] +pub struct KaseDevStopValue { + pub value: f64, + pub direction: f64, +} + +#[napi(js_name = "KaseDevStop")] +pub struct KaseDevStopNode { + inner: wc::KaseDevStop, +} + +#[napi] +impl KaseDevStopNode { + #[napi(constructor)] + pub fn new(period: u32, dev: f64) -> napi::Result { + Ok(Self { + inner: wc::KaseDevStop::new(period as usize, dev).map_err(map_err)?, + }) + } + #[napi] + pub fn update( + &mut self, + high: f64, + low: f64, + close: f64, + ) -> napi::Result> { + Ok(self + .inner + .update(cnd(high, low, close, 0.0)?) + .map(|o| KaseDevStopValue { + value: o.value, + direction: o.direction, + })) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup positions are `NaN`. + #[napi] + pub fn batch( + &mut self, + high: Vec, + low: Vec, + close: Vec, + ) -> napi::Result> { + if high.len() != low.len() || low.len() != close.len() { + return Err(NapiError::from_reason( + "high, low, close must be equal length".to_string(), + )); + } + let n = high.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + if let Some(o) = self.inner.update(cnd(high[i], low[i], close[i], 0.0)?) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(out) + } + #[napi] + pub fn reset(&mut self) { + self.inner.reset(); + } + #[napi(js_name = "isReady")] + pub fn is_ready(&self) -> bool { + self.inner.is_ready() + } + #[napi(js_name = "warmupPeriod")] + pub fn warmup_period(&self) -> u32 { + self.inner.warmup_period() as u32 + } +} + +// ============================== Elder SafeZone ============================== + +#[napi(object)] +pub struct ElderSafeZoneValue { + pub value: f64, + pub direction: f64, +} + +#[napi(js_name = "ElderSafeZone")] +pub struct ElderSafeZoneNode { + inner: wc::ElderSafeZone, +} + +#[napi] +impl ElderSafeZoneNode { + #[napi(constructor)] + pub fn new(period: u32, coeff: f64) -> napi::Result { + Ok(Self { + inner: wc::ElderSafeZone::new(period as usize, coeff).map_err(map_err)?, + }) + } + #[napi] + pub fn update( + &mut self, + high: f64, + low: f64, + close: f64, + ) -> napi::Result> { + Ok(self + .inner + .update(cnd(high, low, close, 0.0)?) + .map(|o| ElderSafeZoneValue { + value: o.value, + direction: o.direction, + })) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup positions are `NaN`. + #[napi] + pub fn batch( + &mut self, + high: Vec, + low: Vec, + close: Vec, + ) -> napi::Result> { + if high.len() != low.len() || low.len() != close.len() { + return Err(NapiError::from_reason( + "high, low, close must be equal length".to_string(), + )); + } + let n = high.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + if let Some(o) = self.inner.update(cnd(high[i], low[i], close[i], 0.0)?) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(out) + } + #[napi] + pub fn reset(&mut self) { + self.inner.reset(); + } + #[napi(js_name = "isReady")] + pub fn is_ready(&self) -> bool { + self.inner.is_ready() + } + #[napi(js_name = "warmupPeriod")] + pub fn warmup_period(&self) -> u32 { + self.inner.warmup_period() as u32 + } +} + +// ============================== ATR Ratchet ============================== + +#[napi(object)] +pub struct AtrRatchetValue { + pub value: f64, + pub direction: f64, +} + +#[napi(js_name = "AtrRatchet")] +pub struct AtrRatchetNode { + inner: wc::AtrRatchet, +} + +#[napi] +impl AtrRatchetNode { + #[napi(constructor)] + pub fn new(atr_period: u32, start_mult: f64, increment: f64) -> napi::Result { + Ok(Self { + inner: wc::AtrRatchet::new(atr_period as usize, start_mult, increment) + .map_err(map_err)?, + }) + } + #[napi] + pub fn update( + &mut self, + high: f64, + low: f64, + close: f64, + ) -> napi::Result> { + Ok(self + .inner + .update(cnd(high, low, close, 0.0)?) + .map(|o| AtrRatchetValue { + value: o.value, + direction: o.direction, + })) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup positions are `NaN`. + #[napi] + pub fn batch( + &mut self, + high: Vec, + low: Vec, + close: Vec, + ) -> napi::Result> { + if high.len() != low.len() || low.len() != close.len() { + return Err(NapiError::from_reason( + "high, low, close must be equal length".to_string(), + )); + } + let n = high.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + if let Some(o) = self.inner.update(cnd(high[i], low[i], close[i], 0.0)?) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(out) + } + #[napi] + pub fn reset(&mut self) { + self.inner.reset(); + } + #[napi(js_name = "isReady")] + pub fn is_ready(&self) -> bool { + self.inner.is_ready() + } + #[napi(js_name = "warmupPeriod")] + pub fn warmup_period(&self) -> u32 { + self.inner.warmup_period() as u32 + } +} + +// ============================== NRTR ============================== + +#[napi(object)] +pub struct NrtrValue { + pub value: f64, + pub direction: f64, +} + +#[napi(js_name = "Nrtr")] +pub struct NrtrNode { + inner: wc::Nrtr, +} + +#[napi] +impl NrtrNode { + #[napi(constructor)] + pub fn new(pct: f64) -> napi::Result { + Ok(Self { + inner: wc::Nrtr::new(pct).map_err(map_err)?, + }) + } + #[napi] + pub fn update(&mut self, high: f64, low: f64, close: f64) -> napi::Result> { + Ok(self + .inner + .update(cnd(high, low, close, 0.0)?) + .map(|o| NrtrValue { + value: o.value, + direction: o.direction, + })) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup positions are `NaN`. + #[napi] + pub fn batch( + &mut self, + high: Vec, + low: Vec, + close: Vec, + ) -> napi::Result> { + if high.len() != low.len() || low.len() != close.len() { + return Err(NapiError::from_reason( + "high, low, close must be equal length".to_string(), + )); + } + let n = high.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + if let Some(o) = self.inner.update(cnd(high[i], low[i], close[i], 0.0)?) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(out) + } + #[napi] + pub fn reset(&mut self) { + self.inner.reset(); + } + #[napi(js_name = "isReady")] + pub fn is_ready(&self) -> bool { + self.inner.is_ready() + } + #[napi(js_name = "warmupPeriod")] + pub fn warmup_period(&self) -> u32 { + self.inner.warmup_period() as u32 + } +} + +// ============================== Modified MA Stop ============================== + +#[napi(object)] +pub struct ModifiedMaStopValue { + pub value: f64, + pub direction: f64, +} + +#[napi(js_name = "ModifiedMaStop")] +pub struct ModifiedMaStopNode { + inner: wc::ModifiedMaStop, +} + +#[napi] +impl ModifiedMaStopNode { + #[napi(constructor)] + pub fn new(period: u32) -> napi::Result { + Ok(Self { + inner: wc::ModifiedMaStop::new(period as usize).map_err(map_err)?, + }) + } + #[napi] + pub fn update( + &mut self, + high: f64, + low: f64, + close: f64, + ) -> napi::Result> { + Ok(self + .inner + .update(cnd(high, low, close, 0.0)?) + .map(|o| ModifiedMaStopValue { + value: o.value, + direction: o.direction, + })) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup positions are `NaN`. + #[napi] + pub fn batch( + &mut self, + high: Vec, + low: Vec, + close: Vec, + ) -> napi::Result> { + if high.len() != low.len() || low.len() != close.len() { + return Err(NapiError::from_reason( + "high, low, close must be equal length".to_string(), + )); + } + let n = high.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + if let Some(o) = self.inner.update(cnd(high[i], low[i], close[i], 0.0)?) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(out) + } + #[napi] + pub fn reset(&mut self) { + self.inner.reset(); + } + #[napi(js_name = "isReady")] + pub fn is_ready(&self) -> bool { + self.inner.is_ready() + } + #[napi(js_name = "warmupPeriod")] + pub fn warmup_period(&self) -> u32 { + self.inner.warmup_period() as u32 + } +} + // ============================== Typical Price ============================== #[napi(js_name = "TypicalPrice")] diff --git a/bindings/python/python/wickra/__init__.py b/bindings/python/python/wickra/__init__.py index c8c02453..6c78c2c0 100644 --- a/bindings/python/python/wickra/__init__.py +++ b/bindings/python/python/wickra/__init__.py @@ -25,6 +25,7 @@ from __future__ import annotations from ._wickra import ( __version__, + TimeBasedStop, ProjectionOscillator, VolatilityCone, VolatilityRatio, @@ -168,6 +169,11 @@ from ._wickra import ( HistoricalVolatility, BollingerBandwidth, PercentB, + # Trailing Stops + ModifiedMaStop, + Nrtr, + AtrRatchet, + ElderSafeZone, SuperTrend, ChandelierExit, ChandeKrollStop, @@ -179,6 +185,7 @@ from ._wickra import ( PercentageTrailingStop, StepTrailingStop, RenkoTrailingStop, + KaseDevStop, TrueRange, ChaikinVolatility, RVIVolatility, @@ -487,6 +494,7 @@ from ._wickra import ( ) __all__ = [ + "TimeBasedStop", "ProjectionOscillator", "VolatilityCone", "VolatilityRatio", @@ -631,6 +639,11 @@ __all__ = [ "HistoricalVolatility", "BollingerBandwidth", "PercentB", + # Trailing Stops + "ModifiedMaStop", + "Nrtr", + "AtrRatchet", + "ElderSafeZone", "SuperTrend", "ChandelierExit", "ChandeKrollStop", @@ -642,6 +655,7 @@ __all__ = [ "PercentageTrailingStop", "StepTrailingStop", "RenkoTrailingStop", + "KaseDevStop", "TrueRange", "ChaikinVolatility", "RVIVolatility", diff --git a/bindings/python/src/lib.rs b/bindings/python/src/lib.rs index 776c4340..3c855ffd 100644 --- a/bindings/python/src/lib.rs +++ b/bindings/python/src/lib.rs @@ -3631,6 +3631,75 @@ impl PyProjectionOscillator { } } +// ============================== TimeBasedStop ============================== + +#[pyclass(name = "TimeBasedStop", module = "wickra._wickra", skip_from_py_object)] +#[derive(Clone)] +struct PyTimeBasedStop { + inner: wc::TimeBasedStop, +} + +#[pymethods] +impl PyTimeBasedStop { + #[new] + #[pyo3(signature = (max_bars=5))] + fn new(max_bars: usize) -> PyResult { + Ok(Self { + inner: wc::TimeBasedStop::new(max_bars).map_err(map_err)?, + }) + } + fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult> { + let c = extract_candle(candle)?; + Ok(self.inner.update(c)) + } + /// Batch over numpy columns: high, low, close (all 1-D, equal length). + /// Ignores price; counts bars. Returns progress in `[0, 1]`. + fn batch<'py>( + &mut self, + py: Python<'py>, + high: PyReadonlyArray1<'py, f64>, + low: PyReadonlyArray1<'py, f64>, + close: PyReadonlyArray1<'py, f64>, + ) -> PyResult>> { + let h = high + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let l = low + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let c = close + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + if h.len() != l.len() || l.len() != c.len() { + return Err(PyValueError::new_err( + "high, low, close must be equal length", + )); + } + let mut out = Vec::with_capacity(h.len()); + for i in 0..h.len() { + let candle = wc::Candle::new(c[i], h[i], l[i], c[i], 0.0, 0).map_err(map_err)?; + out.push(self.inner.update(candle).unwrap_or(f64::NAN)); + } + Ok(out.into_pyarray(py)) + } + #[getter] + fn max_bars(&self) -> usize { + self.inner.max_bars() + } + fn reset(&mut self) { + self.inner.reset(); + } + fn is_ready(&self) -> bool { + self.inner.is_ready() + } + fn warmup_period(&self) -> usize { + self.inner.warmup_period() + } + fn __repr__(&self) -> String { + format!("TimeBasedStop(max_bars={})", self.inner.max_bars()) + } +} + // ============================== Stochastic ============================== #[pyclass(name = "IMI", module = "wickra._wickra", skip_from_py_object)] @@ -9813,6 +9882,390 @@ impl PyRenkoTrailingStop { } } +// ============================== Kase DevStop ============================== + +#[pyclass(name = "KaseDevStop", module = "wickra._wickra", skip_from_py_object)] +#[derive(Clone)] +struct PyKaseDevStop { + inner: wc::KaseDevStop, +} + +#[pymethods] +impl PyKaseDevStop { + #[new] + #[pyo3(signature = (period=30, dev=1.0))] + fn new(period: usize, dev: f64) -> PyResult { + Ok(Self { + inner: wc::KaseDevStop::new(period, dev).map_err(map_err)?, + }) + } + fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult> { + let c = extract_candle(candle)?; + Ok(self.inner.update(c).map(|o| (o.value, o.direction))) + } + /// Batch over numpy columns high, low, close. Returns shape `(n, 2)` with + /// columns `[value, direction]`; warmup rows are `NaN`. + fn batch<'py>( + &mut self, + py: Python<'py>, + high: PyReadonlyArray1<'py, f64>, + low: PyReadonlyArray1<'py, f64>, + close: PyReadonlyArray1<'py, f64>, + ) -> PyResult>> { + let h = high + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let l = low + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let c = close + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + if h.len() != l.len() || l.len() != c.len() { + return Err(PyValueError::new_err( + "high, low, close must be equal length", + )); + } + let n = h.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let candle = wc::Candle::new(c[i], h[i], l[i], c[i], 0.0, 0).map_err(map_err)?; + if let Some(o) = self.inner.update(candle) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out) + .expect("shape consistent") + .into_pyarray(py)) + } + #[getter] + fn params(&self) -> (usize, f64) { + self.inner.params() + } + fn reset(&mut self) { + self.inner.reset(); + } + fn is_ready(&self) -> bool { + self.inner.is_ready() + } + fn warmup_period(&self) -> usize { + self.inner.warmup_period() + } + fn __repr__(&self) -> String { + let (period, dev) = self.inner.params(); + format!("KaseDevStop(period={period}, dev={dev})") + } +} + +// ============================== Elder SafeZone ============================== + +#[pyclass(name = "ElderSafeZone", module = "wickra._wickra", skip_from_py_object)] +#[derive(Clone)] +struct PyElderSafeZone { + inner: wc::ElderSafeZone, +} + +#[pymethods] +impl PyElderSafeZone { + #[new] + #[pyo3(signature = (period=14, coeff=2.0))] + fn new(period: usize, coeff: f64) -> PyResult { + Ok(Self { + inner: wc::ElderSafeZone::new(period, coeff).map_err(map_err)?, + }) + } + fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult> { + let c = extract_candle(candle)?; + Ok(self.inner.update(c).map(|o| (o.value, o.direction))) + } + /// Batch over numpy columns high, low, close. Returns shape `(n, 2)` with + /// columns `[value, direction]`; warmup rows are `NaN`. + fn batch<'py>( + &mut self, + py: Python<'py>, + high: PyReadonlyArray1<'py, f64>, + low: PyReadonlyArray1<'py, f64>, + close: PyReadonlyArray1<'py, f64>, + ) -> PyResult>> { + let h = high + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let l = low + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let c = close + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + if h.len() != l.len() || l.len() != c.len() { + return Err(PyValueError::new_err( + "high, low, close must be equal length", + )); + } + let n = h.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let candle = wc::Candle::new(c[i], h[i], l[i], c[i], 0.0, 0).map_err(map_err)?; + if let Some(o) = self.inner.update(candle) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out) + .expect("shape consistent") + .into_pyarray(py)) + } + #[getter] + fn params(&self) -> (usize, f64) { + self.inner.params() + } + fn reset(&mut self) { + self.inner.reset(); + } + fn is_ready(&self) -> bool { + self.inner.is_ready() + } + fn warmup_period(&self) -> usize { + self.inner.warmup_period() + } + fn __repr__(&self) -> String { + let (period, coeff) = self.inner.params(); + format!("ElderSafeZone(period={period}, coeff={coeff})") + } +} + +// ============================== ATR Ratchet ============================== + +#[pyclass(name = "AtrRatchet", module = "wickra._wickra", skip_from_py_object)] +#[derive(Clone)] +struct PyAtrRatchet { + inner: wc::AtrRatchet, +} + +#[pymethods] +impl PyAtrRatchet { + #[new] + #[pyo3(signature = (atr_period=14, start_mult=4.0, increment=0.1))] + fn new(atr_period: usize, start_mult: f64, increment: f64) -> PyResult { + Ok(Self { + inner: wc::AtrRatchet::new(atr_period, start_mult, increment).map_err(map_err)?, + }) + } + fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult> { + let c = extract_candle(candle)?; + Ok(self.inner.update(c).map(|o| (o.value, o.direction))) + } + /// Batch over numpy columns high, low, close. Returns shape `(n, 2)` with + /// columns `[value, direction]`; warmup rows are `NaN`. + fn batch<'py>( + &mut self, + py: Python<'py>, + high: PyReadonlyArray1<'py, f64>, + low: PyReadonlyArray1<'py, f64>, + close: PyReadonlyArray1<'py, f64>, + ) -> PyResult>> { + let h = high + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let l = low + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let c = close + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + if h.len() != l.len() || l.len() != c.len() { + return Err(PyValueError::new_err( + "high, low, close must be equal length", + )); + } + let n = h.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let candle = wc::Candle::new(c[i], h[i], l[i], c[i], 0.0, 0).map_err(map_err)?; + if let Some(o) = self.inner.update(candle) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out) + .expect("shape consistent") + .into_pyarray(py)) + } + #[getter] + fn params(&self) -> (usize, f64, f64) { + self.inner.params() + } + fn reset(&mut self) { + self.inner.reset(); + } + fn is_ready(&self) -> bool { + self.inner.is_ready() + } + fn warmup_period(&self) -> usize { + self.inner.warmup_period() + } + fn __repr__(&self) -> String { + let (atr_period, start_mult, increment) = self.inner.params(); + format!( + "AtrRatchet(atr_period={atr_period}, start_mult={start_mult}, increment={increment})" + ) + } +} + +// ============================== NRTR ============================== + +#[pyclass(name = "Nrtr", module = "wickra._wickra", skip_from_py_object)] +#[derive(Clone)] +struct PyNrtr { + inner: wc::Nrtr, +} + +#[pymethods] +impl PyNrtr { + #[new] + #[pyo3(signature = (pct=2.0))] + fn new(pct: f64) -> PyResult { + Ok(Self { + inner: wc::Nrtr::new(pct).map_err(map_err)?, + }) + } + fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult> { + let c = extract_candle(candle)?; + Ok(self.inner.update(c).map(|o| (o.value, o.direction))) + } + /// Batch over numpy columns high, low, close. Returns shape `(n, 2)` with + /// columns `[value, direction]`; warmup rows are `NaN`. + fn batch<'py>( + &mut self, + py: Python<'py>, + high: PyReadonlyArray1<'py, f64>, + low: PyReadonlyArray1<'py, f64>, + close: PyReadonlyArray1<'py, f64>, + ) -> PyResult>> { + let h = high + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let l = low + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let c = close + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + if h.len() != l.len() || l.len() != c.len() { + return Err(PyValueError::new_err( + "high, low, close must be equal length", + )); + } + let n = h.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let candle = wc::Candle::new(c[i], h[i], l[i], c[i], 0.0, 0).map_err(map_err)?; + if let Some(o) = self.inner.update(candle) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out) + .expect("shape consistent") + .into_pyarray(py)) + } + #[getter] + fn pct(&self) -> f64 { + self.inner.pct() + } + fn reset(&mut self) { + self.inner.reset(); + } + fn is_ready(&self) -> bool { + self.inner.is_ready() + } + fn warmup_period(&self) -> usize { + self.inner.warmup_period() + } + fn __repr__(&self) -> String { + format!("Nrtr(pct={})", self.inner.pct()) + } +} + +// ============================== Modified MA Stop ============================== + +#[pyclass( + name = "ModifiedMaStop", + module = "wickra._wickra", + skip_from_py_object +)] +#[derive(Clone)] +struct PyModifiedMaStop { + inner: wc::ModifiedMaStop, +} + +#[pymethods] +impl PyModifiedMaStop { + #[new] + #[pyo3(signature = (period=14))] + fn new(period: usize) -> PyResult { + Ok(Self { + inner: wc::ModifiedMaStop::new(period).map_err(map_err)?, + }) + } + fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult> { + let c = extract_candle(candle)?; + Ok(self.inner.update(c).map(|o| (o.value, o.direction))) + } + /// Batch over numpy columns high, low, close. Returns shape `(n, 2)` with + /// columns `[value, direction]`; warmup rows are `NaN`. + fn batch<'py>( + &mut self, + py: Python<'py>, + high: PyReadonlyArray1<'py, f64>, + low: PyReadonlyArray1<'py, f64>, + close: PyReadonlyArray1<'py, f64>, + ) -> PyResult>> { + let h = high + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let l = low + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + let c = close + .as_slice() + .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?; + if h.len() != l.len() || l.len() != c.len() { + return Err(PyValueError::new_err( + "high, low, close must be equal length", + )); + } + let n = h.len(); + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let candle = wc::Candle::new(c[i], h[i], l[i], c[i], 0.0, 0).map_err(map_err)?; + if let Some(o) = self.inner.update(candle) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out) + .expect("shape consistent") + .into_pyarray(py)) + } + #[getter] + fn period(&self) -> usize { + self.inner.period() + } + fn reset(&mut self) { + self.inner.reset(); + } + fn is_ready(&self) -> bool { + self.inner.is_ready() + } + fn warmup_period(&self) -> usize { + self.inner.warmup_period() + } + fn __repr__(&self) -> String { + format!("ModifiedMaStop(period={})", self.inner.period()) + } +} + // ============================== Typical Price ============================== #[pyclass(name = "TypicalPrice", module = "wickra._wickra", skip_from_py_object)] @@ -21894,6 +22347,11 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_class::()?; m.add_class::()?; m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; m.add_class::()?; m.add_class::()?; m.add_class::()?; @@ -22238,5 +22696,6 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_class::()?; m.add_class::()?; m.add_class::()?; + m.add_class::()?; Ok(()) } diff --git a/bindings/python/tests/test_new_indicators.py b/bindings/python/tests/test_new_indicators.py index 324073ee..f59fc191 100644 --- a/bindings/python/tests/test_new_indicators.py +++ b/bindings/python/tests/test_new_indicators.py @@ -368,6 +368,7 @@ def test_relative_strength_streaming_matches_batch(): # 6-tuple candle; the batch helper takes only the columns it needs. CANDLE_SCALAR = { + "TimeBasedStop": (lambda: ta.TimeBasedStop(5), lambda ind, h, l, c, v: ind.batch(h, l, c)), "ProjectionOscillator": (lambda: ta.ProjectionOscillator(14), lambda ind, h, l, c, v: ind.batch(h, l, c)), "VolatilityRatio": (lambda: ta.VolatilityRatio(14), lambda ind, h, l, c, v: ind.batch(h, l, c)), "TTM_TREND": (lambda: ta.TTM_TREND(6), lambda ind, h, l, c, v: ind.batch(h, l, c)), @@ -908,6 +909,31 @@ def test_candle_scalar_streaming_matches_batch(name, ohlcv): # --- Candle-input, multi-output indicators -------------------------------- MULTI = { + "ModifiedMaStop": ( + lambda: ta.ModifiedMaStop(14), + lambda ind, h, l, c, v: ind.batch(h, l, c), + 2, + ), + "Nrtr": ( + lambda: ta.Nrtr(2.0), + lambda ind, h, l, c, v: ind.batch(h, l, c), + 2, + ), + "AtrRatchet": ( + lambda: ta.AtrRatchet(14, 4.0, 0.1), + lambda ind, h, l, c, v: ind.batch(h, l, c), + 2, + ), + "ElderSafeZone": ( + lambda: ta.ElderSafeZone(14, 2.0), + lambda ind, h, l, c, v: ind.batch(h, l, c), + 2, + ), + "KaseDevStop": ( + lambda: ta.KaseDevStop(3, 1.0), + lambda ind, h, l, c, v: ind.batch(h, l, c), + 2, + ), "ProjectionBands": ( lambda: ta.ProjectionBands(3), lambda ind, h, l, c, v: ind.batch(h, l), @@ -2967,6 +2993,53 @@ def test_projection_oscillator_reference(): assert t.update((9.0, 12.0, 9.0, 11.0, 1.0, 1)) is None assert t.update((10.0, 11.0, 10.0, 11.0, 1.0, 2)) == pytest.approx(40.0) + +def test_kase_devstop_reference(): + t = ta.KaseDevStop(3, 1.0) + assert t.update((100.0, 101.0, 99.0, 100.0, 1.0, 0)) is None + assert t.update((101.0, 102.0, 100.0, 101.0, 1.0, 1)) is None + assert t.update((102.0, 103.0, 101.0, 102.0, 1.0, 2)) is None + assert t.update((102.5, 104.0, 102.0, 103.0, 1.0, 3)) == pytest.approx((101.0, 1.0)) + + +def _stop_candles(n): + # Gently rising, valid OHLC: high >= open/close, low <= open/close. + return [(100.0 + i, 101.5 + i, 98.5 + i, 100.5 + i, 1.0, i) for i in range(n)] + + +def test_elder_safezone_reference(): + t = ta.ElderSafeZone(14, 2.0) + candles = _stop_candles(15) + for c in candles[:14]: + assert t.update(c) is None + assert t.update(candles[14]) == pytest.approx((112.5, 1.0)) + + +def test_atr_ratchet_reference(): + t = ta.AtrRatchet(14, 4.0, 0.1) + candles = _stop_candles(14) + for c in candles[:13]: + assert t.update(c) is None + assert t.update(candles[13]) == pytest.approx((101.5, 1.0)) + + +def test_nrtr_reference(): + t = ta.Nrtr(2.0) + assert t.update((100.0, 100.0, 100.0, 100.0, 1.0, 0)) == pytest.approx((98.0, 1.0)) + + +def test_time_based_stop_reference(): + t = ta.TimeBasedStop(5) + assert t.update((100.0, 101.0, 99.0, 100.0, 1.0, 0)) == pytest.approx(0.2) + + +def test_modified_ma_stop_reference(): + t = ta.ModifiedMaStop(14) + candles = _stop_candles(14) + for c in candles[:13]: + assert t.update(c) is None + assert t.update(candles[13]) == pytest.approx((107.0, 1.0)) + # --- Lifecycle ------------------------------------------------------------ diff --git a/bindings/wasm/src/lib.rs b/bindings/wasm/src/lib.rs index e96012dd..733362bf 100644 --- a/bindings/wasm/src/lib.rs +++ b/bindings/wasm/src/lib.rs @@ -2552,6 +2552,44 @@ impl WasmProjectionOscillator { } } +#[wasm_bindgen(js_name = TimeBasedStop)] +pub struct WasmTimeBasedStop { + inner: wc::TimeBasedStop, +} + +#[wasm_bindgen(js_class = TimeBasedStop)] +impl WasmTimeBasedStop { + #[wasm_bindgen(constructor)] + pub fn new(max_bars: usize) -> Result { + Ok(Self { + inner: wc::TimeBasedStop::new(max_bars).map_err(map_err)?, + }) + } + pub fn update(&mut self, high: f64, low: f64, close: f64) -> Result, JsError> { + let c = make_candle(high, low, close, 0.0)?; + Ok(self.inner.update(c)) + } + pub fn batch( + &mut self, + high: &[f64], + low: &[f64], + close: &[f64], + ) -> Result { + if high.len() != low.len() || low.len() != close.len() { + return Err(JsError::new("high, low, close must be equal length")); + } + let mut out = Vec::with_capacity(high.len()); + for i in 0..high.len() { + let c = make_candle(high[i], low[i], close[i], 0.0)?; + out.push(self.inner.update(c).unwrap_or(f64::NAN)); + } + Ok(Float64Array::from(out.as_slice())) + } + pub fn reset(&mut self) { + self.inner.reset(); + } +} + #[wasm_bindgen(js_name = Stochastic)] pub struct WasmStoch { inner: wc::Stochastic, @@ -3833,6 +3871,275 @@ impl WasmRenkoTrailingStop { } } +#[wasm_bindgen(js_name = KaseDevStop)] +pub struct WasmKaseDevStop { + inner: wc::KaseDevStop, +} + +#[wasm_bindgen(js_class = KaseDevStop)] +impl WasmKaseDevStop { + #[wasm_bindgen(constructor)] + pub fn new(period: usize, dev: f64) -> Result { + Ok(Self { + inner: wc::KaseDevStop::new(period, dev).map_err(map_err)?, + }) + } + /// Returns `{ value, direction }` once warm, else `null`. + pub fn update(&mut self, high: f64, low: f64, close: f64) -> Result { + let c = make_candle(high, low, close, 0.0)?; + Ok(match self.inner.update(c) { + Some(o) => { + let obj = Object::new(); + Reflect::set(&obj, &"value".into(), &o.value.into()).ok(); + Reflect::set(&obj, &"direction".into(), &o.direction.into()).ok(); + obj.into() + } + None => JsValue::NULL, + }) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup is NaN. + pub fn batch( + &mut self, + high: &[f64], + low: &[f64], + close: &[f64], + ) -> Result { + let n = high.len(); + if low.len() != n || close.len() != n { + return Err(JsError::new("high, low, close must be equal length")); + } + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let c = make_candle(high[i], low[i], close[i], 0.0)?; + if let Some(o) = self.inner.update(c) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(Float64Array::from(out.as_slice())) + } + pub fn reset(&mut self) { + self.inner.reset(); + } +} + +#[wasm_bindgen(js_name = ElderSafeZone)] +pub struct WasmElderSafeZone { + inner: wc::ElderSafeZone, +} + +#[wasm_bindgen(js_class = ElderSafeZone)] +impl WasmElderSafeZone { + #[wasm_bindgen(constructor)] + pub fn new(period: usize, coeff: f64) -> Result { + Ok(Self { + inner: wc::ElderSafeZone::new(period, coeff).map_err(map_err)?, + }) + } + /// Returns `{ value, direction }` once warm, else `null`. + pub fn update(&mut self, high: f64, low: f64, close: f64) -> Result { + let c = make_candle(high, low, close, 0.0)?; + Ok(match self.inner.update(c) { + Some(o) => { + let obj = Object::new(); + Reflect::set(&obj, &"value".into(), &o.value.into()).ok(); + Reflect::set(&obj, &"direction".into(), &o.direction.into()).ok(); + obj.into() + } + None => JsValue::NULL, + }) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup is NaN. + pub fn batch( + &mut self, + high: &[f64], + low: &[f64], + close: &[f64], + ) -> Result { + let n = high.len(); + if low.len() != n || close.len() != n { + return Err(JsError::new("high, low, close must be equal length")); + } + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let c = make_candle(high[i], low[i], close[i], 0.0)?; + if let Some(o) = self.inner.update(c) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(Float64Array::from(out.as_slice())) + } + pub fn reset(&mut self) { + self.inner.reset(); + } +} + +#[wasm_bindgen(js_name = AtrRatchet)] +pub struct WasmAtrRatchet { + inner: wc::AtrRatchet, +} + +#[wasm_bindgen(js_class = AtrRatchet)] +impl WasmAtrRatchet { + #[wasm_bindgen(constructor)] + pub fn new( + atr_period: usize, + start_mult: f64, + increment: f64, + ) -> Result { + Ok(Self { + inner: wc::AtrRatchet::new(atr_period, start_mult, increment).map_err(map_err)?, + }) + } + /// Returns `{ value, direction }` once warm, else `null`. + pub fn update(&mut self, high: f64, low: f64, close: f64) -> Result { + let c = make_candle(high, low, close, 0.0)?; + Ok(match self.inner.update(c) { + Some(o) => { + let obj = Object::new(); + Reflect::set(&obj, &"value".into(), &o.value.into()).ok(); + Reflect::set(&obj, &"direction".into(), &o.direction.into()).ok(); + obj.into() + } + None => JsValue::NULL, + }) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup is NaN. + pub fn batch( + &mut self, + high: &[f64], + low: &[f64], + close: &[f64], + ) -> Result { + let n = high.len(); + if low.len() != n || close.len() != n { + return Err(JsError::new("high, low, close must be equal length")); + } + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let c = make_candle(high[i], low[i], close[i], 0.0)?; + if let Some(o) = self.inner.update(c) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(Float64Array::from(out.as_slice())) + } + pub fn reset(&mut self) { + self.inner.reset(); + } +} + +#[wasm_bindgen(js_name = Nrtr)] +pub struct WasmNrtr { + inner: wc::Nrtr, +} + +#[wasm_bindgen(js_class = Nrtr)] +impl WasmNrtr { + #[wasm_bindgen(constructor)] + pub fn new(pct: f64) -> Result { + Ok(Self { + inner: wc::Nrtr::new(pct).map_err(map_err)?, + }) + } + /// Returns `{ value, direction }` once warm, else `null`. + pub fn update(&mut self, high: f64, low: f64, close: f64) -> Result { + let c = make_candle(high, low, close, 0.0)?; + Ok(match self.inner.update(c) { + Some(o) => { + let obj = Object::new(); + Reflect::set(&obj, &"value".into(), &o.value.into()).ok(); + Reflect::set(&obj, &"direction".into(), &o.direction.into()).ok(); + obj.into() + } + None => JsValue::NULL, + }) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup is NaN. + pub fn batch( + &mut self, + high: &[f64], + low: &[f64], + close: &[f64], + ) -> Result { + let n = high.len(); + if low.len() != n || close.len() != n { + return Err(JsError::new("high, low, close must be equal length")); + } + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let c = make_candle(high[i], low[i], close[i], 0.0)?; + if let Some(o) = self.inner.update(c) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(Float64Array::from(out.as_slice())) + } + pub fn reset(&mut self) { + self.inner.reset(); + } +} + +#[wasm_bindgen(js_name = ModifiedMaStop)] +pub struct WasmModifiedMaStop { + inner: wc::ModifiedMaStop, +} + +#[wasm_bindgen(js_class = ModifiedMaStop)] +impl WasmModifiedMaStop { + #[wasm_bindgen(constructor)] + pub fn new(period: usize) -> Result { + Ok(Self { + inner: wc::ModifiedMaStop::new(period).map_err(map_err)?, + }) + } + /// Returns `{ value, direction }` once warm, else `null`. + pub fn update(&mut self, high: f64, low: f64, close: f64) -> Result { + let c = make_candle(high, low, close, 0.0)?; + Ok(match self.inner.update(c) { + Some(o) => { + let obj = Object::new(); + Reflect::set(&obj, &"value".into(), &o.value.into()).ok(); + Reflect::set(&obj, &"direction".into(), &o.direction.into()).ok(); + obj.into() + } + None => JsValue::NULL, + }) + } + /// Returns `[value0, direction0, value1, direction1, ...]`, length `2 * n`. + /// Warmup is NaN. + pub fn batch( + &mut self, + high: &[f64], + low: &[f64], + close: &[f64], + ) -> Result { + let n = high.len(); + if low.len() != n || close.len() != n { + return Err(JsError::new("high, low, close must be equal length")); + } + let mut out = vec![f64::NAN; n * 2]; + for i in 0..n { + let c = make_candle(high[i], low[i], close[i], 0.0)?; + if let Some(o) = self.inner.update(c) { + out[i * 2] = o.value; + out[i * 2 + 1] = o.direction; + } + } + Ok(Float64Array::from(out.as_slice())) + } + pub fn reset(&mut self) { + self.inner.reset(); + } +} + #[wasm_bindgen(js_name = TypicalPrice)] pub struct WasmTypicalPrice { inner: wc::TypicalPrice, diff --git a/crates/wickra-core/src/indicators/atr_ratchet.rs b/crates/wickra-core/src/indicators/atr_ratchet.rs new file mode 100644 index 00000000..d5846e5c --- /dev/null +++ b/crates/wickra-core/src/indicators/atr_ratchet.rs @@ -0,0 +1,279 @@ +//! ATR Ratchet (Kaufman) — a trailing stop that creeps toward price each bar. + +use crate::error::{Error, Result}; +use crate::indicators::atr::Atr; +use crate::ohlcv::Candle; +use crate::traits::Indicator; + +/// Output of [`AtrRatchet`]: the active stop level and the trend direction. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct AtrRatchetOutput { + /// The ratchet stop level — below price when long, above price when short. + pub value: f64, + /// Trend direction: `+1.0` long, `-1.0` short. + pub direction: f64, +} + +/// ATR Ratchet — Perry Kaufman's time-based volatility stop that tightens by a +/// fixed fraction of ATR **every bar**, whether or not price moves. +/// +/// ```text +/// on entry (long): stop = close − start_mult · ATR +/// each later bar: stop = stop + increment · ATR (ratchets toward price) +/// flip to short when close < stop, reseeding stop = close + start_mult · ATR +/// ``` +/// +/// Most trailing stops only move when price makes a new extreme. Kaufman's ratchet +/// instead advances the stop a little each bar — `increment · ATR` — so a trade +/// that stalls is squeezed out over time even in a flat market. The initial +/// distance (`start_mult · ATR`) gives the position room to breathe; the per-bar +/// `increment` controls how aggressively the leash shortens. When price closes +/// through the stop the system reverses and reseeds at the full initial distance. +/// +/// The first stop lands once ATR is ready (`atr_period` inputs). Each `update` is +/// O(1). +/// +/// # Example +/// +/// ``` +/// use wickra_core::{Candle, Indicator, AtrRatchet}; +/// +/// let mut indicator = AtrRatchet::new(14, 4.0, 0.1).unwrap(); +/// let mut last = None; +/// for i in 0..60 { +/// let base = 100.0 + f64::from(i); +/// let c = Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 1_000.0, 0).unwrap(); +/// last = indicator.update(c); +/// } +/// assert!(last.is_some()); +/// ``` +#[derive(Debug, Clone)] +pub struct AtrRatchet { + atr: Atr, + atr_period: usize, + start_mult: f64, + increment: f64, + direction: f64, + stop: f64, + last: Option, +} + +impl AtrRatchet { + /// Construct an ATR Ratchet stop. + /// + /// # Errors + /// + /// Returns [`Error::PeriodZero`] if `atr_period == 0` and + /// [`Error::NonPositiveMultiplier`] if `start_mult` or `increment` is not + /// finite and positive. + pub fn new(atr_period: usize, start_mult: f64, increment: f64) -> Result { + if !start_mult.is_finite() + || start_mult <= 0.0 + || !increment.is_finite() + || increment <= 0.0 + { + return Err(Error::NonPositiveMultiplier); + } + Ok(Self { + atr: Atr::new(atr_period)?, + atr_period, + start_mult, + increment, + direction: 0.0, + stop: 0.0, + last: None, + }) + } + + /// Configured `(atr_period, start_mult, increment)`. + pub const fn params(&self) -> (usize, f64, f64) { + (self.atr_period, self.start_mult, self.increment) + } + + /// Current value if available. + pub const fn value(&self) -> Option { + self.last + } +} + +impl Indicator for AtrRatchet { + type Input = Candle; + type Output = AtrRatchetOutput; + + fn update(&mut self, candle: Candle) -> Option { + let atr = self.atr.update(candle)?; + let close = candle.close; + + if self.direction == 0.0 { + self.direction = 1.0; + self.stop = close - self.start_mult * atr; + } else if self.direction > 0.0 { + self.stop += self.increment * atr; + if close < self.stop { + self.direction = -1.0; + self.stop = close + self.start_mult * atr; + } + } else { + self.stop -= self.increment * atr; + if close > self.stop { + self.direction = 1.0; + self.stop = close - self.start_mult * atr; + } + } + + let out = AtrRatchetOutput { + value: self.stop, + direction: self.direction, + }; + self.last = Some(out); + Some(out) + } + + fn reset(&mut self) { + self.atr.reset(); + self.direction = 0.0; + self.stop = 0.0; + self.last = None; + } + + fn warmup_period(&self) -> usize { + self.atr_period + } + + fn is_ready(&self) -> bool { + self.last.is_some() + } + + fn name(&self) -> &'static str { + "AtrRatchet" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::traits::BatchExt; + + fn c(high: f64, low: f64, close: f64) -> Candle { + Candle::new_unchecked(f64::midpoint(high, low), high, low, close, 1_000.0, 0) + } + + #[test] + fn rejects_invalid_params() { + assert!(matches!( + AtrRatchet::new(0, 4.0, 0.1), + Err(Error::PeriodZero) + )); + assert!(matches!( + AtrRatchet::new(14, 0.0, 0.1), + Err(Error::NonPositiveMultiplier) + )); + assert!(matches!( + AtrRatchet::new(14, 4.0, 0.0), + Err(Error::NonPositiveMultiplier) + )); + assert!(matches!( + AtrRatchet::new(14, 4.0, f64::NAN), + Err(Error::NonPositiveMultiplier) + )); + } + + #[test] + fn accessors_and_metadata() { + let r = AtrRatchet::new(14, 4.0, 0.1).unwrap(); + assert_eq!(r.params(), (14, 4.0, 0.1)); + assert_eq!(r.warmup_period(), 14); + assert_eq!(r.name(), "AtrRatchet"); + assert!(!r.is_ready()); + assert_eq!(r.value(), None); + } + + #[test] + fn first_emission_at_warmup_period() { + let mut r = AtrRatchet::new(5, 4.0, 0.1).unwrap(); + let candles: Vec = (0..12) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base) + }) + .collect(); + let out = r.batch(&candles); + for v in out.iter().take(4) { + assert!(v.is_none()); + } + assert!(out[4].is_some()); + } + + #[test] + fn uptrend_keeps_stop_below_price() { + let mut r = AtrRatchet::new(5, 4.0, 0.05).unwrap(); + let candles: Vec = (0..60) + .map(|i| { + let base = 100.0 + 2.0 * f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + for (o, candle) in r.batch(&candles).into_iter().zip(candles.iter()) { + if let Some(o) = o { + assert_eq!(o.direction, 1.0); + assert!(o.value < candle.close); + } + } + } + + #[test] + fn stall_eventually_triggers_flip() { + // A long trend then a long flat stretch: the ratchet creeps up each bar + // and eventually overtakes the flat close, flipping to short. + let mut r = AtrRatchet::new(5, 2.0, 0.5).unwrap(); + let mut candles: Vec = (0..20) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + // Flat stretch at the last price. + candles.extend((0..40).map(|_| c(120.6, 118.6, 119.5))); + let dirs: Vec = r + .batch(&candles) + .into_iter() + .flatten() + .map(|o| o.direction) + .collect(); + assert!( + dirs.iter().any(|&d| d < 0.0), + "the ratchet should eventually flip short" + ); + } + + #[test] + fn reset_clears_state() { + let mut r = AtrRatchet::new(5, 4.0, 0.1).unwrap(); + let candles: Vec = (0..40) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + r.batch(&candles); + assert!(r.is_ready()); + r.reset(); + assert!(!r.is_ready()); + assert_eq!(r.value(), None); + assert_eq!(r.update(candles[0]), None); + } + + #[test] + fn batch_equals_streaming() { + let candles: Vec = (0..120) + .map(|i| { + let base = 100.0 + (f64::from(i) * 0.25).sin() * 9.0; + c(base + 2.0, base - 1.5, base + 0.5) + }) + .collect(); + let batch = AtrRatchet::new(14, 4.0, 0.1).unwrap().batch(&candles); + let mut b = AtrRatchet::new(14, 4.0, 0.1).unwrap(); + let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect(); + assert_eq!(batch, streamed); + } +} diff --git a/crates/wickra-core/src/indicators/elder_safezone.rs b/crates/wickra-core/src/indicators/elder_safezone.rs new file mode 100644 index 00000000..f8721cf0 --- /dev/null +++ b/crates/wickra-core/src/indicators/elder_safezone.rs @@ -0,0 +1,360 @@ +//! Elder `SafeZone` Stop — a trailing stop set by the average noise penetration. + +use std::collections::VecDeque; + +use crate::error::{Error, Result}; +use crate::ohlcv::Candle; +use crate::traits::Indicator; + +/// Output of [`ElderSafeZone`]: the active stop level and the trend direction. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct ElderSafeZoneOutput { + /// The `SafeZone` stop level — below price when long, above price when short. + pub value: f64, + /// Trend direction: `+1.0` long, `-1.0` short. + pub direction: f64, +} + +/// Elder `SafeZone` Stop — Alexander Elder's stop placed a multiple of the +/// **average market noise** away from price. +/// +/// ```text +/// long market noise = average downside penetration = mean( prev_low − low | low < prev_low ) +/// short market noise = average upside penetration = mean( high − prev_high | high > prev_high ) +/// long stop = ratchet_up( low_t − coeff · avg_down_penetration ) +/// short stop = ratchet_down( high_t + coeff · avg_up_penetration ) +/// ``` +/// +/// Elder defines *noise* in an uptrend as the part of each bar that pokes below +/// the previous bar's low (a "downside penetration"). Averaging those +/// penetrations over a lookback and placing the stop `coeff` multiples below the +/// current low keeps the stop just outside normal pullbacks while still exiting on +/// a genuine reversal. The stop trails in the trend's favour and flips when price +/// closes through it. The average uses only the bars that actually penetrated +/// (Elder's definition), so a noiseless trend gives a tight stop at the bar's +/// extreme. +/// +/// The first bar seeds the prior candle; the next `period` bars accumulate the +/// penetration statistics, so the first stop lands after `period + 1` inputs. +/// Each `update` is O(1). +/// +/// # Example +/// +/// ``` +/// use wickra_core::{Candle, Indicator, ElderSafeZone}; +/// +/// let mut indicator = ElderSafeZone::new(14, 2.0).unwrap(); +/// let mut last = None; +/// for i in 0..60 { +/// let base = 100.0 + f64::from(i); +/// let c = Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 1_000.0, 0).unwrap(); +/// last = indicator.update(c); +/// } +/// assert!(last.is_some()); +/// ``` +#[derive(Debug, Clone)] +pub struct ElderSafeZone { + period: usize, + coeff: f64, + prev: Option, + down_pen: VecDeque, + up_pen: VecDeque, + down_sum: f64, + up_sum: f64, + down_count: usize, + up_count: usize, + direction: f64, + stop: f64, + last: Option, +} + +impl ElderSafeZone { + /// Construct an Elder `SafeZone` stop with the given averaging `period` and + /// noise `coeff`icient. + /// + /// # Errors + /// + /// Returns [`Error::PeriodZero`] if `period == 0` and + /// [`Error::NonPositiveMultiplier`] if `coeff` is not finite and positive. + pub fn new(period: usize, coeff: f64) -> Result { + if period == 0 { + return Err(Error::PeriodZero); + } + if !coeff.is_finite() || coeff <= 0.0 { + return Err(Error::NonPositiveMultiplier); + } + Ok(Self { + period, + coeff, + prev: None, + down_pen: VecDeque::with_capacity(period), + up_pen: VecDeque::with_capacity(period), + down_sum: 0.0, + up_sum: 0.0, + down_count: 0, + up_count: 0, + direction: 0.0, + stop: 0.0, + last: None, + }) + } + + /// Configured `(period, coeff)`. + pub const fn params(&self) -> (usize, f64) { + (self.period, self.coeff) + } + + /// Current value if available. + pub const fn value(&self) -> Option { + self.last + } + + fn push(window: &mut VecDeque, sum: &mut f64, count: &mut usize, period: usize, pen: f64) { + if window.len() == period { + let old = window.pop_front().expect("non-empty"); + *sum -= old; + if old > 0.0 { + *count -= 1; + } + } + window.push_back(pen); + *sum += pen; + if pen > 0.0 { + *count += 1; + } + } + + fn avg(sum: f64, count: usize) -> f64 { + if count == 0 { + 0.0 + } else { + sum / count as f64 + } + } +} + +impl Indicator for ElderSafeZone { + type Input = Candle; + type Output = ElderSafeZoneOutput; + + fn update(&mut self, candle: Candle) -> Option { + let Some(prev) = self.prev else { + self.prev = Some(candle); + return None; + }; + let dp = (prev.low - candle.low).max(0.0); + let up = (candle.high - prev.high).max(0.0); + self.prev = Some(candle); + + Self::push( + &mut self.down_pen, + &mut self.down_sum, + &mut self.down_count, + self.period, + dp, + ); + Self::push( + &mut self.up_pen, + &mut self.up_sum, + &mut self.up_count, + self.period, + up, + ); + if self.down_pen.len() < self.period { + return None; + } + + let avg_down = Self::avg(self.down_sum, self.down_count); + let avg_up = Self::avg(self.up_sum, self.up_count); + + if self.direction == 0.0 { + self.direction = 1.0; + self.stop = candle.low - self.coeff * avg_down; + } else if self.direction > 0.0 { + let raw = candle.low - self.coeff * avg_down; + self.stop = self.stop.max(raw); + if candle.close < self.stop { + self.direction = -1.0; + self.stop = candle.high + self.coeff * avg_up; + } + } else { + let raw = candle.high + self.coeff * avg_up; + self.stop = self.stop.min(raw); + if candle.close > self.stop { + self.direction = 1.0; + self.stop = candle.low - self.coeff * avg_down; + } + } + + let out = ElderSafeZoneOutput { + value: self.stop, + direction: self.direction, + }; + self.last = Some(out); + Some(out) + } + + fn reset(&mut self) { + self.prev = None; + self.down_pen.clear(); + self.up_pen.clear(); + self.down_sum = 0.0; + self.up_sum = 0.0; + self.down_count = 0; + self.up_count = 0; + self.direction = 0.0; + self.stop = 0.0; + self.last = None; + } + + fn warmup_period(&self) -> usize { + self.period + 1 + } + + fn is_ready(&self) -> bool { + self.last.is_some() + } + + fn name(&self) -> &'static str { + "ElderSafeZone" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::traits::BatchExt; + + fn c(high: f64, low: f64, close: f64) -> Candle { + Candle::new_unchecked(f64::midpoint(high, low), high, low, close, 1_000.0, 0) + } + + #[test] + fn rejects_invalid_params() { + assert!(matches!(ElderSafeZone::new(0, 2.0), Err(Error::PeriodZero))); + assert!(matches!( + ElderSafeZone::new(14, 0.0), + Err(Error::NonPositiveMultiplier) + )); + assert!(matches!( + ElderSafeZone::new(14, -1.0), + Err(Error::NonPositiveMultiplier) + )); + } + + #[test] + fn accessors_and_metadata() { + let e = ElderSafeZone::new(14, 2.0).unwrap(); + assert_eq!(e.params(), (14, 2.0)); + assert_eq!(e.warmup_period(), 15); + assert_eq!(e.name(), "ElderSafeZone"); + assert!(!e.is_ready()); + assert_eq!(e.value(), None); + } + + #[test] + fn first_emission_at_warmup_period() { + let mut e = ElderSafeZone::new(3, 2.0).unwrap(); + let candles: Vec = (0..8) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base) + }) + .collect(); + let out = e.batch(&candles); + let warmup = e.warmup_period(); // 4 + assert_eq!(warmup, 4); + for v in out.iter().take(warmup - 1) { + assert!(v.is_none()); + } + assert!(out[warmup - 1].is_some()); + } + + #[test] + fn uptrend_keeps_stop_below_price() { + let mut e = ElderSafeZone::new(5, 2.0).unwrap(); + let candles: Vec = (0..60) + .map(|i| { + let base = 100.0 + 2.0 * f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + for (o, candle) in e.batch(&candles).into_iter().zip(candles.iter()) { + if let Some(o) = o { + assert_eq!(o.direction, 1.0); + assert!(o.value <= candle.close); + } + } + } + + #[test] + fn noiseless_trend_stop_sits_at_low() { + // Every bar makes a higher low -> no downside penetration -> avg 0 -> + // the stop sits exactly at the bar's low. + let mut e = ElderSafeZone::new(3, 2.0).unwrap(); + let candles: Vec = (0..10) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + let out = e.batch(&candles); + let last_candle = candles.last().unwrap(); + let last = out.last().unwrap().unwrap(); + assert!((last.value - last_candle.low).abs() < 1e-9); + } + + #[test] + fn flips_on_reversal() { + let mut candles: Vec = (0..40) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + candles.extend((0..40).map(|i| { + let base = 140.0 - f64::from(i); + c(base + 1.0, base - 1.0, base - 0.5) + })); + let mut e = ElderSafeZone::new(5, 2.0).unwrap(); + let dirs: Vec = e + .batch(&candles) + .into_iter() + .flatten() + .map(|o| o.direction) + .collect(); + assert!(dirs.iter().any(|&d| d > 0.0)); + assert!(dirs.iter().any(|&d| d < 0.0)); + } + + #[test] + fn reset_clears_state() { + let mut e = ElderSafeZone::new(5, 2.0).unwrap(); + let candles: Vec = (0..40) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + e.batch(&candles); + assert!(e.is_ready()); + e.reset(); + assert!(!e.is_ready()); + assert_eq!(e.value(), None); + assert_eq!(e.update(candles[0]), None); + } + + #[test] + fn batch_equals_streaming() { + let candles: Vec = (0..120) + .map(|i| { + let base = 100.0 + (f64::from(i) * 0.25).sin() * 9.0; + c(base + 2.0, base - 1.5, base + 0.5) + }) + .collect(); + let batch = ElderSafeZone::new(14, 2.0).unwrap().batch(&candles); + let mut b = ElderSafeZone::new(14, 2.0).unwrap(); + let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect(); + assert_eq!(batch, streamed); + } +} diff --git a/crates/wickra-core/src/indicators/kase_devstop.rs b/crates/wickra-core/src/indicators/kase_devstop.rs new file mode 100644 index 00000000..55227a04 --- /dev/null +++ b/crates/wickra-core/src/indicators/kase_devstop.rs @@ -0,0 +1,341 @@ +//! Kase `DevStop` — a volatility trailing stop on the standard deviation of the +//! two-bar true range. + +use std::collections::VecDeque; + +use crate::error::{Error, Result}; +use crate::ohlcv::Candle; +use crate::traits::Indicator; + +/// Output of [`KaseDevStop`]: the active trailing-stop level and the trend +/// direction it protects. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct KaseDevStopOutput { + /// The `DevStop` level — below price in an uptrend, above price in a downtrend. + pub value: f64, + /// Trend direction: `+1.0` long (stop below price), `-1.0` short. + pub direction: f64, +} + +/// Sample standard deviation from a running `(sum, sum_of_squares, count)`. +fn sample_stddev(sum: f64, sum_sq: f64, count: usize) -> f64 { + let n = count as f64; + let mean = sum / n; + (((sum_sq - n * mean * mean) / (n - 1.0)).max(0.0)).sqrt() +} + +/// Kase `DevStop` — Cynthia Kase's volatility stop, built on the **standard +/// deviation of the two-bar true range** rather than a single-bar ATR. +/// +/// ```text +/// DTR_t = max(high_t, high_{t−1}) − min(low_t, low_{t−1}) (two-bar range) +/// band = mean(DTR, period) + dev · stddev(DTR, period) +/// long stop = ratchet_up( highest_high_since_flip − band ) +/// short stop = ratchet_down( lowest_low_since_flip + band ) +/// ``` +/// +/// Kase observed that range expansion is better captured by a two-bar range than +/// a one-bar one, and that subtracting a *standard-deviation* band (not a fixed +/// ATR multiple) adapts the stop to changing volatility. The stop trails the +/// extreme reached since the last reversal — ratcheting only in the trend's favour +/// — and flips sides when price closes through it. `dev` selects which `DevStop` +/// line to follow (`1`, `2` or `3` standard deviations are Kase's warning lines). +/// +/// The first bar seeds the prior candle; the next `period` two-bar ranges seed the +/// mean and standard deviation, so the first stop lands after `period + 1` inputs. +/// Each `update` is O(1). +/// +/// # Example +/// +/// ``` +/// use wickra_core::{Candle, Indicator, KaseDevStop}; +/// +/// let mut indicator = KaseDevStop::new(30, 1.0).unwrap(); +/// let mut last = None; +/// for i in 0..80 { +/// let base = 100.0 + f64::from(i); +/// let c = Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 1_000.0, 0).unwrap(); +/// last = indicator.update(c); +/// } +/// assert!(last.is_some()); +/// ``` +#[derive(Debug, Clone)] +pub struct KaseDevStop { + period: usize, + dev: f64, + prev: Option, + window: VecDeque, + sum: f64, + sum_sq: f64, + direction: f64, + extreme: f64, + stop: f64, + last: Option, +} + +impl KaseDevStop { + /// Construct a Kase `DevStop` with the given lookback `period` and + /// standard-deviation multiplier `dev`. + /// + /// # Errors + /// + /// Returns [`Error::InvalidPeriod`] if `period < 2` (a standard deviation + /// needs at least two samples) and [`Error::NonPositiveMultiplier`] if `dev` + /// is not finite and positive. + pub fn new(period: usize, dev: f64) -> Result { + if period < 2 { + return Err(Error::InvalidPeriod { + message: "Kase DevStop period must be >= 2", + }); + } + if !dev.is_finite() || dev <= 0.0 { + return Err(Error::NonPositiveMultiplier); + } + Ok(Self { + period, + dev, + prev: None, + window: VecDeque::with_capacity(period), + sum: 0.0, + sum_sq: 0.0, + direction: 0.0, + extreme: 0.0, + stop: 0.0, + last: None, + }) + } + + /// Configured `(period, dev)`. + pub const fn params(&self) -> (usize, f64) { + (self.period, self.dev) + } + + /// Current value if available. + pub const fn value(&self) -> Option { + self.last + } +} + +impl Indicator for KaseDevStop { + type Input = Candle; + type Output = KaseDevStopOutput; + + fn update(&mut self, candle: Candle) -> Option { + let Some(prev) = self.prev else { + self.prev = Some(candle); + return None; + }; + let dtr = candle.high.max(prev.high) - candle.low.min(prev.low); + self.prev = Some(candle); + + if self.window.len() == self.period { + let old = self.window.pop_front().expect("non-empty"); + self.sum -= old; + self.sum_sq -= old * old; + } + self.window.push_back(dtr); + self.sum += dtr; + self.sum_sq += dtr * dtr; + if self.window.len() < self.period { + return None; + } + let mean = self.sum / self.period as f64; + let band = mean + self.dev * sample_stddev(self.sum, self.sum_sq, self.period); + + if self.direction == 0.0 { + // Seed the trend as long off the first fully-warmed bar. + self.direction = 1.0; + self.extreme = candle.high; + self.stop = candle.high - band; + } else if self.direction > 0.0 { + self.extreme = self.extreme.max(candle.high); + let raw = self.extreme - band; + self.stop = self.stop.max(raw); + if candle.close < self.stop { + self.direction = -1.0; + self.extreme = candle.low; + self.stop = candle.low + band; + } + } else { + self.extreme = self.extreme.min(candle.low); + let raw = self.extreme + band; + self.stop = self.stop.min(raw); + if candle.close > self.stop { + self.direction = 1.0; + self.extreme = candle.high; + self.stop = candle.high - band; + } + } + + let out = KaseDevStopOutput { + value: self.stop, + direction: self.direction, + }; + self.last = Some(out); + Some(out) + } + + fn reset(&mut self) { + self.prev = None; + self.window.clear(); + self.sum = 0.0; + self.sum_sq = 0.0; + self.direction = 0.0; + self.extreme = 0.0; + self.stop = 0.0; + self.last = None; + } + + fn warmup_period(&self) -> usize { + self.period + 1 + } + + fn is_ready(&self) -> bool { + self.last.is_some() + } + + fn name(&self) -> &'static str { + "KaseDevStop" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::traits::BatchExt; + + fn c(high: f64, low: f64, close: f64) -> Candle { + Candle::new_unchecked(f64::midpoint(high, low), high, low, close, 1_000.0, 0) + } + + #[test] + fn rejects_invalid_params() { + assert!(matches!( + KaseDevStop::new(1, 1.0), + Err(Error::InvalidPeriod { .. }) + )); + assert!(matches!( + KaseDevStop::new(30, 0.0), + Err(Error::NonPositiveMultiplier) + )); + assert!(matches!( + KaseDevStop::new(30, -1.0), + Err(Error::NonPositiveMultiplier) + )); + } + + #[test] + fn accessors_and_metadata() { + let k = KaseDevStop::new(30, 1.0).unwrap(); + assert_eq!(k.params(), (30, 1.0)); + assert_eq!(k.warmup_period(), 31); + assert_eq!(k.name(), "KaseDevStop"); + assert!(!k.is_ready()); + assert_eq!(k.value(), None); + } + + #[test] + fn first_emission_at_warmup_period() { + let mut k = KaseDevStop::new(3, 1.0).unwrap(); + let candles: Vec = (0..8) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base) + }) + .collect(); + let out = k.batch(&candles); + let warmup = k.warmup_period(); // 4 + assert_eq!(warmup, 4); + for v in out.iter().take(warmup - 1) { + assert!(v.is_none()); + } + assert!(out[warmup - 1].is_some()); + } + + #[test] + fn uptrend_keeps_stop_below_price() { + let mut k = KaseDevStop::new(5, 1.0).unwrap(); + let candles: Vec = (0..60) + .map(|i| { + let base = 100.0 + 2.0 * f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + for (o, candle) in k.batch(&candles).into_iter().zip(candles.iter()) { + if let Some(o) = o { + assert_eq!(o.direction, 1.0, "pure uptrend stays long"); + assert!(o.value < candle.close, "stop below price"); + } + } + } + + #[test] + fn stop_ratchets_up_in_uptrend() { + let mut k = KaseDevStop::new(5, 1.0).unwrap(); + let candles: Vec = (0..60) + .map(|i| { + let base = 100.0 + 2.0 * f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + let mut prev = f64::NEG_INFINITY; + for o in k.batch(&candles).into_iter().flatten() { + assert!(o.value >= prev, "long stop must not fall"); + prev = o.value; + } + } + + #[test] + fn flips_on_reversal() { + let mut candles: Vec = (0..40) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + candles.extend((0..40).map(|i| { + let base = 140.0 - f64::from(i); + c(base + 1.0, base - 1.0, base - 0.5) + })); + let mut k = KaseDevStop::new(5, 1.0).unwrap(); + let dirs: Vec = k + .batch(&candles) + .into_iter() + .flatten() + .map(|o| o.direction) + .collect(); + assert!(dirs.iter().any(|&d| d > 0.0)); + assert!(dirs.iter().any(|&d| d < 0.0)); + } + + #[test] + fn reset_clears_state() { + let mut k = KaseDevStop::new(5, 1.0).unwrap(); + let candles: Vec = (0..40) + .map(|i| { + let base = 100.0 + f64::from(i); + c(base + 1.0, base - 1.0, base + 0.5) + }) + .collect(); + k.batch(&candles); + assert!(k.is_ready()); + k.reset(); + assert!(!k.is_ready()); + assert_eq!(k.value(), None); + assert_eq!(k.update(candles[0]), None); + } + + #[test] + fn batch_equals_streaming() { + let candles: Vec = (0..120) + .map(|i| { + let base = 100.0 + (f64::from(i) * 0.25).sin() * 9.0; + c(base + 2.0, base - 1.5, base + 0.5) + }) + .collect(); + let batch = KaseDevStop::new(20, 2.0).unwrap().batch(&candles); + let mut b = KaseDevStop::new(20, 2.0).unwrap(); + let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect(); + assert_eq!(batch, streamed); + } +} diff --git a/crates/wickra-core/src/indicators/mod.rs b/crates/wickra-core/src/indicators/mod.rs index fb690afb..110ae5dc 100644 --- a/crates/wickra-core/src/indicators/mod.rs +++ b/crates/wickra-core/src/indicators/mod.rs @@ -35,6 +35,7 @@ mod aroon; mod aroon_oscillator; mod atr; mod atr_bands; +mod atr_ratchet; mod atr_trailing_stop; mod auto_fib; mod autocorrelation; @@ -115,6 +116,7 @@ mod ehlers_stochastic; mod ehma; mod elder_impulse; mod elder_ray; +mod elder_safezone; mod ema; mod empirical_mode_decomposition; mod engulfing; @@ -192,6 +194,7 @@ mod jump_indicator; mod kagi_bars; mod kalman_hedge_ratio; mod kama; +mod kase_devstop; mod kase_permission_stochastic; mod kelly_criterion; mod keltner; @@ -239,11 +242,13 @@ mod mid_point; mod mid_price; mod minus_di; mod minus_dm; +mod modified_ma_stop; mod mom; mod morning_doji_star; mod morning_evening_star; mod natr; mod new_highs_new_lows; +mod nrtr; mod nvi; mod ob_imbalance_full; mod ob_imbalance_top1; @@ -378,6 +383,7 @@ mod three_stars_in_south; mod thrusting; mod tick_index; mod tii; +mod time_based_stop; mod time_of_day_return_profile; mod tpo_profile; mod trade_imbalance; @@ -469,6 +475,7 @@ pub use aroon::{Aroon, AroonOutput}; pub use aroon_oscillator::AroonOscillator; pub use atr::Atr; pub use atr_bands::{AtrBands, AtrBandsOutput}; +pub use atr_ratchet::{AtrRatchet, AtrRatchetOutput}; pub use atr_trailing_stop::AtrTrailingStop; pub use auto_fib::{AutoFib, AutoFibOutput}; pub use autocorrelation::Autocorrelation; @@ -549,6 +556,7 @@ pub use ehlers_stochastic::EhlersStochastic; pub use ehma::Ehma; pub use elder_impulse::ElderImpulse; pub use elder_ray::{ElderRay, ElderRayOutput}; +pub use elder_safezone::{ElderSafeZone, ElderSafeZoneOutput}; pub use ema::Ema; pub use empirical_mode_decomposition::EmpiricalModeDecomposition; pub use engulfing::Engulfing; @@ -626,6 +634,7 @@ pub use jump_indicator::JumpIndicator; pub use kagi_bars::{KagiBar, KagiBars}; pub use kalman_hedge_ratio::{KalmanHedgeRatio, KalmanHedgeRatioOutput}; pub use kama::Kama; +pub use kase_devstop::{KaseDevStop, KaseDevStopOutput}; pub use kase_permission_stochastic::{KasePermissionStochastic, KasePermissionStochasticOutput}; pub use kelly_criterion::KellyCriterion; pub use keltner::{Keltner, KeltnerOutput}; @@ -673,11 +682,13 @@ pub use mid_point::MidPoint; pub use mid_price::MidPrice; pub use minus_di::MinusDi; pub use minus_dm::MinusDm; +pub use modified_ma_stop::{ModifiedMaStop, ModifiedMaStopOutput}; pub use mom::Mom; pub use morning_doji_star::MorningDojiStar; pub use morning_evening_star::MorningEveningStar; pub use natr::Natr; pub use new_highs_new_lows::NewHighsNewLows; +pub use nrtr::{Nrtr, NrtrOutput}; pub use nvi::Nvi; pub use ob_imbalance_full::OrderBookImbalanceFull; pub use ob_imbalance_top1::OrderBookImbalanceTop1; @@ -812,6 +823,7 @@ pub use three_stars_in_south::ThreeStarsInSouth; pub use thrusting::Thrusting; pub use tick_index::TickIndex; pub use tii::Tii; +pub use time_based_stop::TimeBasedStop; pub use time_of_day_return_profile::{TimeOfDayReturnProfile, TimeOfDayReturnProfileOutput}; pub use tpo_profile::{TpoProfile, TpoProfileOutput}; pub use trade_imbalance::TradeImbalance; @@ -1073,6 +1085,12 @@ pub const FAMILIES: &[(&str, &[&str])] = &[ "StepTrailingStop", "RenkoTrailingStop", "SarExt", + "KaseDevStop", + "ElderSafeZone", + "AtrRatchet", + "Nrtr", + "TimeBasedStop", + "ModifiedMaStop", ], ), ( @@ -1456,6 +1474,6 @@ mod family_tests { // the actual indicator count is the early-warning signal that an // indicator was added without being assigned a family. let total: usize = FAMILIES.iter().map(|(_, ns)| ns.len()).sum(); - assert_eq!(total, 434, "FAMILIES total drifted from indicator count"); + assert_eq!(total, 440, "FAMILIES total drifted from indicator count"); } } diff --git a/crates/wickra-core/src/indicators/modified_ma_stop.rs b/crates/wickra-core/src/indicators/modified_ma_stop.rs new file mode 100644 index 00000000..b132913f --- /dev/null +++ b/crates/wickra-core/src/indicators/modified_ma_stop.rs @@ -0,0 +1,238 @@ +//! Modified-MA Stop — a trailing stop riding the Modified Moving Average (SMMA). + +use crate::error::{Error, Result}; +use crate::indicators::smma::Smma; +use crate::ohlcv::Candle; +use crate::traits::Indicator; + +/// Output of [`ModifiedMaStop`]: the active stop level and the trend direction. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct ModifiedMaStopOutput { + /// The stop level (a directionally-ratcheted Modified Moving Average). + pub value: f64, + /// Trend direction: `+1.0` long (stop below price), `-1.0` short. + pub direction: f64, +} + +/// Modified-MA Stop — a trailing stop whose line is the **Modified Moving +/// Average** (SMMA / Wilder's RMA) of price, allowed to move only in the trend's +/// favour. +/// +/// ```text +/// ma = SMMA(close, period) (Modified Moving Average) +/// long: stop = max(prev_stop, ma); flip short when close < stop +/// short: stop = min(prev_stop, ma); flip long when close > stop +/// ``` +/// +/// The Modified Moving Average (also called the smoothed or running moving +/// average) is the slow, low-lag average Wilder used throughout his systems. Using +/// it directly as a trailing line — but **ratcheting** so the long stop never +/// falls and the short stop never rises — turns the smooth average into a stop +/// that hugs price in a trend and flips when price decisively crosses it. Because +/// the SMMA lags, the stop gives trends room while still exiting clean reversals. +/// +/// The first stop lands once the SMMA is ready (`period` inputs). Each `update` is +/// O(1). +/// +/// # Example +/// +/// ``` +/// use wickra_core::{Candle, Indicator, ModifiedMaStop}; +/// +/// let mut indicator = ModifiedMaStop::new(14).unwrap(); +/// let mut last = None; +/// for i in 0..60 { +/// let base = 100.0 + f64::from(i); +/// let c = Candle::new(base, base + 1.0, base - 1.0, base + 0.5, 1_000.0, 0).unwrap(); +/// last = indicator.update(c); +/// } +/// assert!(last.is_some()); +/// ``` +#[derive(Debug, Clone)] +pub struct ModifiedMaStop { + smma: Smma, + period: usize, + direction: f64, + stop: f64, + last: Option, +} + +impl ModifiedMaStop { + /// Construct a Modified-MA stop with the given SMMA `period`. + /// + /// # Errors + /// + /// Returns [`Error::PeriodZero`] if `period == 0`. + pub fn new(period: usize) -> Result { + if period == 0 { + return Err(Error::PeriodZero); + } + Ok(Self { + smma: Smma::new(period)?, + period, + direction: 0.0, + stop: 0.0, + last: None, + }) + } + + /// Configured SMMA period. + pub const fn period(&self) -> usize { + self.period + } + + /// Current value if available. + pub const fn value(&self) -> Option { + self.last + } +} + +impl Indicator for ModifiedMaStop { + type Input = Candle; + type Output = ModifiedMaStopOutput; + + fn update(&mut self, candle: Candle) -> Option { + let ma = self.smma.update(candle.close)?; + let close = candle.close; + + if self.direction == 0.0 { + self.direction = if close >= ma { 1.0 } else { -1.0 }; + self.stop = ma; + } else if self.direction > 0.0 { + self.stop = self.stop.max(ma); + if close < self.stop { + self.direction = -1.0; + self.stop = ma; + } + } else { + self.stop = self.stop.min(ma); + if close > self.stop { + self.direction = 1.0; + self.stop = ma; + } + } + + let out = ModifiedMaStopOutput { + value: self.stop, + direction: self.direction, + }; + self.last = Some(out); + Some(out) + } + + fn reset(&mut self) { + self.smma.reset(); + self.direction = 0.0; + self.stop = 0.0; + self.last = None; + } + + fn warmup_period(&self) -> usize { + self.period + } + + fn is_ready(&self) -> bool { + self.last.is_some() + } + + fn name(&self) -> &'static str { + "ModifiedMaStop" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::traits::BatchExt; + + fn c(close: f64) -> Candle { + Candle::new_unchecked(close, close + 1.0, close - 1.0, close, 1_000.0, 0) + } + + #[test] + fn rejects_zero_period() { + assert!(matches!(ModifiedMaStop::new(0), Err(Error::PeriodZero))); + } + + #[test] + fn accessors_and_metadata() { + let m = ModifiedMaStop::new(14).unwrap(); + assert_eq!(m.period(), 14); + assert_eq!(m.warmup_period(), 14); + assert_eq!(m.name(), "ModifiedMaStop"); + assert!(!m.is_ready()); + assert_eq!(m.value(), None); + } + + #[test] + fn first_emission_at_warmup_period() { + let mut m = ModifiedMaStop::new(5).unwrap(); + let candles: Vec = (0..12).map(|i| c(100.0 + f64::from(i))).collect(); + let out = m.batch(&candles); + for v in out.iter().take(4) { + assert!(v.is_none()); + } + assert!(out[4].is_some()); + } + + #[test] + fn uptrend_keeps_stop_below_price() { + let mut m = ModifiedMaStop::new(5).unwrap(); + let candles: Vec = (0..60).map(|i| c(100.0 + 2.0 * f64::from(i))).collect(); + for (o, candle) in m.batch(&candles).into_iter().zip(candles.iter()) { + if let Some(o) = o { + assert_eq!(o.direction, 1.0); + assert!(o.value < candle.close); + } + } + } + + #[test] + fn long_stop_ratchets_up() { + let mut m = ModifiedMaStop::new(5).unwrap(); + let candles: Vec = (0..60).map(|i| c(100.0 + 2.0 * f64::from(i))).collect(); + let mut prev = f64::NEG_INFINITY; + for o in m.batch(&candles).into_iter().flatten() { + assert_eq!(o.direction, 1.0, "pure uptrend stays long"); + assert!(o.value >= prev, "long stop must not fall"); + prev = o.value; + } + } + + #[test] + fn flips_on_reversal() { + let mut candles: Vec = (0..40).map(|i| c(100.0 + f64::from(i))).collect(); + candles.extend((0..40).map(|i| c(140.0 - f64::from(i)))); + let mut m = ModifiedMaStop::new(5).unwrap(); + let dirs: Vec = m + .batch(&candles) + .into_iter() + .flatten() + .map(|o| o.direction) + .collect(); + assert!(dirs.iter().any(|&d| d > 0.0)); + assert!(dirs.iter().any(|&d| d < 0.0)); + } + + #[test] + fn reset_clears_state() { + let mut m = ModifiedMaStop::new(5).unwrap(); + m.batch(&(0..40).map(|i| c(100.0 + f64::from(i))).collect::>()); + assert!(m.is_ready()); + m.reset(); + assert!(!m.is_ready()); + assert_eq!(m.value(), None); + assert_eq!(m.update(c(100.0)), None); + } + + #[test] + fn batch_equals_streaming() { + let candles: Vec = (0..120) + .map(|i| c(100.0 + (f64::from(i) * 0.25).sin() * 9.0)) + .collect(); + let batch = ModifiedMaStop::new(14).unwrap().batch(&candles); + let mut b = ModifiedMaStop::new(14).unwrap(); + let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect(); + assert_eq!(batch, streamed); + } +} diff --git a/crates/wickra-core/src/indicators/nrtr.rs b/crates/wickra-core/src/indicators/nrtr.rs new file mode 100644 index 00000000..3fa471a9 --- /dev/null +++ b/crates/wickra-core/src/indicators/nrtr.rs @@ -0,0 +1,259 @@ +//! NRTR — Nick Rypock Trailing Reverse, a percentage trailing-reverse stop. + +use crate::error::{Error, Result}; +use crate::ohlcv::Candle; +use crate::traits::Indicator; + +/// Output of [`Nrtr`]: the trailing-reverse line and the trend direction. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct NrtrOutput { + /// The NRTR line — below price in an uptrend, above price in a downtrend. + pub value: f64, + /// Trend direction: `+1.0` up (line below price), `-1.0` down. + pub direction: f64, +} + +/// NRTR (Nick Rypock Trailing Reverse) — a **percentage** trailing-reverse stop +/// that follows the trend extreme and flips when price retraces by a fixed +/// percentage. +/// +/// ```text +/// uptrend: high_water = max(high_water, close) +/// line = high_water · (1 − pct/100) +/// flip down when close < line (reseed low_water = close) +/// downtrend: low_water = min(low_water, close) +/// line = low_water · (1 + pct/100) +/// flip up when close > line (reseed high_water = close) +/// ``` +/// +/// Unlike volatility stops (ATR, σ-of-range), NRTR uses a pure **percentage** +/// retracement: the line trails the highest close reached in the up-leg at a +/// fixed `pct` below it, and a close that gives back that percentage reverses the +/// trend, handing the line to the opposite extreme. This makes it scale-free and +/// trivially tunable — one number sets how much retracement you tolerate. It +/// differs from a fixed percentage *stop-loss* in that it **reverses** (tracks +/// both directions) rather than just exiting. +/// +/// The first bar seeds the up-trend and emits a line immediately. Each `update` is +/// O(1). +/// +/// # Example +/// +/// ``` +/// use wickra_core::{Candle, Indicator, Nrtr}; +/// +/// let mut indicator = Nrtr::new(2.0).unwrap(); +/// let mut last = None; +/// for i in 0..40 { +/// let close = 100.0 + f64::from(i); +/// let c = Candle::new(close, close + 0.5, close - 0.5, close, 1_000.0, 0).unwrap(); +/// last = indicator.update(c); +/// } +/// assert!(last.is_some()); +/// ``` +#[derive(Debug, Clone)] +pub struct Nrtr { + pct: f64, + direction: f64, + water: f64, + last: Option, +} + +impl Nrtr { + /// Construct an NRTR with the given trailing percentage (e.g. `2.0` for 2%). + /// + /// # Errors + /// + /// Returns [`Error::InvalidParameter`] if `pct` is not finite or is outside + /// `(0, 100)`. + pub fn new(pct: f64) -> Result { + if !pct.is_finite() || pct <= 0.0 || pct >= 100.0 { + return Err(Error::InvalidParameter { + message: "NRTR percentage must be in (0, 100)", + }); + } + Ok(Self { + pct, + direction: 0.0, + water: 0.0, + last: None, + }) + } + + /// Configured trailing percentage. + pub const fn pct(&self) -> f64 { + self.pct + } + + /// Current value if available. + pub const fn value(&self) -> Option { + self.last + } +} + +impl Indicator for Nrtr { + type Input = Candle; + type Output = NrtrOutput; + + fn update(&mut self, candle: Candle) -> Option { + let close = candle.close; + let down = self.pct / 100.0; + let up = self.pct / 100.0; + + if self.direction == 0.0 { + self.direction = 1.0; + self.water = close; + } else if self.direction > 0.0 { + self.water = self.water.max(close); + let line = self.water * (1.0 - down); + if close < line { + self.direction = -1.0; + self.water = close; + } + } else { + self.water = self.water.min(close); + let line = self.water * (1.0 + up); + if close > line { + self.direction = 1.0; + self.water = close; + } + } + + let line = if self.direction > 0.0 { + self.water * (1.0 - down) + } else { + self.water * (1.0 + up) + }; + let out = NrtrOutput { + value: line, + direction: self.direction, + }; + self.last = Some(out); + Some(out) + } + + fn reset(&mut self) { + self.direction = 0.0; + self.water = 0.0; + self.last = None; + } + + fn warmup_period(&self) -> usize { + 1 + } + + fn is_ready(&self) -> bool { + self.last.is_some() + } + + fn name(&self) -> &'static str { + "Nrtr" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::traits::BatchExt; + + fn c(close: f64) -> Candle { + Candle::new_unchecked(close, close, close, close, 1_000.0, 0) + } + + #[test] + fn rejects_invalid_pct() { + assert!(matches!( + Nrtr::new(0.0), + Err(Error::InvalidParameter { .. }) + )); + assert!(matches!( + Nrtr::new(100.0), + Err(Error::InvalidParameter { .. }) + )); + assert!(matches!( + Nrtr::new(f64::NAN), + Err(Error::InvalidParameter { .. }) + )); + assert!(Nrtr::new(2.0).is_ok()); + } + + #[test] + fn accessors_and_metadata() { + let n = Nrtr::new(2.0).unwrap(); + assert_eq!(n.pct(), 2.0); + assert_eq!(n.warmup_period(), 1); + assert_eq!(n.name(), "Nrtr"); + assert!(!n.is_ready()); + assert_eq!(n.value(), None); + } + + #[test] + fn first_bar_emits_up_line() { + let mut n = Nrtr::new(10.0).unwrap(); + let o = n.update(c(100.0)).unwrap(); + assert_eq!(o.direction, 1.0); + // line = 100 * (1 - 0.10) = 90. + assert!((o.value - 90.0).abs() < 1e-9); + } + + #[test] + fn uptrend_keeps_line_below_price() { + let mut n = Nrtr::new(5.0).unwrap(); + let candles: Vec = (0..40).map(|i| c(100.0 + f64::from(i))).collect(); + for (o, candle) in n.batch(&candles).into_iter().zip(candles.iter()) { + let o = o.unwrap(); + assert_eq!(o.direction, 1.0); + assert!(o.value < candle.close); + } + } + + #[test] + fn reverses_on_retracement() { + let mut n = Nrtr::new(5.0).unwrap(); + // Rise to 120, then drop sharply -> a >5% retracement reverses the trend. + let mut candles: Vec = (0..20).map(|i| c(100.0 + f64::from(i))).collect(); + candles.extend((0..10).map(|i| c(119.0 - 3.0 * f64::from(i)))); + let dirs: Vec = n + .batch(&candles) + .into_iter() + .flatten() + .map(|o| o.direction) + .collect(); + assert!(dirs.iter().any(|&d| d > 0.0)); + assert!(dirs.iter().any(|&d| d < 0.0)); + } + + #[test] + fn downtrend_keeps_line_above_price() { + let mut n = Nrtr::new(5.0).unwrap(); + // Establish a downtrend after an initial bar. + let mut candles = vec![c(100.0)]; + candles.extend((0..30).map(|i| c(80.0 - f64::from(i)))); + let out = n.batch(&candles); + let o = out.last().unwrap().unwrap(); + let candle = candles.last().unwrap(); + assert_eq!(o.direction, -1.0); + assert!(o.value > candle.close); + } + + #[test] + fn reset_clears_state() { + let mut n = Nrtr::new(2.0).unwrap(); + n.batch(&(0..20).map(|i| c(100.0 + f64::from(i))).collect::>()); + assert!(n.is_ready()); + n.reset(); + assert!(!n.is_ready()); + assert_eq!(n.value(), None); + } + + #[test] + fn batch_equals_streaming() { + let candles: Vec = (0..120) + .map(|i| c(100.0 + (f64::from(i) * 0.25).sin() * 15.0)) + .collect(); + let batch = Nrtr::new(3.0).unwrap().batch(&candles); + let mut b = Nrtr::new(3.0).unwrap(); + let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect(); + assert_eq!(batch, streamed); + } +} diff --git a/crates/wickra-core/src/indicators/time_based_stop.rs b/crates/wickra-core/src/indicators/time_based_stop.rs new file mode 100644 index 00000000..646ab3d9 --- /dev/null +++ b/crates/wickra-core/src/indicators/time_based_stop.rs @@ -0,0 +1,192 @@ +//! Time-Based Stop — a holding-period timer that fires after a fixed bar count. + +use crate::error::{Error, Result}; +use crate::ohlcv::Candle; +use crate::traits::Indicator; + +/// Time-Based Stop — exits a position purely on **elapsed bars**, independent of +/// price. +/// +/// ```text +/// bars_held increments by 1 each bar (since the last reset) +/// progress = min(bars_held / max_bars, 1.0) in [0, 1] +/// stop fires when progress == 1.0 (bars_held >= max_bars) +/// ``` +/// +/// Some setups should not be given unlimited time to work: a mean-reversion entry +/// that has not reverted within `max_bars`, or an event trade whose catalyst has +/// passed, is best closed regardless of price. This indicator is a pure timer — +/// it ignores the candle's prices entirely and reports the fraction of the +/// holding window that has elapsed, reaching `1.0` (the stop) after `max_bars` +/// bars. **Call [`reset`](Indicator::reset) on each new entry** so the timer +/// restarts from the position open. +/// +/// Each `update` is O(1) and the first bar already emits a value +/// (`1 / max_bars`). +/// +/// # Example +/// +/// ``` +/// use wickra_core::{Candle, Indicator, TimeBasedStop}; +/// +/// let mut indicator = TimeBasedStop::new(5).unwrap(); +/// let c = Candle::new(100.0, 101.0, 99.0, 100.0, 1.0, 0).unwrap(); +/// // Five bars reach the stop. +/// let mut last = 0.0; +/// for _ in 0..5 { +/// last = indicator.update(c).unwrap(); +/// } +/// assert_eq!(last, 1.0); +/// ``` +#[derive(Debug, Clone)] +pub struct TimeBasedStop { + max_bars: usize, + bars_held: usize, + last: Option, +} + +impl TimeBasedStop { + /// Construct a time-based stop that fires after `max_bars` bars. + /// + /// # Errors + /// + /// Returns [`Error::PeriodZero`] if `max_bars == 0`. + pub fn new(max_bars: usize) -> Result { + if max_bars == 0 { + return Err(Error::PeriodZero); + } + Ok(Self { + max_bars, + bars_held: 0, + last: None, + }) + } + + /// Configured maximum holding period in bars. + pub const fn max_bars(&self) -> usize { + self.max_bars + } + + /// Number of bars held since the last reset. + pub const fn bars_held(&self) -> usize { + self.bars_held + } + + /// Whether the stop has fired (the holding period has fully elapsed). + pub const fn triggered(&self) -> bool { + self.bars_held >= self.max_bars + } + + /// Current value if available. + pub const fn value(&self) -> Option { + self.last + } +} + +impl Indicator for TimeBasedStop { + type Input = Candle; + type Output = f64; + + fn update(&mut self, _candle: Candle) -> Option { + self.bars_held += 1; + let progress = (self.bars_held as f64 / self.max_bars as f64).min(1.0); + self.last = Some(progress); + Some(progress) + } + + fn reset(&mut self) { + self.bars_held = 0; + self.last = None; + } + + fn warmup_period(&self) -> usize { + 1 + } + + fn is_ready(&self) -> bool { + self.last.is_some() + } + + fn name(&self) -> &'static str { + "TimeBasedStop" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::traits::BatchExt; + use approx::assert_relative_eq; + + fn c() -> Candle { + Candle::new_unchecked(100.0, 101.0, 99.0, 100.0, 1.0, 0) + } + + #[test] + fn rejects_zero_max_bars() { + assert!(matches!(TimeBasedStop::new(0), Err(Error::PeriodZero))); + } + + #[test] + fn accessors_and_metadata() { + let t = TimeBasedStop::new(5).unwrap(); + assert_eq!(t.max_bars(), 5); + assert_eq!(t.bars_held(), 0); + assert!(!t.triggered()); + assert_eq!(t.warmup_period(), 1); + assert_eq!(t.name(), "TimeBasedStop"); + assert!(!t.is_ready()); + assert_eq!(t.value(), None); + } + + #[test] + fn progress_climbs_to_one() { + let mut t = TimeBasedStop::new(4).unwrap(); + let out = t.batch(&[c(), c(), c(), c()]); + assert_relative_eq!(out[0].unwrap(), 0.25, epsilon = 1e-12); + assert_relative_eq!(out[1].unwrap(), 0.50, epsilon = 1e-12); + assert_relative_eq!(out[2].unwrap(), 0.75, epsilon = 1e-12); + assert_relative_eq!(out[3].unwrap(), 1.00, epsilon = 1e-12); + } + + #[test] + fn triggers_after_max_bars() { + let mut t = TimeBasedStop::new(3).unwrap(); + t.update(c()); + assert!(!t.triggered()); + t.update(c()); + assert!(!t.triggered()); + t.update(c()); + assert!(t.triggered()); + } + + #[test] + fn progress_saturates_at_one() { + // Beyond max_bars the progress stays clamped at 1.0. + let mut t = TimeBasedStop::new(2).unwrap(); + let out = t.batch(&[c(), c(), c(), c()]); + assert_relative_eq!(out[2].unwrap(), 1.0, epsilon = 1e-12); + assert_relative_eq!(out[3].unwrap(), 1.0, epsilon = 1e-12); + } + + #[test] + fn reset_restarts_timer() { + let mut t = TimeBasedStop::new(3).unwrap(); + t.batch(&[c(), c(), c()]); + assert!(t.triggered()); + t.reset(); + assert!(!t.is_ready()); + assert_eq!(t.bars_held(), 0); + assert!(!t.triggered()); + assert_relative_eq!(t.update(c()).unwrap(), 1.0 / 3.0, epsilon = 1e-12); + } + + #[test] + fn batch_equals_streaming() { + let candles = [c(); 10]; + let batch = TimeBasedStop::new(4).unwrap().batch(&candles); + let mut b = TimeBasedStop::new(4).unwrap(); + let streamed: Vec<_> = candles.iter().map(|x| b.update(*x)).collect(); + assert_eq!(batch, streamed); + } +} diff --git a/crates/wickra-core/src/lib.rs b/crates/wickra-core/src/lib.rs index 05eb5a1f..6c683ed1 100644 --- a/crates/wickra-core/src/lib.rs +++ b/crates/wickra-core/src/lib.rs @@ -60,9 +60,9 @@ pub use indicators::{ AcceleratorOscillator, AdOscillator, AdVolumeLine, AdaptiveCycle, AdaptiveLaguerreFilter, Adl, AdvanceBlock, AdvanceDecline, AdvanceDeclineRatio, Adx, AdxOutput, Adxr, Alligator, AlligatorOutput, Alma, Alpha, AmihudIlliquidity, AnchoredRsi, AnchoredVwap, Apo, Aroon, - AroonOscillator, AroonOutput, Atr, AtrBands, AtrBandsOutput, AtrTrailingStop, AutoFib, - AutoFibOutput, Autocorrelation, AverageDailyRange, AverageDrawdown, AvgPrice, - AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BeltHold, Beta, + AroonOscillator, AroonOutput, Atr, AtrBands, AtrBandsOutput, AtrRatchet, AtrRatchetOutput, + AtrTrailingStop, AutoFib, AutoFibOutput, Autocorrelation, AverageDailyRange, AverageDrawdown, + AvgPrice, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BeltHold, Beta, BetaNeutralSpread, BipowerVariation, BodySizePct, BollingerBands, BollingerBandwidth, BollingerOutput, BomarBands, BomarBandsOutput, BreadthThrust, Breakaway, BullishPercentIndex, Butterfly, CalendarSpread, CalmarRatio, Camarilla, CamarillaPivotsOutput, Cci, CenterOfGravity, @@ -77,34 +77,35 @@ pub use indicators::{ DonchianOutput, DonchianStop, DonchianStopOutput, DoubleBollinger, DoubleBollingerOutput, DoubleTopBottom, DownsideGapThreeMethods, Dpo, DragonflyDoji, DrawdownDuration, Dx, DynamicMomentumIndex, EaseOfMovement, EffectiveSpread, EhlersStochastic, Ehma, ElderImpulse, - ElderRay, ElderRayOutput, Ema, EmpiricalModeDecomposition, Engulfing, EveningDojiStar, Evwma, - EwmaVolatility, Expectancy, FallingThreeMethods, Fama, FibArcs, FibArcsOutput, FibChannel, - FibChannelOutput, FibConfluence, FibConfluenceOutput, FibExtension, FibExtensionOutput, FibFan, - FibFanOutput, FibProjection, FibProjectionOutput, FibRetracement, FibRetracementOutput, - FibTimeZones, FibTimeZonesOutput, FibonacciPivots, FibonacciPivotsOutput, FisherRsi, - FisherTransform, FlagPennant, Footprint, FootprintOutput, ForceIndex, FractalChaosBands, - FractalChaosBandsOutput, Frama, FundingBasis, FundingRate, FundingRateMean, FundingRateZScore, - GainLossRatio, GapSideBySideWhite, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator, - GatorOscillatorOutput, GeneralizedDema, GeometricMa, GoldenPocket, GoldenPocketOutput, - GrangerCausality, GravestoneDoji, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, - HeikinAshiOutput, HiLoActivator, HighLowIndex, HighLowRange, HighWave, Hikkake, - HikkakeModified, HilbertDominantCycle, HistoricalVolatility, Hma, HoltWinters, HomingPigeon, - HtDcPhase, HtPhasor, HtPhasorOutput, HtTrendMode, HurstChannel, HurstChannelOutput, - HurstExponent, Ichimoku, IchimokuOutput, IdenticalThreeCrows, InNeck, Inertia, - InformationRatio, InitialBalance, InitialBalanceOutput, InstantaneousTrendline, - IntradayMomentumIndex, IntradayVolatilityProfile, IntradayVolatilityProfileOutput, - InverseFisherTransform, InvertedHammer, Jma, JumpIndicator, KagiBars, KalmanHedgeRatio, - KalmanHedgeRatioOutput, Kama, KasePermissionStochastic, KasePermissionStochasticOutput, - KellyCriterion, Keltner, KeltnerOutput, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, - Kvo, KylesLambda, LadderBottom, LaguerreRsi, LeadLagCrossCorrelation, - LeadLagCrossCorrelationOutput, LinRegAngle, LinRegChannel, LinRegChannelOutput, - LinRegIntercept, LinRegSlope, LinearRegression, LiquidationFeatures, LiquidationFeaturesOutput, - LogReturn, LongLeggedDoji, LongLine, LongShortRatio, MaEnvelope, MaEnvelopeOutput, MacdExt, - MacdFix, MacdHistogram, MacdIndicator, MacdOutput, Mama, MamaOutput, MarketFacilitationIndex, - Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown, McClellanOscillator, - McClellanSummationIndex, McGinleyDynamic, MedianAbsoluteDeviation, MedianChannel, - MedianChannelOutput, MedianMa, MedianPrice, Mfi, Microprice, MidPoint, MidPrice, MinusDi, - MinusDm, Mom, MorningDojiStar, MorningEveningStar, Natr, NewHighsNewLows, Nvi, + ElderRay, ElderRayOutput, ElderSafeZone, ElderSafeZoneOutput, Ema, EmpiricalModeDecomposition, + Engulfing, EveningDojiStar, Evwma, EwmaVolatility, Expectancy, FallingThreeMethods, Fama, + FibArcs, FibArcsOutput, FibChannel, FibChannelOutput, FibConfluence, FibConfluenceOutput, + FibExtension, FibExtensionOutput, FibFan, FibFanOutput, FibProjection, FibProjectionOutput, + FibRetracement, FibRetracementOutput, FibTimeZones, FibTimeZonesOutput, FibonacciPivots, + FibonacciPivotsOutput, FisherRsi, FisherTransform, FlagPennant, Footprint, FootprintOutput, + ForceIndex, FractalChaosBands, FractalChaosBandsOutput, Frama, FundingBasis, FundingRate, + FundingRateMean, FundingRateZScore, GainLossRatio, GapSideBySideWhite, Garch11, + GarmanKlassVolatility, Gartley, GatorOscillator, GatorOscillatorOutput, GeneralizedDema, + GeometricMa, GoldenPocket, GoldenPocketOutput, GrangerCausality, GravestoneDoji, Hammer, + HangingMan, Harami, HeadAndShoulders, HeikinAshi, HeikinAshiOutput, HiLoActivator, + HighLowIndex, HighLowRange, HighWave, Hikkake, HikkakeModified, HilbertDominantCycle, + HistoricalVolatility, Hma, HoltWinters, HomingPigeon, HtDcPhase, HtPhasor, HtPhasorOutput, + HtTrendMode, HurstChannel, HurstChannelOutput, HurstExponent, Ichimoku, IchimokuOutput, + IdenticalThreeCrows, InNeck, Inertia, InformationRatio, InitialBalance, InitialBalanceOutput, + InstantaneousTrendline, IntradayMomentumIndex, IntradayVolatilityProfile, + IntradayVolatilityProfileOutput, InverseFisherTransform, InvertedHammer, Jma, JumpIndicator, + KagiBars, KalmanHedgeRatio, KalmanHedgeRatioOutput, Kama, KaseDevStop, KaseDevStopOutput, + KasePermissionStochastic, KasePermissionStochasticOutput, KellyCriterion, Keltner, + KeltnerOutput, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo, KylesLambda, + LadderBottom, LaguerreRsi, LeadLagCrossCorrelation, LeadLagCrossCorrelationOutput, LinRegAngle, + LinRegChannel, LinRegChannelOutput, LinRegIntercept, LinRegSlope, LinearRegression, + LiquidationFeatures, LiquidationFeaturesOutput, LogReturn, LongLeggedDoji, LongLine, + LongShortRatio, MaEnvelope, MaEnvelopeOutput, MacdExt, MacdFix, MacdHistogram, MacdIndicator, + MacdOutput, Mama, MamaOutput, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, + MatchingLow, MaxDrawdown, McClellanOscillator, McClellanSummationIndex, McGinleyDynamic, + MedianAbsoluteDeviation, MedianChannel, MedianChannelOutput, MedianMa, MedianPrice, Mfi, + Microprice, MidPoint, MidPrice, MinusDi, MinusDm, ModifiedMaStop, ModifiedMaStopOutput, Mom, + MorningDojiStar, MorningEveningStar, Natr, NewHighsNewLows, Nrtr, NrtrOutput, Nvi, OIPriceDivergence, OIWeighted, Obv, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange, OpeningRangeOutput, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn, @@ -129,18 +130,18 @@ pub use indicators::{ TdLines, TdLinesOutput, TdOpen, TdPressure, TdRangeProjection, TdRangeProjectionOutput, TdRei, TdRiskLevel, TdRiskLevelOutput, TdSequential, TdSequentialOutput, TdSetup, Tema, TermStructureBasis, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, - ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, Tii, TimeOfDayReturnProfile, - TimeOfDayReturnProfileOutput, TpoProfile, TpoProfileOutput, TradeImbalance, TrendLabel, - TrendStrengthIndex, TreynorRatio, Triangle, Trima, Trin, TripleTopBottom, Trix, TrueRange, Tsf, - TsfOscillator, Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, TtmTrend, TurnOfMonth, Tweezer, - TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver, UpDownVolumeRatio, - UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, ValueAreaOutput, ValueAtRisk, Variance, - VarianceRatio, VerticalHorizontalFilter, Vidya, VolatilityCone, VolatilityConeOutput, - VolatilityOfVolatility, VolatilityRatio, VoltyStop, VolumeByTimeProfile, - VolumeByTimeProfileOutput, VolumeOscillator, VolumePriceTrend, VolumeProfile, - VolumeProfileOutput, Vortex, VortexOutput, Vpin, Vwap, VwapStdDevBands, VwapStdDevBandsOutput, - Vwma, Vzo, WavePm, WaveTrend, WaveTrendOutput, Wedge, WeightedClose, WickRatio, - WilliamsFractals, WilliamsFractalsOutput, WilliamsR, WinRate, Wma, WoodiePivots, + ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TickIndex, Tii, TimeBasedStop, + TimeOfDayReturnProfile, TimeOfDayReturnProfileOutput, TpoProfile, TpoProfileOutput, + TradeImbalance, TrendLabel, TrendStrengthIndex, TreynorRatio, Triangle, Trima, Trin, + TripleTopBottom, Trix, TrueRange, Tsf, TsfOscillator, Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, + TtmTrend, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, + UniqueThreeRiver, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, + ValueAreaOutput, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, Vidya, + VolatilityCone, VolatilityConeOutput, VolatilityOfVolatility, VolatilityRatio, VoltyStop, + VolumeByTimeProfile, VolumeByTimeProfileOutput, VolumeOscillator, VolumePriceTrend, + VolumeProfile, VolumeProfileOutput, Vortex, VortexOutput, Vpin, Vwap, VwapStdDevBands, + VwapStdDevBandsOutput, Vwma, Vzo, WavePm, WaveTrend, WaveTrendOutput, Wedge, WeightedClose, + WickRatio, WilliamsFractals, WilliamsFractalsOutput, WilliamsR, WinRate, Wma, WoodiePivots, WoodiePivotsOutput, YangZhangVolatility, YoyoExit, ZScore, ZeroLagMacd, ZeroLagMacdOutput, ZigZag, ZigZagOutput, Zlema, FAMILIES, T3, }; diff --git a/docs/README.md b/docs/README.md index 2924c8b8..f6ee6777 100644 --- a/docs/README.md +++ b/docs/README.md @@ -8,7 +8,7 @@ That includes: [Python](https://docs.wickra.org/Quickstart-Python), [Node](https://docs.wickra.org/Quickstart-Node), and [WASM](https://docs.wickra.org/Quickstart-WASM). -- A per-indicator deep dive for every one of the **434 indicators** across +- A per-indicator deep dive for every one of the **440 indicators** across the sixteen families (Moving Averages, Momentum Oscillators, Trend & Directional, Price Oscillators, Volatility & Bands, Bands & Channels, Trailing Stops, Volume, Price Statistics, Ehlers / Cycle DSP, Pivots & diff --git a/fuzz/fuzz_targets/indicator_update_candle.rs b/fuzz/fuzz_targets/indicator_update_candle.rs index f23ad82b..ac90d858 100644 --- a/fuzz/fuzz_targets/indicator_update_candle.rs +++ b/fuzz/fuzz_targets/indicator_update_candle.rs @@ -22,7 +22,7 @@ //! WeightedClose. use libfuzzer_sys::fuzz_target; -use wickra_core::{AbandonedBaby, Abcd, AccelerationBands, AcceleratorOscillator, AdOscillator, Adl, AdvanceBlock, Adx, Adxr, Alligator, AnchoredVwap, Aroon, AroonOscillator, Atr, AtrBands, AtrTrailingStop, AutoFib, AverageDailyRange, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BatchExt, BeltHold, BodySizePct, Breakaway, Butterfly, Camarilla, Candle, Cci, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, ConcealingBabySwallow, Counterattack, Crab, CupAndHandle, Cypher, DayOfWeekProfile, DemandIndex, DemarkPivots, Doji, DojiStar, Donchian, DonchianStop, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, Dx, EaseOfMovement, ElderRay, Engulfing, EveningDojiStar, Evwma, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FlagPennant, ForceIndex, FractalChaosBands, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GravestoneDoji, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, HiLoActivator, HighLowRange, HighWave, Hikkake, HikkakeModified, HomingPigeon, HurstChannel, Ichimoku, IdenticalThreeCrows, InNeck, Indicator, Inertia, InitialBalance, IntradayMomentumIndex, IntradayVolatilityProfile, InvertedHammer, KasePermissionStochastic, Keltner, Kicking, KickingByLength, Kvo, LadderBottom, LongLeggedDoji, LongLine, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, AvgPrice, MedianPrice, Mfi, MidPrice, MinusDi, MinusDm, MorningDojiStar, MorningEveningStar, Natr, Nvi, Obv, OnNeck, OpeningMarubozu, OpeningRange, OvernightGap, OvernightIntradayReturn, ParkinsonVolatility, Pgo, PiercingDarkCloud, PlusDi, PlusDm, ProjectionBands, ProjectionOscillator, Psar, Pvi, Qstick, RectangleRange, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollingVwap, Rvi, Rwi, SarExt, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, ShootingStar, ShortLine, Smi, SpinningTop, StalledPattern, StarcBands, StickSandwich, Stochastic, StochasticCci, SuperTrend, Takuri, TasukiGap, TdCombo, TdCountdown, TdDeMarker, TdDifferential, TdLines, TdOpen, TdPressure, TdRangeProjection, TdRei, TdRiskLevel, TdSequential, TdSetup, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TimeOfDayReturnProfile, TpoProfile, Triangle, TripleTopBottom, TrueRange, Tsv, TtmSqueeze, TtmTrend, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UltimateOscillator, UniqueThreeRiver, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, VolatilityCone, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, Vortex, Vwap, VwapStdDevBands, Vwma, Vzo, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsFractals, WilliamsR, WoodiePivots, YangZhangVolatility, YoyoExit, ZigZag}; +use wickra_core::{AbandonedBaby, Abcd, AccelerationBands, AcceleratorOscillator, AdOscillator, Adl, AdvanceBlock, Adx, Adxr, Alligator, AnchoredVwap, Aroon, AroonOscillator, Atr, AtrBands, AtrRatchet, AtrTrailingStop, AutoFib, AverageDailyRange, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BatchExt, BeltHold, BodySizePct, Breakaway, Butterfly, Camarilla, Candle, Cci, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, ConcealingBabySwallow, Counterattack, Crab, CupAndHandle, Cypher, DayOfWeekProfile, DemandIndex, DemarkPivots, Doji, DojiStar, Donchian, DonchianStop, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, Dx, EaseOfMovement, ElderRay, ElderSafeZone, Engulfing, EveningDojiStar, Evwma, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FlagPennant, ForceIndex, FractalChaosBands, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GravestoneDoji, Hammer, HangingMan, Harami, HeadAndShoulders, HeikinAshi, HiLoActivator, HighLowRange, HighWave, Hikkake, HikkakeModified, HomingPigeon, HurstChannel, Ichimoku, IdenticalThreeCrows, InNeck, Indicator, Inertia, InitialBalance, IntradayMomentumIndex, IntradayVolatilityProfile, InvertedHammer, KaseDevStop, KasePermissionStochastic, Keltner, Kicking, KickingByLength, Kvo, LadderBottom, LongLeggedDoji, LongLine, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, AvgPrice, MedianPrice, Mfi, MidPrice, MinusDi, MinusDm, ModifiedMaStop, MorningDojiStar, MorningEveningStar, Natr, Nrtr, Nvi, Obv, OnNeck, OpeningMarubozu, OpeningRange, OvernightGap, OvernightIntradayReturn, ParkinsonVolatility, Pgo, PiercingDarkCloud, PlusDi, PlusDm, ProjectionBands, ProjectionOscillator, Psar, Pvi, Qstick, RectangleRange, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollingVwap, Rvi, Rwi, SarExt, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, ShootingStar, ShortLine, Smi, SpinningTop, StalledPattern, StarcBands, StickSandwich, Stochastic, StochasticCci, SuperTrend, Takuri, TasukiGap, TdCombo, TdCountdown, TdDeMarker, TdDifferential, TdLines, TdOpen, TdPressure, TdRangeProjection, TdRei, TdRiskLevel, TdSequential, TdSetup, ThreeDrives, ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TimeBasedStop, TimeOfDayReturnProfile, TpoProfile, Triangle, TripleTopBottom, TrueRange, Tsv, TtmSqueeze, TtmTrend, TurnOfMonth, Tweezer, TwoCrows, TypicalPrice, UltimateOscillator, UniqueThreeRiver, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, VolatilityCone, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, Vortex, Vwap, VwapStdDevBands, Vwma, Vzo, WaveTrend, Wedge, WeightedClose, WickRatio, WilliamsFractals, WilliamsR, WoodiePivots, YangZhangVolatility, YoyoExit, ZigZag}; /// Convert a flat `f64` stream into a `Vec` by chunking it into /// `[open, high, low, close, volume]` groups. Tuples that fail OHLCV @@ -79,6 +79,11 @@ fuzz_target!(|data: Vec| { drive(|| Donchian::new(20).unwrap(), &candles); // --- Trailing Stops --- + drive(|| ModifiedMaStop::new(14).unwrap(), &candles); + drive(|| TimeBasedStop::new(5).unwrap(), &candles); + drive(|| Nrtr::new(2.0).unwrap(), &candles); + drive(|| AtrRatchet::new(14, 4.0, 0.1).unwrap(), &candles); + drive(|| ElderSafeZone::new(14, 2.0).unwrap(), &candles); drive(|| Psar::new(0.02, 0.02, 0.20).unwrap(), &candles); drive(SarExt::classic, &candles); drive(|| SuperTrend::new(14, 3.0).unwrap(), &candles); @@ -88,6 +93,7 @@ fuzz_target!(|data: Vec| { drive(|| HiLoActivator::new(3).unwrap(), &candles); drive(|| VoltyStop::new(14, 2.0).unwrap(), &candles); drive(|| YoyoExit::new(14, 2.0).unwrap(), &candles); + drive(|| KaseDevStop::new(30, 1.0).unwrap(), &candles); // --- Trend & Directional --- drive(|| KasePermissionStochastic::new(9, 3).unwrap(), &candles);