diff --git a/CHANGELOG.md b/CHANGELOG.md index 7d7d1675..a42c04d9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +### Added +- C ABI hub: every indicator now exposes `wickra__warmup_period` and + `wickra__is_ready`, closing the gap with the native bindings (which + already had them). The C-ABI languages surface them idiomatically: C# `int + WarmupPeriod()` / `bool IsReady()`, Go `WarmupPeriod()` / `IsReady()`, Java + `int warmupPeriod()` / `boolean isReady()`, and R `warmup_period()` / + `is_ready()` generics. The alt-chart bar builders are excluded by design (a + candle can complete 0..n bars, so they have no warmup). + ### Changed - Standardised programming-language naming and ordering across all docs, READMEs, the documentation site, marketing site, organization profile and GitHub diff --git a/bindings/c/include/wickra.h b/bindings/c/include/wickra.h index 0c4ca4e9..e8589bda 100644 --- a/bindings/c/include/wickra.h +++ b/bindings/c/include/wickra.h @@ -1688,6 +1688,10 @@ void wickra_adaptive_cycle_batch(struct AdaptiveCycle *handle, double *out, uintptr_t n); +uintptr_t wickra_adaptive_cycle_warmup_period(struct AdaptiveCycle *handle); + +bool wickra_adaptive_cycle_is_ready(struct AdaptiveCycle *handle); + void wickra_adaptive_cycle_reset(struct AdaptiveCycle *handle); void wickra_adaptive_cycle_free(struct AdaptiveCycle *handle); @@ -1701,6 +1705,10 @@ void wickra_adaptive_laguerre_filter_batch(struct AdaptiveLaguerreFilter *handle double *out, uintptr_t n); +uintptr_t wickra_adaptive_laguerre_filter_warmup_period(struct AdaptiveLaguerreFilter *handle); + +bool wickra_adaptive_laguerre_filter_is_ready(struct AdaptiveLaguerreFilter *handle); + void wickra_adaptive_laguerre_filter_reset(struct AdaptiveLaguerreFilter *handle); void wickra_adaptive_laguerre_filter_free(struct AdaptiveLaguerreFilter *handle); @@ -1714,6 +1722,10 @@ void wickra_adaptive_rsi_batch(struct AdaptiveRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_adaptive_rsi_warmup_period(struct AdaptiveRsi *handle); + +bool wickra_adaptive_rsi_is_ready(struct AdaptiveRsi *handle); + void wickra_adaptive_rsi_reset(struct AdaptiveRsi *handle); void wickra_adaptive_rsi_free(struct AdaptiveRsi *handle); @@ -1724,6 +1736,10 @@ double wickra_alma_update(struct Alma *handle, double value); void wickra_alma_batch(struct Alma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_alma_warmup_period(struct Alma *handle); + +bool wickra_alma_is_ready(struct Alma *handle); + void wickra_alma_reset(struct Alma *handle); void wickra_alma_free(struct Alma *handle); @@ -1737,6 +1753,10 @@ void wickra_anchored_rsi_batch(struct AnchoredRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_anchored_rsi_warmup_period(struct AnchoredRsi *handle); + +bool wickra_anchored_rsi_is_ready(struct AnchoredRsi *handle); + void wickra_anchored_rsi_reset(struct AnchoredRsi *handle); void wickra_anchored_rsi_free(struct AnchoredRsi *handle); @@ -1747,6 +1767,10 @@ double wickra_apo_update(struct Apo *handle, double value); void wickra_apo_batch(struct Apo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_apo_warmup_period(struct Apo *handle); + +bool wickra_apo_is_ready(struct Apo *handle); + void wickra_apo_reset(struct Apo *handle); void wickra_apo_free(struct Apo *handle); @@ -1760,6 +1784,10 @@ void wickra_autocorrelation_batch(struct Autocorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_autocorrelation_warmup_period(struct Autocorrelation *handle); + +bool wickra_autocorrelation_is_ready(struct Autocorrelation *handle); + void wickra_autocorrelation_reset(struct Autocorrelation *handle); void wickra_autocorrelation_free(struct Autocorrelation *handle); @@ -1775,6 +1803,10 @@ void wickra_autocorrelation_periodogram_batch(struct AutocorrelationPeriodogram double *out, uintptr_t n); +uintptr_t wickra_autocorrelation_periodogram_warmup_period(struct AutocorrelationPeriodogram *handle); + +bool wickra_autocorrelation_periodogram_is_ready(struct AutocorrelationPeriodogram *handle); + void wickra_autocorrelation_periodogram_reset(struct AutocorrelationPeriodogram *handle); void wickra_autocorrelation_periodogram_free(struct AutocorrelationPeriodogram *handle); @@ -1788,6 +1820,10 @@ void wickra_average_drawdown_batch(struct AverageDrawdown *handle, double *out, uintptr_t n); +uintptr_t wickra_average_drawdown_warmup_period(struct AverageDrawdown *handle); + +bool wickra_average_drawdown_is_ready(struct AverageDrawdown *handle); + void wickra_average_drawdown_reset(struct AverageDrawdown *handle); void wickra_average_drawdown_free(struct AverageDrawdown *handle); @@ -1801,6 +1837,10 @@ void wickra_bandpass_filter_batch(struct BandpassFilter *handle, double *out, uintptr_t n); +uintptr_t wickra_bandpass_filter_warmup_period(struct BandpassFilter *handle); + +bool wickra_bandpass_filter_is_ready(struct BandpassFilter *handle); + void wickra_bandpass_filter_reset(struct BandpassFilter *handle); void wickra_bandpass_filter_free(struct BandpassFilter *handle); @@ -1814,6 +1854,10 @@ void wickra_bipower_variation_batch(struct BipowerVariation *handle, double *out, uintptr_t n); +uintptr_t wickra_bipower_variation_warmup_period(struct BipowerVariation *handle); + +bool wickra_bipower_variation_is_ready(struct BipowerVariation *handle); + void wickra_bipower_variation_reset(struct BipowerVariation *handle); void wickra_bipower_variation_free(struct BipowerVariation *handle); @@ -1827,6 +1871,10 @@ void wickra_bollinger_bandwidth_batch(struct BollingerBandwidth *handle, double *out, uintptr_t n); +uintptr_t wickra_bollinger_bandwidth_warmup_period(struct BollingerBandwidth *handle); + +bool wickra_bollinger_bandwidth_is_ready(struct BollingerBandwidth *handle); + void wickra_bollinger_bandwidth_reset(struct BollingerBandwidth *handle); void wickra_bollinger_bandwidth_free(struct BollingerBandwidth *handle); @@ -1840,6 +1888,10 @@ void wickra_burke_ratio_batch(struct BurkeRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_burke_ratio_warmup_period(struct BurkeRatio *handle); + +bool wickra_burke_ratio_is_ready(struct BurkeRatio *handle); + void wickra_burke_ratio_reset(struct BurkeRatio *handle); void wickra_burke_ratio_free(struct BurkeRatio *handle); @@ -1853,6 +1905,10 @@ void wickra_calmar_ratio_batch(struct CalmarRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_calmar_ratio_warmup_period(struct CalmarRatio *handle); + +bool wickra_calmar_ratio_is_ready(struct CalmarRatio *handle); + void wickra_calmar_ratio_reset(struct CalmarRatio *handle); void wickra_calmar_ratio_free(struct CalmarRatio *handle); @@ -1866,6 +1922,10 @@ void wickra_center_of_gravity_batch(struct CenterOfGravity *handle, double *out, uintptr_t n); +uintptr_t wickra_center_of_gravity_warmup_period(struct CenterOfGravity *handle); + +bool wickra_center_of_gravity_is_ready(struct CenterOfGravity *handle); + void wickra_center_of_gravity_reset(struct CenterOfGravity *handle); void wickra_center_of_gravity_free(struct CenterOfGravity *handle); @@ -1876,6 +1936,10 @@ double wickra_cfo_update(struct Cfo *handle, double value); void wickra_cfo_batch(struct Cfo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_cfo_warmup_period(struct Cfo *handle); + +bool wickra_cfo_is_ready(struct Cfo *handle); + void wickra_cfo_reset(struct Cfo *handle); void wickra_cfo_free(struct Cfo *handle); @@ -1886,6 +1950,10 @@ double wickra_cmo_update(struct Cmo *handle, double value); void wickra_cmo_batch(struct Cmo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_cmo_warmup_period(struct Cmo *handle); + +bool wickra_cmo_is_ready(struct Cmo *handle); + void wickra_cmo_reset(struct Cmo *handle); void wickra_cmo_free(struct Cmo *handle); @@ -1899,6 +1967,10 @@ void wickra_coefficient_of_variation_batch(struct CoefficientOfVariation *handle double *out, uintptr_t n); +uintptr_t wickra_coefficient_of_variation_warmup_period(struct CoefficientOfVariation *handle); + +bool wickra_coefficient_of_variation_is_ready(struct CoefficientOfVariation *handle); + void wickra_coefficient_of_variation_reset(struct CoefficientOfVariation *handle); void wickra_coefficient_of_variation_free(struct CoefficientOfVariation *handle); @@ -1912,6 +1984,10 @@ void wickra_common_sense_ratio_batch(struct CommonSenseRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_common_sense_ratio_warmup_period(struct CommonSenseRatio *handle); + +bool wickra_common_sense_ratio_is_ready(struct CommonSenseRatio *handle); + void wickra_common_sense_ratio_reset(struct CommonSenseRatio *handle); void wickra_common_sense_ratio_free(struct CommonSenseRatio *handle); @@ -1926,6 +2002,10 @@ void wickra_conditional_value_at_risk_batch(struct ConditionalValueAtRisk *handl double *out, uintptr_t n); +uintptr_t wickra_conditional_value_at_risk_warmup_period(struct ConditionalValueAtRisk *handle); + +bool wickra_conditional_value_at_risk_is_ready(struct ConditionalValueAtRisk *handle); + void wickra_conditional_value_at_risk_reset(struct ConditionalValueAtRisk *handle); void wickra_conditional_value_at_risk_free(struct ConditionalValueAtRisk *handle); @@ -1941,6 +2021,10 @@ void wickra_connors_rsi_batch(struct ConnorsRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_connors_rsi_warmup_period(struct ConnorsRsi *handle); + +bool wickra_connors_rsi_is_ready(struct ConnorsRsi *handle); + void wickra_connors_rsi_reset(struct ConnorsRsi *handle); void wickra_connors_rsi_free(struct ConnorsRsi *handle); @@ -1953,6 +2037,10 @@ double wickra_coppock_update(struct Coppock *handle, double value); void wickra_coppock_batch(struct Coppock *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_coppock_warmup_period(struct Coppock *handle); + +bool wickra_coppock_is_ready(struct Coppock *handle); + void wickra_coppock_reset(struct Coppock *handle); void wickra_coppock_free(struct Coppock *handle); @@ -1967,6 +2055,10 @@ void wickra_correlation_trend_indicator_batch(struct CorrelationTrendIndicator * double *out, uintptr_t n); +uintptr_t wickra_correlation_trend_indicator_warmup_period(struct CorrelationTrendIndicator *handle); + +bool wickra_correlation_trend_indicator_is_ready(struct CorrelationTrendIndicator *handle); + void wickra_correlation_trend_indicator_reset(struct CorrelationTrendIndicator *handle); void wickra_correlation_trend_indicator_free(struct CorrelationTrendIndicator *handle); @@ -1980,6 +2072,10 @@ void wickra_cybernetic_cycle_batch(struct CyberneticCycle *handle, double *out, uintptr_t n); +uintptr_t wickra_cybernetic_cycle_warmup_period(struct CyberneticCycle *handle); + +bool wickra_cybernetic_cycle_is_ready(struct CyberneticCycle *handle); + void wickra_cybernetic_cycle_reset(struct CyberneticCycle *handle); void wickra_cybernetic_cycle_free(struct CyberneticCycle *handle); @@ -1990,6 +2086,10 @@ double wickra_decycler_update(struct Decycler *handle, double value); void wickra_decycler_batch(struct Decycler *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_decycler_warmup_period(struct Decycler *handle); + +bool wickra_decycler_is_ready(struct Decycler *handle); + void wickra_decycler_reset(struct Decycler *handle); void wickra_decycler_free(struct Decycler *handle); @@ -2003,6 +2103,10 @@ void wickra_decycler_oscillator_batch(struct DecyclerOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_decycler_oscillator_warmup_period(struct DecyclerOscillator *handle); + +bool wickra_decycler_oscillator_is_ready(struct DecyclerOscillator *handle); + void wickra_decycler_oscillator_reset(struct DecyclerOscillator *handle); void wickra_decycler_oscillator_free(struct DecyclerOscillator *handle); @@ -2013,6 +2117,10 @@ double wickra_dema_update(struct Dema *handle, double value); void wickra_dema_batch(struct Dema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_dema_warmup_period(struct Dema *handle); + +bool wickra_dema_is_ready(struct Dema *handle); + void wickra_dema_reset(struct Dema *handle); void wickra_dema_free(struct Dema *handle); @@ -2029,6 +2137,10 @@ void wickra_derivative_oscillator_batch(struct DerivativeOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_derivative_oscillator_warmup_period(struct DerivativeOscillator *handle); + +bool wickra_derivative_oscillator_is_ready(struct DerivativeOscillator *handle); + void wickra_derivative_oscillator_reset(struct DerivativeOscillator *handle); void wickra_derivative_oscillator_free(struct DerivativeOscillator *handle); @@ -2042,6 +2154,10 @@ void wickra_detrended_std_dev_batch(struct DetrendedStdDev *handle, double *out, uintptr_t n); +uintptr_t wickra_detrended_std_dev_warmup_period(struct DetrendedStdDev *handle); + +bool wickra_detrended_std_dev_is_ready(struct DetrendedStdDev *handle); + void wickra_detrended_std_dev_reset(struct DetrendedStdDev *handle); void wickra_detrended_std_dev_free(struct DetrendedStdDev *handle); @@ -2055,6 +2171,10 @@ void wickra_disparity_index_batch(struct DisparityIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_disparity_index_warmup_period(struct DisparityIndex *handle); + +bool wickra_disparity_index_is_ready(struct DisparityIndex *handle); + void wickra_disparity_index_reset(struct DisparityIndex *handle); void wickra_disparity_index_free(struct DisparityIndex *handle); @@ -2065,6 +2185,10 @@ double wickra_dpo_update(struct Dpo *handle, double value); void wickra_dpo_batch(struct Dpo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_dpo_warmup_period(struct Dpo *handle); + +bool wickra_dpo_is_ready(struct Dpo *handle); + void wickra_dpo_reset(struct Dpo *handle); void wickra_dpo_free(struct Dpo *handle); @@ -2078,6 +2202,10 @@ void wickra_drawdown_duration_batch(struct DrawdownDuration *handle, double *out, uintptr_t n); +uintptr_t wickra_drawdown_duration_warmup_period(struct DrawdownDuration *handle); + +bool wickra_drawdown_duration_is_ready(struct DrawdownDuration *handle); + void wickra_drawdown_duration_reset(struct DrawdownDuration *handle); void wickra_drawdown_duration_free(struct DrawdownDuration *handle); @@ -2091,6 +2219,10 @@ void wickra_dynamic_momentum_index_batch(struct DynamicMomentumIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_dynamic_momentum_index_warmup_period(struct DynamicMomentumIndex *handle); + +bool wickra_dynamic_momentum_index_is_ready(struct DynamicMomentumIndex *handle); + void wickra_dynamic_momentum_index_reset(struct DynamicMomentumIndex *handle); void wickra_dynamic_momentum_index_free(struct DynamicMomentumIndex *handle); @@ -2104,6 +2236,10 @@ void wickra_ehlers_stochastic_batch(struct EhlersStochastic *handle, double *out, uintptr_t n); +uintptr_t wickra_ehlers_stochastic_warmup_period(struct EhlersStochastic *handle); + +bool wickra_ehlers_stochastic_is_ready(struct EhlersStochastic *handle); + void wickra_ehlers_stochastic_reset(struct EhlersStochastic *handle); void wickra_ehlers_stochastic_free(struct EhlersStochastic *handle); @@ -2114,6 +2250,10 @@ double wickra_ehma_update(struct Ehma *handle, double value); void wickra_ehma_batch(struct Ehma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_ehma_warmup_period(struct Ehma *handle); + +bool wickra_ehma_is_ready(struct Ehma *handle); + void wickra_ehma_reset(struct Ehma *handle); void wickra_ehma_free(struct Ehma *handle); @@ -2130,6 +2270,10 @@ void wickra_elder_impulse_batch(struct ElderImpulse *handle, double *out, uintptr_t n); +uintptr_t wickra_elder_impulse_warmup_period(struct ElderImpulse *handle); + +bool wickra_elder_impulse_is_ready(struct ElderImpulse *handle); + void wickra_elder_impulse_reset(struct ElderImpulse *handle); void wickra_elder_impulse_free(struct ElderImpulse *handle); @@ -2140,6 +2284,10 @@ double wickra_ema_update(struct Ema *handle, double value); void wickra_ema_batch(struct Ema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_ema_warmup_period(struct Ema *handle); + +bool wickra_ema_is_ready(struct Ema *handle); + void wickra_ema_reset(struct Ema *handle); void wickra_ema_free(struct Ema *handle); @@ -2155,6 +2303,10 @@ void wickra_empirical_mode_decomposition_batch(struct EmpiricalModeDecomposition double *out, uintptr_t n); +uintptr_t wickra_empirical_mode_decomposition_warmup_period(struct EmpiricalModeDecomposition *handle); + +bool wickra_empirical_mode_decomposition_is_ready(struct EmpiricalModeDecomposition *handle); + void wickra_empirical_mode_decomposition_reset(struct EmpiricalModeDecomposition *handle); void wickra_empirical_mode_decomposition_free(struct EmpiricalModeDecomposition *handle); @@ -2169,6 +2321,10 @@ void wickra_even_better_sinewave_batch(struct EvenBetterSinewave *handle, double *out, uintptr_t n); +uintptr_t wickra_even_better_sinewave_warmup_period(struct EvenBetterSinewave *handle); + +bool wickra_even_better_sinewave_is_ready(struct EvenBetterSinewave *handle); + void wickra_even_better_sinewave_reset(struct EvenBetterSinewave *handle); void wickra_even_better_sinewave_free(struct EvenBetterSinewave *handle); @@ -2182,6 +2338,10 @@ void wickra_ewma_volatility_batch(struct EwmaVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_ewma_volatility_warmup_period(struct EwmaVolatility *handle); + +bool wickra_ewma_volatility_is_ready(struct EwmaVolatility *handle); + void wickra_ewma_volatility_reset(struct EwmaVolatility *handle); void wickra_ewma_volatility_free(struct EwmaVolatility *handle); @@ -2195,6 +2355,10 @@ void wickra_expectancy_batch(struct Expectancy *handle, double *out, uintptr_t n); +uintptr_t wickra_expectancy_warmup_period(struct Expectancy *handle); + +bool wickra_expectancy_is_ready(struct Expectancy *handle); + void wickra_expectancy_reset(struct Expectancy *handle); void wickra_expectancy_free(struct Expectancy *handle); @@ -2205,6 +2369,10 @@ double wickra_fama_update(struct Fama *handle, double value); void wickra_fama_batch(struct Fama *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_fama_warmup_period(struct Fama *handle); + +bool wickra_fama_is_ready(struct Fama *handle); + void wickra_fama_reset(struct Fama *handle); void wickra_fama_free(struct Fama *handle); @@ -2218,6 +2386,10 @@ void wickra_fisher_rsi_batch(struct FisherRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_fisher_rsi_warmup_period(struct FisherRsi *handle); + +bool wickra_fisher_rsi_is_ready(struct FisherRsi *handle); + void wickra_fisher_rsi_reset(struct FisherRsi *handle); void wickra_fisher_rsi_free(struct FisherRsi *handle); @@ -2231,6 +2403,10 @@ void wickra_fisher_transform_batch(struct FisherTransform *handle, double *out, uintptr_t n); +uintptr_t wickra_fisher_transform_warmup_period(struct FisherTransform *handle); + +bool wickra_fisher_transform_is_ready(struct FisherTransform *handle); + void wickra_fisher_transform_reset(struct FisherTransform *handle); void wickra_fisher_transform_free(struct FisherTransform *handle); @@ -2241,6 +2417,10 @@ double wickra_frama_update(struct Frama *handle, double value); void wickra_frama_batch(struct Frama *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_frama_warmup_period(struct Frama *handle); + +bool wickra_frama_is_ready(struct Frama *handle); + void wickra_frama_reset(struct Frama *handle); void wickra_frama_free(struct Frama *handle); @@ -2254,6 +2434,10 @@ void wickra_gain_loss_ratio_batch(struct GainLossRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_gain_loss_ratio_warmup_period(struct GainLossRatio *handle); + +bool wickra_gain_loss_ratio_is_ready(struct GainLossRatio *handle); + void wickra_gain_loss_ratio_reset(struct GainLossRatio *handle); void wickra_gain_loss_ratio_free(struct GainLossRatio *handle); @@ -2267,6 +2451,10 @@ void wickra_gain_to_pain_ratio_batch(struct GainToPainRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_gain_to_pain_ratio_warmup_period(struct GainToPainRatio *handle); + +bool wickra_gain_to_pain_ratio_is_ready(struct GainToPainRatio *handle); + void wickra_gain_to_pain_ratio_reset(struct GainToPainRatio *handle); void wickra_gain_to_pain_ratio_free(struct GainToPainRatio *handle); @@ -2277,6 +2465,10 @@ double wickra_garch11_update(struct Garch11 *handle, double value); void wickra_garch11_batch(struct Garch11 *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_garch11_warmup_period(struct Garch11 *handle); + +bool wickra_garch11_is_ready(struct Garch11 *handle); + void wickra_garch11_reset(struct Garch11 *handle); void wickra_garch11_free(struct Garch11 *handle); @@ -2290,6 +2482,10 @@ void wickra_generalized_dema_batch(struct GeneralizedDema *handle, double *out, uintptr_t n); +uintptr_t wickra_generalized_dema_warmup_period(struct GeneralizedDema *handle); + +bool wickra_generalized_dema_is_ready(struct GeneralizedDema *handle); + void wickra_generalized_dema_reset(struct GeneralizedDema *handle); void wickra_generalized_dema_free(struct GeneralizedDema *handle); @@ -2303,6 +2499,10 @@ void wickra_geometric_ma_batch(struct GeometricMa *handle, double *out, uintptr_t n); +uintptr_t wickra_geometric_ma_warmup_period(struct GeometricMa *handle); + +bool wickra_geometric_ma_is_ready(struct GeometricMa *handle); + void wickra_geometric_ma_reset(struct GeometricMa *handle); void wickra_geometric_ma_free(struct GeometricMa *handle); @@ -2316,6 +2516,10 @@ void wickra_highpass_filter_batch(struct HighpassFilter *handle, double *out, uintptr_t n); +uintptr_t wickra_highpass_filter_warmup_period(struct HighpassFilter *handle); + +bool wickra_highpass_filter_is_ready(struct HighpassFilter *handle); + void wickra_highpass_filter_reset(struct HighpassFilter *handle); void wickra_highpass_filter_free(struct HighpassFilter *handle); @@ -2329,6 +2533,10 @@ void wickra_hilbert_dominant_cycle_batch(struct HilbertDominantCycle *handle, double *out, uintptr_t n); +uintptr_t wickra_hilbert_dominant_cycle_warmup_period(struct HilbertDominantCycle *handle); + +bool wickra_hilbert_dominant_cycle_is_ready(struct HilbertDominantCycle *handle); + void wickra_hilbert_dominant_cycle_reset(struct HilbertDominantCycle *handle); void wickra_hilbert_dominant_cycle_free(struct HilbertDominantCycle *handle); @@ -2343,6 +2551,10 @@ void wickra_historical_volatility_batch(struct HistoricalVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_historical_volatility_warmup_period(struct HistoricalVolatility *handle); + +bool wickra_historical_volatility_is_ready(struct HistoricalVolatility *handle); + void wickra_historical_volatility_reset(struct HistoricalVolatility *handle); void wickra_historical_volatility_free(struct HistoricalVolatility *handle); @@ -2353,6 +2565,10 @@ double wickra_hma_update(struct Hma *handle, double value); void wickra_hma_batch(struct Hma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_hma_warmup_period(struct Hma *handle); + +bool wickra_hma_is_ready(struct Hma *handle); + void wickra_hma_reset(struct Hma *handle); void wickra_hma_free(struct Hma *handle); @@ -2366,6 +2582,10 @@ void wickra_holt_winters_batch(struct HoltWinters *handle, double *out, uintptr_t n); +uintptr_t wickra_holt_winters_warmup_period(struct HoltWinters *handle); + +bool wickra_holt_winters_is_ready(struct HoltWinters *handle); + void wickra_holt_winters_reset(struct HoltWinters *handle); void wickra_holt_winters_free(struct HoltWinters *handle); @@ -2379,6 +2599,10 @@ void wickra_ht_dc_phase_batch(struct HtDcPhase *handle, double *out, uintptr_t n); +uintptr_t wickra_ht_dc_phase_warmup_period(struct HtDcPhase *handle); + +bool wickra_ht_dc_phase_is_ready(struct HtDcPhase *handle); + void wickra_ht_dc_phase_reset(struct HtDcPhase *handle); void wickra_ht_dc_phase_free(struct HtDcPhase *handle); @@ -2392,6 +2616,10 @@ void wickra_ht_trend_mode_batch(struct HtTrendMode *handle, double *out, uintptr_t n); +uintptr_t wickra_ht_trend_mode_warmup_period(struct HtTrendMode *handle); + +bool wickra_ht_trend_mode_is_ready(struct HtTrendMode *handle); + void wickra_ht_trend_mode_reset(struct HtTrendMode *handle); void wickra_ht_trend_mode_free(struct HtTrendMode *handle); @@ -2405,6 +2633,10 @@ void wickra_hurst_exponent_batch(struct HurstExponent *handle, double *out, uintptr_t n); +uintptr_t wickra_hurst_exponent_warmup_period(struct HurstExponent *handle); + +bool wickra_hurst_exponent_is_ready(struct HurstExponent *handle); + void wickra_hurst_exponent_reset(struct HurstExponent *handle); void wickra_hurst_exponent_free(struct HurstExponent *handle); @@ -2418,6 +2650,10 @@ void wickra_instantaneous_trendline_batch(struct InstantaneousTrendline *handle, double *out, uintptr_t n); +uintptr_t wickra_instantaneous_trendline_warmup_period(struct InstantaneousTrendline *handle); + +bool wickra_instantaneous_trendline_is_ready(struct InstantaneousTrendline *handle); + void wickra_instantaneous_trendline_reset(struct InstantaneousTrendline *handle); void wickra_instantaneous_trendline_free(struct InstantaneousTrendline *handle); @@ -2431,6 +2667,10 @@ void wickra_inverse_fisher_transform_batch(struct InverseFisherTransform *handle double *out, uintptr_t n); +uintptr_t wickra_inverse_fisher_transform_warmup_period(struct InverseFisherTransform *handle); + +bool wickra_inverse_fisher_transform_is_ready(struct InverseFisherTransform *handle); + void wickra_inverse_fisher_transform_reset(struct InverseFisherTransform *handle); void wickra_inverse_fisher_transform_free(struct InverseFisherTransform *handle); @@ -2444,6 +2684,10 @@ void wickra_jarque_bera_batch(struct JarqueBera *handle, double *out, uintptr_t n); +uintptr_t wickra_jarque_bera_warmup_period(struct JarqueBera *handle); + +bool wickra_jarque_bera_is_ready(struct JarqueBera *handle); + void wickra_jarque_bera_reset(struct JarqueBera *handle); void wickra_jarque_bera_free(struct JarqueBera *handle); @@ -2454,6 +2698,10 @@ double wickra_jma_update(struct Jma *handle, double value); void wickra_jma_batch(struct Jma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_jma_warmup_period(struct Jma *handle); + +bool wickra_jma_is_ready(struct Jma *handle); + void wickra_jma_reset(struct Jma *handle); void wickra_jma_free(struct Jma *handle); @@ -2467,6 +2715,10 @@ void wickra_jump_indicator_batch(struct JumpIndicator *handle, double *out, uintptr_t n); +uintptr_t wickra_jump_indicator_warmup_period(struct JumpIndicator *handle); + +bool wickra_jump_indicator_is_ready(struct JumpIndicator *handle); + void wickra_jump_indicator_reset(struct JumpIndicator *handle); void wickra_jump_indicator_free(struct JumpIndicator *handle); @@ -2477,6 +2729,10 @@ double wickra_k_ratio_update(struct KRatio *handle, double value); void wickra_k_ratio_batch(struct KRatio *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_k_ratio_warmup_period(struct KRatio *handle); + +bool wickra_k_ratio_is_ready(struct KRatio *handle); + void wickra_k_ratio_reset(struct KRatio *handle); void wickra_k_ratio_free(struct KRatio *handle); @@ -2487,6 +2743,10 @@ double wickra_kama_update(struct Kama *handle, double value); void wickra_kama_batch(struct Kama *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_kama_warmup_period(struct Kama *handle); + +bool wickra_kama_is_ready(struct Kama *handle); + void wickra_kama_reset(struct Kama *handle); void wickra_kama_free(struct Kama *handle); @@ -2500,6 +2760,10 @@ void wickra_kelly_criterion_batch(struct KellyCriterion *handle, double *out, uintptr_t n); +uintptr_t wickra_kelly_criterion_warmup_period(struct KellyCriterion *handle); + +bool wickra_kelly_criterion_is_ready(struct KellyCriterion *handle); + void wickra_kelly_criterion_reset(struct KellyCriterion *handle); void wickra_kelly_criterion_free(struct KellyCriterion *handle); @@ -2510,6 +2774,10 @@ double wickra_kurtosis_update(struct Kurtosis *handle, double value); void wickra_kurtosis_batch(struct Kurtosis *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_kurtosis_warmup_period(struct Kurtosis *handle); + +bool wickra_kurtosis_is_ready(struct Kurtosis *handle); + void wickra_kurtosis_reset(struct Kurtosis *handle); void wickra_kurtosis_free(struct Kurtosis *handle); @@ -2523,6 +2791,10 @@ void wickra_laguerre_rsi_batch(struct LaguerreRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_laguerre_rsi_warmup_period(struct LaguerreRsi *handle); + +bool wickra_laguerre_rsi_is_ready(struct LaguerreRsi *handle); + void wickra_laguerre_rsi_reset(struct LaguerreRsi *handle); void wickra_laguerre_rsi_free(struct LaguerreRsi *handle); @@ -2536,6 +2808,10 @@ void wickra_linear_regression_batch(struct LinearRegression *handle, double *out, uintptr_t n); +uintptr_t wickra_linear_regression_warmup_period(struct LinearRegression *handle); + +bool wickra_linear_regression_is_ready(struct LinearRegression *handle); + void wickra_linear_regression_reset(struct LinearRegression *handle); void wickra_linear_regression_free(struct LinearRegression *handle); @@ -2549,6 +2825,10 @@ void wickra_lin_reg_angle_batch(struct LinRegAngle *handle, double *out, uintptr_t n); +uintptr_t wickra_lin_reg_angle_warmup_period(struct LinRegAngle *handle); + +bool wickra_lin_reg_angle_is_ready(struct LinRegAngle *handle); + void wickra_lin_reg_angle_reset(struct LinRegAngle *handle); void wickra_lin_reg_angle_free(struct LinRegAngle *handle); @@ -2562,6 +2842,10 @@ void wickra_lin_reg_intercept_batch(struct LinRegIntercept *handle, double *out, uintptr_t n); +uintptr_t wickra_lin_reg_intercept_warmup_period(struct LinRegIntercept *handle); + +bool wickra_lin_reg_intercept_is_ready(struct LinRegIntercept *handle); + void wickra_lin_reg_intercept_reset(struct LinRegIntercept *handle); void wickra_lin_reg_intercept_free(struct LinRegIntercept *handle); @@ -2575,6 +2859,10 @@ void wickra_lin_reg_slope_batch(struct LinRegSlope *handle, double *out, uintptr_t n); +uintptr_t wickra_lin_reg_slope_warmup_period(struct LinRegSlope *handle); + +bool wickra_lin_reg_slope_is_ready(struct LinRegSlope *handle); + void wickra_lin_reg_slope_reset(struct LinRegSlope *handle); void wickra_lin_reg_slope_free(struct LinRegSlope *handle); @@ -2588,6 +2876,10 @@ void wickra_log_return_batch(struct LogReturn *handle, double *out, uintptr_t n); +uintptr_t wickra_log_return_warmup_period(struct LogReturn *handle); + +bool wickra_log_return_is_ready(struct LogReturn *handle); + void wickra_log_return_reset(struct LogReturn *handle); void wickra_log_return_free(struct LogReturn *handle); @@ -2603,6 +2895,10 @@ void wickra_m2_measure_batch(struct M2Measure *handle, double *out, uintptr_t n); +uintptr_t wickra_m2_measure_warmup_period(struct M2Measure *handle); + +bool wickra_m2_measure_is_ready(struct M2Measure *handle); + void wickra_m2_measure_reset(struct M2Measure *handle); void wickra_m2_measure_free(struct M2Measure *handle); @@ -2616,6 +2912,10 @@ void wickra_macd_histogram_batch(struct MacdHistogram *handle, double *out, uintptr_t n); +uintptr_t wickra_macd_histogram_warmup_period(struct MacdHistogram *handle); + +bool wickra_macd_histogram_is_ready(struct MacdHistogram *handle); + void wickra_macd_histogram_reset(struct MacdHistogram *handle); void wickra_macd_histogram_free(struct MacdHistogram *handle); @@ -2629,6 +2929,10 @@ void wickra_martin_ratio_batch(struct MartinRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_martin_ratio_warmup_period(struct MartinRatio *handle); + +bool wickra_martin_ratio_is_ready(struct MartinRatio *handle); + void wickra_martin_ratio_reset(struct MartinRatio *handle); void wickra_martin_ratio_free(struct MartinRatio *handle); @@ -2642,6 +2946,10 @@ void wickra_max_drawdown_batch(struct MaxDrawdown *handle, double *out, uintptr_t n); +uintptr_t wickra_max_drawdown_warmup_period(struct MaxDrawdown *handle); + +bool wickra_max_drawdown_is_ready(struct MaxDrawdown *handle); + void wickra_max_drawdown_reset(struct MaxDrawdown *handle); void wickra_max_drawdown_free(struct MaxDrawdown *handle); @@ -2655,6 +2963,10 @@ void wickra_mc_ginley_dynamic_batch(struct McGinleyDynamic *handle, double *out, uintptr_t n); +uintptr_t wickra_mc_ginley_dynamic_warmup_period(struct McGinleyDynamic *handle); + +bool wickra_mc_ginley_dynamic_is_ready(struct McGinleyDynamic *handle); + void wickra_mc_ginley_dynamic_reset(struct McGinleyDynamic *handle); void wickra_mc_ginley_dynamic_free(struct McGinleyDynamic *handle); @@ -2669,6 +2981,10 @@ void wickra_median_absolute_deviation_batch(struct MedianAbsoluteDeviation *hand double *out, uintptr_t n); +uintptr_t wickra_median_absolute_deviation_warmup_period(struct MedianAbsoluteDeviation *handle); + +bool wickra_median_absolute_deviation_is_ready(struct MedianAbsoluteDeviation *handle); + void wickra_median_absolute_deviation_reset(struct MedianAbsoluteDeviation *handle); void wickra_median_absolute_deviation_free(struct MedianAbsoluteDeviation *handle); @@ -2679,6 +2995,10 @@ double wickra_median_ma_update(struct MedianMa *handle, double value); void wickra_median_ma_batch(struct MedianMa *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_median_ma_warmup_period(struct MedianMa *handle); + +bool wickra_median_ma_is_ready(struct MedianMa *handle); + void wickra_median_ma_reset(struct MedianMa *handle); void wickra_median_ma_free(struct MedianMa *handle); @@ -2689,6 +3009,10 @@ double wickra_mid_point_update(struct MidPoint *handle, double value); void wickra_mid_point_batch(struct MidPoint *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_mid_point_warmup_period(struct MidPoint *handle); + +bool wickra_mid_point_is_ready(struct MidPoint *handle); + void wickra_mid_point_reset(struct MidPoint *handle); void wickra_mid_point_free(struct MidPoint *handle); @@ -2699,6 +3023,10 @@ double wickra_mom_update(struct Mom *handle, double value); void wickra_mom_batch(struct Mom *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_mom_warmup_period(struct Mom *handle); + +bool wickra_mom_is_ready(struct Mom *handle); + void wickra_mom_reset(struct Mom *handle); void wickra_mom_free(struct Mom *handle); @@ -2712,6 +3040,10 @@ void wickra_omega_ratio_batch(struct OmegaRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_omega_ratio_warmup_period(struct OmegaRatio *handle); + +bool wickra_omega_ratio_is_ready(struct OmegaRatio *handle); + void wickra_omega_ratio_reset(struct OmegaRatio *handle); void wickra_omega_ratio_free(struct OmegaRatio *handle); @@ -2725,6 +3057,10 @@ void wickra_pain_index_batch(struct PainIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_pain_index_warmup_period(struct PainIndex *handle); + +bool wickra_pain_index_is_ready(struct PainIndex *handle); + void wickra_pain_index_reset(struct PainIndex *handle); void wickra_pain_index_free(struct PainIndex *handle); @@ -2735,6 +3071,10 @@ double wickra_percent_b_update(struct PercentB *handle, double value); void wickra_percent_b_batch(struct PercentB *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_percent_b_warmup_period(struct PercentB *handle); + +bool wickra_percent_b_is_ready(struct PercentB *handle); + void wickra_percent_b_reset(struct PercentB *handle); void wickra_percent_b_free(struct PercentB *handle); @@ -2748,6 +3088,10 @@ void wickra_percentage_trailing_stop_batch(struct PercentageTrailingStop *handle double *out, uintptr_t n); +uintptr_t wickra_percentage_trailing_stop_warmup_period(struct PercentageTrailingStop *handle); + +bool wickra_percentage_trailing_stop_is_ready(struct PercentageTrailingStop *handle); + void wickra_percentage_trailing_stop_reset(struct PercentageTrailingStop *handle); void wickra_percentage_trailing_stop_free(struct PercentageTrailingStop *handle); @@ -2758,6 +3102,10 @@ double wickra_pmo_update(struct Pmo *handle, double value); void wickra_pmo_batch(struct Pmo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_pmo_warmup_period(struct Pmo *handle); + +bool wickra_pmo_is_ready(struct Pmo *handle); + void wickra_pmo_reset(struct Pmo *handle); void wickra_pmo_free(struct Pmo *handle); @@ -2773,6 +3121,10 @@ void wickra_polarized_fractal_efficiency_batch(struct PolarizedFractalEfficiency double *out, uintptr_t n); +uintptr_t wickra_polarized_fractal_efficiency_warmup_period(struct PolarizedFractalEfficiency *handle); + +bool wickra_polarized_fractal_efficiency_is_ready(struct PolarizedFractalEfficiency *handle); + void wickra_polarized_fractal_efficiency_reset(struct PolarizedFractalEfficiency *handle); void wickra_polarized_fractal_efficiency_free(struct PolarizedFractalEfficiency *handle); @@ -2783,6 +3135,10 @@ double wickra_ppo_update(struct Ppo *handle, double value); void wickra_ppo_batch(struct Ppo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_ppo_warmup_period(struct Ppo *handle); + +bool wickra_ppo_is_ready(struct Ppo *handle); + void wickra_ppo_reset(struct Ppo *handle); void wickra_ppo_free(struct Ppo *handle); @@ -2796,6 +3152,10 @@ void wickra_ppo_histogram_batch(struct PpoHistogram *handle, double *out, uintptr_t n); +uintptr_t wickra_ppo_histogram_warmup_period(struct PpoHistogram *handle); + +bool wickra_ppo_histogram_is_ready(struct PpoHistogram *handle); + void wickra_ppo_histogram_reset(struct PpoHistogram *handle); void wickra_ppo_histogram_free(struct PpoHistogram *handle); @@ -2809,6 +3169,10 @@ void wickra_profit_factor_batch(struct ProfitFactor *handle, double *out, uintptr_t n); +uintptr_t wickra_profit_factor_warmup_period(struct ProfitFactor *handle); + +bool wickra_profit_factor_is_ready(struct ProfitFactor *handle); + void wickra_profit_factor_reset(struct ProfitFactor *handle); void wickra_profit_factor_free(struct ProfitFactor *handle); @@ -2819,6 +3183,10 @@ double wickra_r_squared_update(struct RSquared *handle, double value); void wickra_r_squared_batch(struct RSquared *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_r_squared_warmup_period(struct RSquared *handle); + +bool wickra_r_squared_is_ready(struct RSquared *handle); + void wickra_r_squared_reset(struct RSquared *handle); void wickra_r_squared_free(struct RSquared *handle); @@ -2832,6 +3200,10 @@ void wickra_realized_volatility_batch(struct RealizedVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_realized_volatility_warmup_period(struct RealizedVolatility *handle); + +bool wickra_realized_volatility_is_ready(struct RealizedVolatility *handle); + void wickra_realized_volatility_reset(struct RealizedVolatility *handle); void wickra_realized_volatility_free(struct RealizedVolatility *handle); @@ -2845,6 +3217,10 @@ void wickra_recovery_factor_batch(struct RecoveryFactor *handle, double *out, uintptr_t n); +uintptr_t wickra_recovery_factor_warmup_period(struct RecoveryFactor *handle); + +bool wickra_recovery_factor_is_ready(struct RecoveryFactor *handle); + void wickra_recovery_factor_reset(struct RecoveryFactor *handle); void wickra_recovery_factor_free(struct RecoveryFactor *handle); @@ -2855,6 +3231,10 @@ double wickra_reflex_update(struct Reflex *handle, double value); void wickra_reflex_batch(struct Reflex *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_reflex_warmup_period(struct Reflex *handle); + +bool wickra_reflex_is_ready(struct Reflex *handle); + void wickra_reflex_reset(struct Reflex *handle); void wickra_reflex_free(struct Reflex *handle); @@ -2868,6 +3248,10 @@ void wickra_regime_label_batch(struct RegimeLabel *handle, double *out, uintptr_t n); +uintptr_t wickra_regime_label_warmup_period(struct RegimeLabel *handle); + +bool wickra_regime_label_is_ready(struct RegimeLabel *handle); + void wickra_regime_label_reset(struct RegimeLabel *handle); void wickra_regime_label_free(struct RegimeLabel *handle); @@ -2881,6 +3265,10 @@ void wickra_renko_trailing_stop_batch(struct RenkoTrailingStop *handle, double *out, uintptr_t n); +uintptr_t wickra_renko_trailing_stop_warmup_period(struct RenkoTrailingStop *handle); + +bool wickra_renko_trailing_stop_is_ready(struct RenkoTrailingStop *handle); + void wickra_renko_trailing_stop_reset(struct RenkoTrailingStop *handle); void wickra_renko_trailing_stop_free(struct RenkoTrailingStop *handle); @@ -2891,6 +3279,10 @@ double wickra_rmi_update(struct Rmi *handle, double value); void wickra_rmi_batch(struct Rmi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rmi_warmup_period(struct Rmi *handle); + +bool wickra_rmi_is_ready(struct Rmi *handle); + void wickra_rmi_reset(struct Rmi *handle); void wickra_rmi_free(struct Rmi *handle); @@ -2901,6 +3293,10 @@ double wickra_roc_update(struct Roc *handle, double value); void wickra_roc_batch(struct Roc *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_roc_warmup_period(struct Roc *handle); + +bool wickra_roc_is_ready(struct Roc *handle); + void wickra_roc_reset(struct Roc *handle); void wickra_roc_free(struct Roc *handle); @@ -2911,6 +3307,10 @@ double wickra_rocp_update(struct Rocp *handle, double value); void wickra_rocp_batch(struct Rocp *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rocp_warmup_period(struct Rocp *handle); + +bool wickra_rocp_is_ready(struct Rocp *handle); + void wickra_rocp_reset(struct Rocp *handle); void wickra_rocp_free(struct Rocp *handle); @@ -2921,6 +3321,10 @@ double wickra_rocr_update(struct Rocr *handle, double value); void wickra_rocr_batch(struct Rocr *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rocr_warmup_period(struct Rocr *handle); + +bool wickra_rocr_is_ready(struct Rocr *handle); + void wickra_rocr_reset(struct Rocr *handle); void wickra_rocr_free(struct Rocr *handle); @@ -2931,6 +3335,10 @@ double wickra_rocr100_update(struct Rocr100 *handle, double value); void wickra_rocr100_batch(struct Rocr100 *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rocr100_warmup_period(struct Rocr100 *handle); + +bool wickra_rocr100_is_ready(struct Rocr100 *handle); + void wickra_rocr100_reset(struct Rocr100 *handle); void wickra_rocr100_free(struct Rocr100 *handle); @@ -2944,6 +3352,10 @@ void wickra_rolling_iqr_batch(struct RollingIqr *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_iqr_warmup_period(struct RollingIqr *handle); + +bool wickra_rolling_iqr_is_ready(struct RollingIqr *handle); + void wickra_rolling_iqr_reset(struct RollingIqr *handle); void wickra_rolling_iqr_free(struct RollingIqr *handle); @@ -2957,6 +3369,10 @@ void wickra_rolling_min_max_scaler_batch(struct RollingMinMaxScaler *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_min_max_scaler_warmup_period(struct RollingMinMaxScaler *handle); + +bool wickra_rolling_min_max_scaler_is_ready(struct RollingMinMaxScaler *handle); + void wickra_rolling_min_max_scaler_reset(struct RollingMinMaxScaler *handle); void wickra_rolling_min_max_scaler_free(struct RollingMinMaxScaler *handle); @@ -2970,6 +3386,10 @@ void wickra_rolling_percentile_rank_batch(struct RollingPercentileRank *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_percentile_rank_warmup_period(struct RollingPercentileRank *handle); + +bool wickra_rolling_percentile_rank_is_ready(struct RollingPercentileRank *handle); + void wickra_rolling_percentile_rank_reset(struct RollingPercentileRank *handle); void wickra_rolling_percentile_rank_free(struct RollingPercentileRank *handle); @@ -2983,6 +3403,10 @@ void wickra_rolling_quantile_batch(struct RollingQuantile *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_quantile_warmup_period(struct RollingQuantile *handle); + +bool wickra_rolling_quantile_is_ready(struct RollingQuantile *handle); + void wickra_rolling_quantile_reset(struct RollingQuantile *handle); void wickra_rolling_quantile_free(struct RollingQuantile *handle); @@ -2996,6 +3420,10 @@ void wickra_roofing_filter_batch(struct RoofingFilter *handle, double *out, uintptr_t n); +uintptr_t wickra_roofing_filter_warmup_period(struct RoofingFilter *handle); + +bool wickra_roofing_filter_is_ready(struct RoofingFilter *handle); + void wickra_roofing_filter_reset(struct RoofingFilter *handle); void wickra_roofing_filter_free(struct RoofingFilter *handle); @@ -3006,6 +3434,10 @@ double wickra_rsi_update(struct Rsi *handle, double value); void wickra_rsi_batch(struct Rsi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rsi_warmup_period(struct Rsi *handle); + +bool wickra_rsi_is_ready(struct Rsi *handle); + void wickra_rsi_reset(struct Rsi *handle); void wickra_rsi_free(struct Rsi *handle); @@ -3016,6 +3448,10 @@ double wickra_rsx_update(struct Rsx *handle, double value); void wickra_rsx_batch(struct Rsx *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rsx_warmup_period(struct Rsx *handle); + +bool wickra_rsx_is_ready(struct Rsx *handle); + void wickra_rsx_reset(struct Rsx *handle); void wickra_rsx_free(struct Rsx *handle); @@ -3029,6 +3465,10 @@ void wickra_rvi_volatility_batch(struct RviVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_rvi_volatility_warmup_period(struct RviVolatility *handle); + +bool wickra_rvi_volatility_is_ready(struct RviVolatility *handle); + void wickra_rvi_volatility_reset(struct RviVolatility *handle); void wickra_rvi_volatility_free(struct RviVolatility *handle); @@ -3042,6 +3482,10 @@ void wickra_sample_entropy_batch(struct SampleEntropy *handle, double *out, uintptr_t n); +uintptr_t wickra_sample_entropy_warmup_period(struct SampleEntropy *handle); + +bool wickra_sample_entropy_is_ready(struct SampleEntropy *handle); + void wickra_sample_entropy_reset(struct SampleEntropy *handle); void wickra_sample_entropy_free(struct SampleEntropy *handle); @@ -3055,6 +3499,10 @@ void wickra_shannon_entropy_batch(struct ShannonEntropy *handle, double *out, uintptr_t n); +uintptr_t wickra_shannon_entropy_warmup_period(struct ShannonEntropy *handle); + +bool wickra_shannon_entropy_is_ready(struct ShannonEntropy *handle); + void wickra_shannon_entropy_reset(struct ShannonEntropy *handle); void wickra_shannon_entropy_free(struct ShannonEntropy *handle); @@ -3068,6 +3516,10 @@ void wickra_sharpe_ratio_batch(struct SharpeRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_sharpe_ratio_warmup_period(struct SharpeRatio *handle); + +bool wickra_sharpe_ratio_is_ready(struct SharpeRatio *handle); + void wickra_sharpe_ratio_reset(struct SharpeRatio *handle); void wickra_sharpe_ratio_free(struct SharpeRatio *handle); @@ -3078,6 +3530,10 @@ double wickra_sine_wave_update(struct SineWave *handle, double value); void wickra_sine_wave_batch(struct SineWave *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_sine_wave_warmup_period(struct SineWave *handle); + +bool wickra_sine_wave_is_ready(struct SineWave *handle); + void wickra_sine_wave_reset(struct SineWave *handle); void wickra_sine_wave_free(struct SineWave *handle); @@ -3091,6 +3547,10 @@ void wickra_sine_weighted_ma_batch(struct SineWeightedMa *handle, double *out, uintptr_t n); +uintptr_t wickra_sine_weighted_ma_warmup_period(struct SineWeightedMa *handle); + +bool wickra_sine_weighted_ma_is_ready(struct SineWeightedMa *handle); + void wickra_sine_weighted_ma_reset(struct SineWeightedMa *handle); void wickra_sine_weighted_ma_free(struct SineWeightedMa *handle); @@ -3101,6 +3561,10 @@ double wickra_skewness_update(struct Skewness *handle, double value); void wickra_skewness_batch(struct Skewness *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_skewness_warmup_period(struct Skewness *handle); + +bool wickra_skewness_is_ready(struct Skewness *handle); + void wickra_skewness_reset(struct Skewness *handle); void wickra_skewness_free(struct Skewness *handle); @@ -3111,6 +3575,10 @@ double wickra_sma_update(struct Sma *handle, double value); void wickra_sma_batch(struct Sma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_sma_warmup_period(struct Sma *handle); + +bool wickra_sma_is_ready(struct Sma *handle); + void wickra_sma_reset(struct Sma *handle); void wickra_sma_free(struct Sma *handle); @@ -3121,6 +3589,10 @@ double wickra_smma_update(struct Smma *handle, double value); void wickra_smma_batch(struct Smma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_smma_warmup_period(struct Smma *handle); + +bool wickra_smma_is_ready(struct Smma *handle); + void wickra_smma_reset(struct Smma *handle); void wickra_smma_free(struct Smma *handle); @@ -3134,6 +3606,10 @@ void wickra_sortino_ratio_batch(struct SortinoRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_sortino_ratio_warmup_period(struct SortinoRatio *handle); + +bool wickra_sortino_ratio_is_ready(struct SortinoRatio *handle); + void wickra_sortino_ratio_reset(struct SortinoRatio *handle); void wickra_sortino_ratio_free(struct SortinoRatio *handle); @@ -3147,6 +3623,10 @@ void wickra_standard_error_batch(struct StandardError *handle, double *out, uintptr_t n); +uintptr_t wickra_standard_error_warmup_period(struct StandardError *handle); + +bool wickra_standard_error_is_ready(struct StandardError *handle); + void wickra_standard_error_reset(struct StandardError *handle); void wickra_standard_error_free(struct StandardError *handle); @@ -3157,6 +3637,10 @@ double wickra_stc_update(struct Stc *handle, double value); void wickra_stc_batch(struct Stc *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_stc_warmup_period(struct Stc *handle); + +bool wickra_stc_is_ready(struct Stc *handle); + void wickra_stc_reset(struct Stc *handle); void wickra_stc_free(struct Stc *handle); @@ -3167,6 +3651,10 @@ double wickra_std_dev_update(struct StdDev *handle, double value); void wickra_std_dev_batch(struct StdDev *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_std_dev_warmup_period(struct StdDev *handle); + +bool wickra_std_dev_is_ready(struct StdDev *handle); + void wickra_std_dev_reset(struct StdDev *handle); void wickra_std_dev_free(struct StdDev *handle); @@ -3180,6 +3668,10 @@ void wickra_step_trailing_stop_batch(struct StepTrailingStop *handle, double *out, uintptr_t n); +uintptr_t wickra_step_trailing_stop_warmup_period(struct StepTrailingStop *handle); + +bool wickra_step_trailing_stop_is_ready(struct StepTrailingStop *handle); + void wickra_step_trailing_stop_reset(struct StepTrailingStop *handle); void wickra_step_trailing_stop_free(struct StepTrailingStop *handle); @@ -3193,6 +3685,10 @@ void wickra_sterling_ratio_batch(struct SterlingRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_sterling_ratio_warmup_period(struct SterlingRatio *handle); + +bool wickra_sterling_ratio_is_ready(struct SterlingRatio *handle); + void wickra_sterling_ratio_reset(struct SterlingRatio *handle); void wickra_sterling_ratio_free(struct SterlingRatio *handle); @@ -3203,6 +3699,10 @@ double wickra_stoch_rsi_update(struct StochRsi *handle, double value); void wickra_stoch_rsi_batch(struct StochRsi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_stoch_rsi_warmup_period(struct StochRsi *handle); + +bool wickra_stoch_rsi_is_ready(struct StochRsi *handle); + void wickra_stoch_rsi_reset(struct StochRsi *handle); void wickra_stoch_rsi_free(struct StochRsi *handle); @@ -3216,6 +3716,10 @@ void wickra_super_smoother_batch(struct SuperSmoother *handle, double *out, uintptr_t n); +uintptr_t wickra_super_smoother_warmup_period(struct SuperSmoother *handle); + +bool wickra_super_smoother_is_ready(struct SuperSmoother *handle); + void wickra_super_smoother_reset(struct SuperSmoother *handle); void wickra_super_smoother_free(struct SuperSmoother *handle); @@ -3226,6 +3730,10 @@ double wickra_t3_update(struct T3 *handle, double value); void wickra_t3_batch(struct T3 *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_t3_warmup_period(struct T3 *handle); + +bool wickra_t3_is_ready(struct T3 *handle); + void wickra_t3_reset(struct T3 *handle); void wickra_t3_free(struct T3 *handle); @@ -3239,6 +3747,10 @@ void wickra_tail_ratio_batch(struct TailRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_tail_ratio_warmup_period(struct TailRatio *handle); + +bool wickra_tail_ratio_is_ready(struct TailRatio *handle); + void wickra_tail_ratio_reset(struct TailRatio *handle); void wickra_tail_ratio_free(struct TailRatio *handle); @@ -3249,6 +3761,10 @@ double wickra_tema_update(struct Tema *handle, double value); void wickra_tema_batch(struct Tema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tema_warmup_period(struct Tema *handle); + +bool wickra_tema_is_ready(struct Tema *handle); + void wickra_tema_reset(struct Tema *handle); void wickra_tema_free(struct Tema *handle); @@ -3259,6 +3775,10 @@ double wickra_tii_update(struct Tii *handle, double value); void wickra_tii_batch(struct Tii *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tii_warmup_period(struct Tii *handle); + +bool wickra_tii_is_ready(struct Tii *handle); + void wickra_tii_reset(struct Tii *handle); void wickra_tii_free(struct Tii *handle); @@ -3272,6 +3792,10 @@ void wickra_trend_label_batch(struct TrendLabel *handle, double *out, uintptr_t n); +uintptr_t wickra_trend_label_warmup_period(struct TrendLabel *handle); + +bool wickra_trend_label_is_ready(struct TrendLabel *handle); + void wickra_trend_label_reset(struct TrendLabel *handle); void wickra_trend_label_free(struct TrendLabel *handle); @@ -3285,6 +3809,10 @@ void wickra_trend_strength_index_batch(struct TrendStrengthIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_trend_strength_index_warmup_period(struct TrendStrengthIndex *handle); + +bool wickra_trend_strength_index_is_ready(struct TrendStrengthIndex *handle); + void wickra_trend_strength_index_reset(struct TrendStrengthIndex *handle); void wickra_trend_strength_index_free(struct TrendStrengthIndex *handle); @@ -3298,6 +3826,10 @@ void wickra_trendflex_batch(struct Trendflex *handle, double *out, uintptr_t n); +uintptr_t wickra_trendflex_warmup_period(struct Trendflex *handle); + +bool wickra_trendflex_is_ready(struct Trendflex *handle); + void wickra_trendflex_reset(struct Trendflex *handle); void wickra_trendflex_free(struct Trendflex *handle); @@ -3308,6 +3840,10 @@ double wickra_trima_update(struct Trima *handle, double value); void wickra_trima_batch(struct Trima *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_trima_warmup_period(struct Trima *handle); + +bool wickra_trima_is_ready(struct Trima *handle); + void wickra_trima_reset(struct Trima *handle); void wickra_trima_free(struct Trima *handle); @@ -3318,6 +3854,10 @@ double wickra_trix_update(struct Trix *handle, double value); void wickra_trix_batch(struct Trix *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_trix_warmup_period(struct Trix *handle); + +bool wickra_trix_is_ready(struct Trix *handle); + void wickra_trix_reset(struct Trix *handle); void wickra_trix_free(struct Trix *handle); @@ -3328,6 +3868,10 @@ double wickra_tsf_update(struct Tsf *handle, double value); void wickra_tsf_batch(struct Tsf *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tsf_warmup_period(struct Tsf *handle); + +bool wickra_tsf_is_ready(struct Tsf *handle); + void wickra_tsf_reset(struct Tsf *handle); void wickra_tsf_free(struct Tsf *handle); @@ -3341,6 +3885,10 @@ void wickra_tsf_oscillator_batch(struct TsfOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_tsf_oscillator_warmup_period(struct TsfOscillator *handle); + +bool wickra_tsf_oscillator_is_ready(struct TsfOscillator *handle); + void wickra_tsf_oscillator_reset(struct TsfOscillator *handle); void wickra_tsf_oscillator_free(struct TsfOscillator *handle); @@ -3351,6 +3899,10 @@ double wickra_tsi_update(struct Tsi *handle, double value); void wickra_tsi_batch(struct Tsi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tsi_warmup_period(struct Tsi *handle); + +bool wickra_tsi_is_ready(struct Tsi *handle); + void wickra_tsi_reset(struct Tsi *handle); void wickra_tsi_free(struct Tsi *handle); @@ -3364,6 +3916,10 @@ void wickra_ulcer_index_batch(struct UlcerIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_ulcer_index_warmup_period(struct UlcerIndex *handle); + +bool wickra_ulcer_index_is_ready(struct UlcerIndex *handle); + void wickra_ulcer_index_reset(struct UlcerIndex *handle); void wickra_ulcer_index_free(struct UlcerIndex *handle); @@ -3377,6 +3933,10 @@ void wickra_universal_oscillator_batch(struct UniversalOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_universal_oscillator_warmup_period(struct UniversalOscillator *handle); + +bool wickra_universal_oscillator_is_ready(struct UniversalOscillator *handle); + void wickra_universal_oscillator_reset(struct UniversalOscillator *handle); void wickra_universal_oscillator_free(struct UniversalOscillator *handle); @@ -3390,6 +3950,10 @@ void wickra_upside_potential_ratio_batch(struct UpsidePotentialRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_upside_potential_ratio_warmup_period(struct UpsidePotentialRatio *handle); + +bool wickra_upside_potential_ratio_is_ready(struct UpsidePotentialRatio *handle); + void wickra_upside_potential_ratio_reset(struct UpsidePotentialRatio *handle); void wickra_upside_potential_ratio_free(struct UpsidePotentialRatio *handle); @@ -3403,6 +3967,10 @@ void wickra_value_at_risk_batch(struct ValueAtRisk *handle, double *out, uintptr_t n); +uintptr_t wickra_value_at_risk_warmup_period(struct ValueAtRisk *handle); + +bool wickra_value_at_risk_is_ready(struct ValueAtRisk *handle); + void wickra_value_at_risk_reset(struct ValueAtRisk *handle); void wickra_value_at_risk_free(struct ValueAtRisk *handle); @@ -3413,6 +3981,10 @@ double wickra_variance_update(struct Variance *handle, double value); void wickra_variance_batch(struct Variance *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_variance_warmup_period(struct Variance *handle); + +bool wickra_variance_is_ready(struct Variance *handle); + void wickra_variance_reset(struct Variance *handle); void wickra_variance_free(struct Variance *handle); @@ -3427,6 +3999,10 @@ void wickra_vertical_horizontal_filter_batch(struct VerticalHorizontalFilter *ha double *out, uintptr_t n); +uintptr_t wickra_vertical_horizontal_filter_warmup_period(struct VerticalHorizontalFilter *handle); + +bool wickra_vertical_horizontal_filter_is_ready(struct VerticalHorizontalFilter *handle); + void wickra_vertical_horizontal_filter_reset(struct VerticalHorizontalFilter *handle); void wickra_vertical_horizontal_filter_free(struct VerticalHorizontalFilter *handle); @@ -3437,6 +4013,10 @@ double wickra_vidya_update(struct Vidya *handle, double value); void wickra_vidya_batch(struct Vidya *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_vidya_warmup_period(struct Vidya *handle); + +bool wickra_vidya_is_ready(struct Vidya *handle); + void wickra_vidya_reset(struct Vidya *handle); void wickra_vidya_free(struct Vidya *handle); @@ -3451,6 +4031,10 @@ void wickra_volatility_of_volatility_batch(struct VolatilityOfVolatility *handle double *out, uintptr_t n); +uintptr_t wickra_volatility_of_volatility_warmup_period(struct VolatilityOfVolatility *handle); + +bool wickra_volatility_of_volatility_is_ready(struct VolatilityOfVolatility *handle); + void wickra_volatility_of_volatility_reset(struct VolatilityOfVolatility *handle); void wickra_volatility_of_volatility_free(struct VolatilityOfVolatility *handle); @@ -3461,6 +4045,10 @@ double wickra_wave_pm_update(struct WavePm *handle, double value); void wickra_wave_pm_batch(struct WavePm *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_wave_pm_warmup_period(struct WavePm *handle); + +bool wickra_wave_pm_is_ready(struct WavePm *handle); + void wickra_wave_pm_reset(struct WavePm *handle); void wickra_wave_pm_free(struct WavePm *handle); @@ -3471,6 +4059,10 @@ double wickra_win_rate_update(struct WinRate *handle, double value); void wickra_win_rate_batch(struct WinRate *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_win_rate_warmup_period(struct WinRate *handle); + +bool wickra_win_rate_is_ready(struct WinRate *handle); + void wickra_win_rate_reset(struct WinRate *handle); void wickra_win_rate_free(struct WinRate *handle); @@ -3481,6 +4073,10 @@ double wickra_wma_update(struct Wma *handle, double value); void wickra_wma_batch(struct Wma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_wma_warmup_period(struct Wma *handle); + +bool wickra_wma_is_ready(struct Wma *handle); + void wickra_wma_reset(struct Wma *handle); void wickra_wma_free(struct Wma *handle); @@ -3491,6 +4087,10 @@ double wickra_z_score_update(struct ZScore *handle, double value); void wickra_z_score_batch(struct ZScore *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_z_score_warmup_period(struct ZScore *handle); + +bool wickra_z_score_is_ready(struct ZScore *handle); + void wickra_z_score_reset(struct ZScore *handle); void wickra_z_score_free(struct ZScore *handle); @@ -3501,6 +4101,10 @@ double wickra_zlema_update(struct Zlema *handle, double value); void wickra_zlema_batch(struct Zlema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_zlema_warmup_period(struct Zlema *handle); + +bool wickra_zlema_is_ready(struct Zlema *handle); + void wickra_zlema_reset(struct Zlema *handle); void wickra_zlema_free(struct Zlema *handle); @@ -3515,6 +4119,10 @@ void wickra_alpha_batch(struct Alpha *handle, double *out, uintptr_t n); +uintptr_t wickra_alpha_warmup_period(struct Alpha *handle); + +bool wickra_alpha_is_ready(struct Alpha *handle); + void wickra_alpha_reset(struct Alpha *handle); void wickra_alpha_free(struct Alpha *handle); @@ -3529,6 +4137,10 @@ void wickra_beta_batch(struct Beta *handle, double *out, uintptr_t n); +uintptr_t wickra_beta_warmup_period(struct Beta *handle); + +bool wickra_beta_is_ready(struct Beta *handle); + void wickra_beta_reset(struct Beta *handle); void wickra_beta_free(struct Beta *handle); @@ -3543,6 +4155,10 @@ void wickra_beta_neutral_spread_batch(struct BetaNeutralSpread *handle, double *out, uintptr_t n); +uintptr_t wickra_beta_neutral_spread_warmup_period(struct BetaNeutralSpread *handle); + +bool wickra_beta_neutral_spread_is_ready(struct BetaNeutralSpread *handle); + void wickra_beta_neutral_spread_reset(struct BetaNeutralSpread *handle); void wickra_beta_neutral_spread_free(struct BetaNeutralSpread *handle); @@ -3557,6 +4173,10 @@ void wickra_distance_ssd_batch(struct DistanceSsd *handle, double *out, uintptr_t n); +uintptr_t wickra_distance_ssd_warmup_period(struct DistanceSsd *handle); + +bool wickra_distance_ssd_is_ready(struct DistanceSsd *handle); + void wickra_distance_ssd_reset(struct DistanceSsd *handle); void wickra_distance_ssd_free(struct DistanceSsd *handle); @@ -3571,6 +4191,10 @@ void wickra_granger_causality_batch(struct GrangerCausality *handle, double *out, uintptr_t n); +uintptr_t wickra_granger_causality_warmup_period(struct GrangerCausality *handle); + +bool wickra_granger_causality_is_ready(struct GrangerCausality *handle); + void wickra_granger_causality_reset(struct GrangerCausality *handle); void wickra_granger_causality_free(struct GrangerCausality *handle); @@ -3587,6 +4211,10 @@ void wickra_hasbrouck_information_share_batch(struct HasbrouckInformationShare * double *out, uintptr_t n); +uintptr_t wickra_hasbrouck_information_share_warmup_period(struct HasbrouckInformationShare *handle); + +bool wickra_hasbrouck_information_share_is_ready(struct HasbrouckInformationShare *handle); + void wickra_hasbrouck_information_share_reset(struct HasbrouckInformationShare *handle); void wickra_hasbrouck_information_share_free(struct HasbrouckInformationShare *handle); @@ -3601,6 +4229,10 @@ void wickra_information_ratio_batch(struct InformationRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_information_ratio_warmup_period(struct InformationRatio *handle); + +bool wickra_information_ratio_is_ready(struct InformationRatio *handle); + void wickra_information_ratio_reset(struct InformationRatio *handle); void wickra_information_ratio_free(struct InformationRatio *handle); @@ -3615,6 +4247,10 @@ void wickra_kendall_tau_batch(struct KendallTau *handle, double *out, uintptr_t n); +uintptr_t wickra_kendall_tau_warmup_period(struct KendallTau *handle); + +bool wickra_kendall_tau_is_ready(struct KendallTau *handle); + void wickra_kendall_tau_reset(struct KendallTau *handle); void wickra_kendall_tau_free(struct KendallTau *handle); @@ -3629,6 +4265,10 @@ void wickra_ou_half_life_batch(struct OuHalfLife *handle, double *out, uintptr_t n); +uintptr_t wickra_ou_half_life_warmup_period(struct OuHalfLife *handle); + +bool wickra_ou_half_life_is_ready(struct OuHalfLife *handle); + void wickra_ou_half_life_reset(struct OuHalfLife *handle); void wickra_ou_half_life_free(struct OuHalfLife *handle); @@ -3643,6 +4283,10 @@ void wickra_pair_spread_z_score_batch(struct PairSpreadZScore *handle, double *out, uintptr_t n); +uintptr_t wickra_pair_spread_z_score_warmup_period(struct PairSpreadZScore *handle); + +bool wickra_pair_spread_z_score_is_ready(struct PairSpreadZScore *handle); + void wickra_pair_spread_z_score_reset(struct PairSpreadZScore *handle); void wickra_pair_spread_z_score_free(struct PairSpreadZScore *handle); @@ -3657,6 +4301,10 @@ void wickra_pairwise_beta_batch(struct PairwiseBeta *handle, double *out, uintptr_t n); +uintptr_t wickra_pairwise_beta_warmup_period(struct PairwiseBeta *handle); + +bool wickra_pairwise_beta_is_ready(struct PairwiseBeta *handle); + void wickra_pairwise_beta_reset(struct PairwiseBeta *handle); void wickra_pairwise_beta_free(struct PairwiseBeta *handle); @@ -3671,6 +4319,10 @@ void wickra_pearson_correlation_batch(struct PearsonCorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_pearson_correlation_warmup_period(struct PearsonCorrelation *handle); + +bool wickra_pearson_correlation_is_ready(struct PearsonCorrelation *handle); + void wickra_pearson_correlation_reset(struct PearsonCorrelation *handle); void wickra_pearson_correlation_free(struct PearsonCorrelation *handle); @@ -3685,6 +4337,10 @@ void wickra_rolling_correlation_batch(struct RollingCorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_correlation_warmup_period(struct RollingCorrelation *handle); + +bool wickra_rolling_correlation_is_ready(struct RollingCorrelation *handle); + void wickra_rolling_correlation_reset(struct RollingCorrelation *handle); void wickra_rolling_correlation_free(struct RollingCorrelation *handle); @@ -3699,6 +4355,10 @@ void wickra_rolling_covariance_batch(struct RollingCovariance *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_covariance_warmup_period(struct RollingCovariance *handle); + +bool wickra_rolling_covariance_is_ready(struct RollingCovariance *handle); + void wickra_rolling_covariance_reset(struct RollingCovariance *handle); void wickra_rolling_covariance_free(struct RollingCovariance *handle); @@ -3713,6 +4373,10 @@ void wickra_spearman_correlation_batch(struct SpearmanCorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_spearman_correlation_warmup_period(struct SpearmanCorrelation *handle); + +bool wickra_spearman_correlation_is_ready(struct SpearmanCorrelation *handle); + void wickra_spearman_correlation_reset(struct SpearmanCorrelation *handle); void wickra_spearman_correlation_free(struct SpearmanCorrelation *handle); @@ -3729,6 +4393,10 @@ void wickra_spread_ar1_coefficient_batch(struct SpreadAr1Coefficient *handle, double *out, uintptr_t n); +uintptr_t wickra_spread_ar1_coefficient_warmup_period(struct SpreadAr1Coefficient *handle); + +bool wickra_spread_ar1_coefficient_is_ready(struct SpreadAr1Coefficient *handle); + void wickra_spread_ar1_coefficient_reset(struct SpreadAr1Coefficient *handle); void wickra_spread_ar1_coefficient_free(struct SpreadAr1Coefficient *handle); @@ -3743,6 +4411,10 @@ void wickra_spread_hurst_batch(struct SpreadHurst *handle, double *out, uintptr_t n); +uintptr_t wickra_spread_hurst_warmup_period(struct SpreadHurst *handle); + +bool wickra_spread_hurst_is_ready(struct SpreadHurst *handle); + void wickra_spread_hurst_reset(struct SpreadHurst *handle); void wickra_spread_hurst_free(struct SpreadHurst *handle); @@ -3757,6 +4429,10 @@ void wickra_treynor_ratio_batch(struct TreynorRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_treynor_ratio_warmup_period(struct TreynorRatio *handle); + +bool wickra_treynor_ratio_is_ready(struct TreynorRatio *handle); + void wickra_treynor_ratio_reset(struct TreynorRatio *handle); void wickra_treynor_ratio_free(struct TreynorRatio *handle); @@ -3771,6 +4447,10 @@ void wickra_variance_ratio_batch(struct VarianceRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_variance_ratio_warmup_period(struct VarianceRatio *handle); + +bool wickra_variance_ratio_is_ready(struct VarianceRatio *handle); + void wickra_variance_ratio_reset(struct VarianceRatio *handle); void wickra_variance_ratio_free(struct VarianceRatio *handle); @@ -3795,6 +4475,10 @@ void wickra_abandoned_baby_batch(struct AbandonedBaby *handle, double *out, uintptr_t n); +uintptr_t wickra_abandoned_baby_warmup_period(struct AbandonedBaby *handle); + +bool wickra_abandoned_baby_is_ready(struct AbandonedBaby *handle); + void wickra_abandoned_baby_reset(struct AbandonedBaby *handle); void wickra_abandoned_baby_free(struct AbandonedBaby *handle); @@ -3819,6 +4503,10 @@ void wickra_abcd_batch(struct Abcd *handle, double *out, uintptr_t n); +uintptr_t wickra_abcd_warmup_period(struct Abcd *handle); + +bool wickra_abcd_is_ready(struct Abcd *handle); + void wickra_abcd_reset(struct Abcd *handle); void wickra_abcd_free(struct Abcd *handle); @@ -3845,6 +4533,10 @@ void wickra_accelerator_oscillator_batch(struct AcceleratorOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_accelerator_oscillator_warmup_period(struct AcceleratorOscillator *handle); + +bool wickra_accelerator_oscillator_is_ready(struct AcceleratorOscillator *handle); + void wickra_accelerator_oscillator_reset(struct AcceleratorOscillator *handle); void wickra_accelerator_oscillator_free(struct AcceleratorOscillator *handle); @@ -3869,6 +4561,10 @@ void wickra_ad_oscillator_batch(struct AdOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_ad_oscillator_warmup_period(struct AdOscillator *handle); + +bool wickra_ad_oscillator_is_ready(struct AdOscillator *handle); + void wickra_ad_oscillator_reset(struct AdOscillator *handle); void wickra_ad_oscillator_free(struct AdOscillator *handle); @@ -3893,6 +4589,10 @@ void wickra_adaptive_cci_batch(struct AdaptiveCci *handle, double *out, uintptr_t n); +uintptr_t wickra_adaptive_cci_warmup_period(struct AdaptiveCci *handle); + +bool wickra_adaptive_cci_is_ready(struct AdaptiveCci *handle); + void wickra_adaptive_cci_reset(struct AdaptiveCci *handle); void wickra_adaptive_cci_free(struct AdaptiveCci *handle); @@ -3917,6 +4617,10 @@ void wickra_adl_batch(struct Adl *handle, double *out, uintptr_t n); +uintptr_t wickra_adl_warmup_period(struct Adl *handle); + +bool wickra_adl_is_ready(struct Adl *handle); + void wickra_adl_reset(struct Adl *handle); void wickra_adl_free(struct Adl *handle); @@ -3941,6 +4645,10 @@ void wickra_advance_block_batch(struct AdvanceBlock *handle, double *out, uintptr_t n); +uintptr_t wickra_advance_block_warmup_period(struct AdvanceBlock *handle); + +bool wickra_advance_block_is_ready(struct AdvanceBlock *handle); + void wickra_advance_block_reset(struct AdvanceBlock *handle); void wickra_advance_block_free(struct AdvanceBlock *handle); @@ -3965,6 +4673,10 @@ void wickra_adxr_batch(struct Adxr *handle, double *out, uintptr_t n); +uintptr_t wickra_adxr_warmup_period(struct Adxr *handle); + +bool wickra_adxr_is_ready(struct Adxr *handle); + void wickra_adxr_reset(struct Adxr *handle); void wickra_adxr_free(struct Adxr *handle); @@ -3989,6 +4701,10 @@ void wickra_anchored_vwap_batch(struct AnchoredVwap *handle, double *out, uintptr_t n); +uintptr_t wickra_anchored_vwap_warmup_period(struct AnchoredVwap *handle); + +bool wickra_anchored_vwap_is_ready(struct AnchoredVwap *handle); + void wickra_anchored_vwap_reset(struct AnchoredVwap *handle); void wickra_anchored_vwap_free(struct AnchoredVwap *handle); @@ -4013,6 +4729,10 @@ void wickra_aroon_oscillator_batch(struct AroonOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_aroon_oscillator_warmup_period(struct AroonOscillator *handle); + +bool wickra_aroon_oscillator_is_ready(struct AroonOscillator *handle); + void wickra_aroon_oscillator_reset(struct AroonOscillator *handle); void wickra_aroon_oscillator_free(struct AroonOscillator *handle); @@ -4037,6 +4757,10 @@ void wickra_atr_batch(struct Atr *handle, double *out, uintptr_t n); +uintptr_t wickra_atr_warmup_period(struct Atr *handle); + +bool wickra_atr_is_ready(struct Atr *handle); + void wickra_atr_reset(struct Atr *handle); void wickra_atr_free(struct Atr *handle); @@ -4061,6 +4785,10 @@ void wickra_atr_trailing_stop_batch(struct AtrTrailingStop *handle, double *out, uintptr_t n); +uintptr_t wickra_atr_trailing_stop_warmup_period(struct AtrTrailingStop *handle); + +bool wickra_atr_trailing_stop_is_ready(struct AtrTrailingStop *handle); + void wickra_atr_trailing_stop_reset(struct AtrTrailingStop *handle); void wickra_atr_trailing_stop_free(struct AtrTrailingStop *handle); @@ -4086,6 +4814,10 @@ void wickra_average_daily_range_batch(struct AverageDailyRange *handle, double *out, uintptr_t n); +uintptr_t wickra_average_daily_range_warmup_period(struct AverageDailyRange *handle); + +bool wickra_average_daily_range_is_ready(struct AverageDailyRange *handle); + void wickra_average_daily_range_reset(struct AverageDailyRange *handle); void wickra_average_daily_range_free(struct AverageDailyRange *handle); @@ -4110,6 +4842,10 @@ void wickra_avg_price_batch(struct AvgPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_avg_price_warmup_period(struct AvgPrice *handle); + +bool wickra_avg_price_is_ready(struct AvgPrice *handle); + void wickra_avg_price_reset(struct AvgPrice *handle); void wickra_avg_price_free(struct AvgPrice *handle); @@ -4134,6 +4870,10 @@ void wickra_awesome_oscillator_batch(struct AwesomeOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_awesome_oscillator_warmup_period(struct AwesomeOscillator *handle); + +bool wickra_awesome_oscillator_is_ready(struct AwesomeOscillator *handle); + void wickra_awesome_oscillator_reset(struct AwesomeOscillator *handle); void wickra_awesome_oscillator_free(struct AwesomeOscillator *handle); @@ -4160,6 +4900,10 @@ void wickra_awesome_oscillator_histogram_batch(struct AwesomeOscillatorHistogram double *out, uintptr_t n); +uintptr_t wickra_awesome_oscillator_histogram_warmup_period(struct AwesomeOscillatorHistogram *handle); + +bool wickra_awesome_oscillator_histogram_is_ready(struct AwesomeOscillatorHistogram *handle); + void wickra_awesome_oscillator_histogram_reset(struct AwesomeOscillatorHistogram *handle); void wickra_awesome_oscillator_histogram_free(struct AwesomeOscillatorHistogram *handle); @@ -4184,6 +4928,10 @@ void wickra_balance_of_power_batch(struct BalanceOfPower *handle, double *out, uintptr_t n); +uintptr_t wickra_balance_of_power_warmup_period(struct BalanceOfPower *handle); + +bool wickra_balance_of_power_is_ready(struct BalanceOfPower *handle); + void wickra_balance_of_power_reset(struct BalanceOfPower *handle); void wickra_balance_of_power_free(struct BalanceOfPower *handle); @@ -4208,6 +4956,10 @@ void wickra_bat_batch(struct Bat *handle, double *out, uintptr_t n); +uintptr_t wickra_bat_warmup_period(struct Bat *handle); + +bool wickra_bat_is_ready(struct Bat *handle); + void wickra_bat_reset(struct Bat *handle); void wickra_bat_free(struct Bat *handle); @@ -4232,6 +4984,10 @@ void wickra_belt_hold_batch(struct BeltHold *handle, double *out, uintptr_t n); +uintptr_t wickra_belt_hold_warmup_period(struct BeltHold *handle); + +bool wickra_belt_hold_is_ready(struct BeltHold *handle); + void wickra_belt_hold_reset(struct BeltHold *handle); void wickra_belt_hold_free(struct BeltHold *handle); @@ -4256,6 +5012,10 @@ void wickra_better_volume_batch(struct BetterVolume *handle, double *out, uintptr_t n); +uintptr_t wickra_better_volume_warmup_period(struct BetterVolume *handle); + +bool wickra_better_volume_is_ready(struct BetterVolume *handle); + void wickra_better_volume_reset(struct BetterVolume *handle); void wickra_better_volume_free(struct BetterVolume *handle); @@ -4280,6 +5040,10 @@ void wickra_body_size_pct_batch(struct BodySizePct *handle, double *out, uintptr_t n); +uintptr_t wickra_body_size_pct_warmup_period(struct BodySizePct *handle); + +bool wickra_body_size_pct_is_ready(struct BodySizePct *handle); + void wickra_body_size_pct_reset(struct BodySizePct *handle); void wickra_body_size_pct_free(struct BodySizePct *handle); @@ -4304,6 +5068,10 @@ void wickra_breakaway_batch(struct Breakaway *handle, double *out, uintptr_t n); +uintptr_t wickra_breakaway_warmup_period(struct Breakaway *handle); + +bool wickra_breakaway_is_ready(struct Breakaway *handle); + void wickra_breakaway_reset(struct Breakaway *handle); void wickra_breakaway_free(struct Breakaway *handle); @@ -4328,6 +5096,10 @@ void wickra_butterfly_batch(struct Butterfly *handle, double *out, uintptr_t n); +uintptr_t wickra_butterfly_warmup_period(struct Butterfly *handle); + +bool wickra_butterfly_is_ready(struct Butterfly *handle); + void wickra_butterfly_reset(struct Butterfly *handle); void wickra_butterfly_free(struct Butterfly *handle); @@ -4352,6 +5124,10 @@ void wickra_cci_batch(struct Cci *handle, double *out, uintptr_t n); +uintptr_t wickra_cci_warmup_period(struct Cci *handle); + +bool wickra_cci_is_ready(struct Cci *handle); + void wickra_cci_reset(struct Cci *handle); void wickra_cci_free(struct Cci *handle); @@ -4376,6 +5152,10 @@ void wickra_chaikin_oscillator_batch(struct ChaikinOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_chaikin_oscillator_warmup_period(struct ChaikinOscillator *handle); + +bool wickra_chaikin_oscillator_is_ready(struct ChaikinOscillator *handle); + void wickra_chaikin_oscillator_reset(struct ChaikinOscillator *handle); void wickra_chaikin_oscillator_free(struct ChaikinOscillator *handle); @@ -4400,6 +5180,10 @@ void wickra_chaikin_volatility_batch(struct ChaikinVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_chaikin_volatility_warmup_period(struct ChaikinVolatility *handle); + +bool wickra_chaikin_volatility_is_ready(struct ChaikinVolatility *handle); + void wickra_chaikin_volatility_reset(struct ChaikinVolatility *handle); void wickra_chaikin_volatility_free(struct ChaikinVolatility *handle); @@ -4424,6 +5208,10 @@ void wickra_choppiness_index_batch(struct ChoppinessIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_choppiness_index_warmup_period(struct ChoppinessIndex *handle); + +bool wickra_choppiness_index_is_ready(struct ChoppinessIndex *handle); + void wickra_choppiness_index_reset(struct ChoppinessIndex *handle); void wickra_choppiness_index_free(struct ChoppinessIndex *handle); @@ -4448,6 +5236,10 @@ void wickra_close_vs_open_batch(struct CloseVsOpen *handle, double *out, uintptr_t n); +uintptr_t wickra_close_vs_open_warmup_period(struct CloseVsOpen *handle); + +bool wickra_close_vs_open_is_ready(struct CloseVsOpen *handle); + void wickra_close_vs_open_reset(struct CloseVsOpen *handle); void wickra_close_vs_open_free(struct CloseVsOpen *handle); @@ -4472,6 +5264,10 @@ void wickra_closing_marubozu_batch(struct ClosingMarubozu *handle, double *out, uintptr_t n); +uintptr_t wickra_closing_marubozu_warmup_period(struct ClosingMarubozu *handle); + +bool wickra_closing_marubozu_is_ready(struct ClosingMarubozu *handle); + void wickra_closing_marubozu_reset(struct ClosingMarubozu *handle); void wickra_closing_marubozu_free(struct ClosingMarubozu *handle); @@ -4496,6 +5292,10 @@ void wickra_chaikin_money_flow_batch(struct ChaikinMoneyFlow *handle, double *out, uintptr_t n); +uintptr_t wickra_chaikin_money_flow_warmup_period(struct ChaikinMoneyFlow *handle); + +bool wickra_chaikin_money_flow_is_ready(struct ChaikinMoneyFlow *handle); + void wickra_chaikin_money_flow_reset(struct ChaikinMoneyFlow *handle); void wickra_chaikin_money_flow_free(struct ChaikinMoneyFlow *handle); @@ -4520,6 +5320,10 @@ void wickra_concealing_baby_swallow_batch(struct ConcealingBabySwallow *handle, double *out, uintptr_t n); +uintptr_t wickra_concealing_baby_swallow_warmup_period(struct ConcealingBabySwallow *handle); + +bool wickra_concealing_baby_swallow_is_ready(struct ConcealingBabySwallow *handle); + void wickra_concealing_baby_swallow_reset(struct ConcealingBabySwallow *handle); void wickra_concealing_baby_swallow_free(struct ConcealingBabySwallow *handle); @@ -4544,6 +5348,10 @@ void wickra_counterattack_batch(struct Counterattack *handle, double *out, uintptr_t n); +uintptr_t wickra_counterattack_warmup_period(struct Counterattack *handle); + +bool wickra_counterattack_is_ready(struct Counterattack *handle); + void wickra_counterattack_reset(struct Counterattack *handle); void wickra_counterattack_free(struct Counterattack *handle); @@ -4568,6 +5376,10 @@ void wickra_crab_batch(struct Crab *handle, double *out, uintptr_t n); +uintptr_t wickra_crab_warmup_period(struct Crab *handle); + +bool wickra_crab_is_ready(struct Crab *handle); + void wickra_crab_reset(struct Crab *handle); void wickra_crab_free(struct Crab *handle); @@ -4592,6 +5404,10 @@ void wickra_cup_and_handle_batch(struct CupAndHandle *handle, double *out, uintptr_t n); +uintptr_t wickra_cup_and_handle_warmup_period(struct CupAndHandle *handle); + +bool wickra_cup_and_handle_is_ready(struct CupAndHandle *handle); + void wickra_cup_and_handle_reset(struct CupAndHandle *handle); void wickra_cup_and_handle_free(struct CupAndHandle *handle); @@ -4616,6 +5432,10 @@ void wickra_cypher_batch(struct Cypher *handle, double *out, uintptr_t n); +uintptr_t wickra_cypher_warmup_period(struct Cypher *handle); + +bool wickra_cypher_is_ready(struct Cypher *handle); + void wickra_cypher_reset(struct Cypher *handle); void wickra_cypher_free(struct Cypher *handle); @@ -4640,6 +5460,10 @@ void wickra_demand_index_batch(struct DemandIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_demand_index_warmup_period(struct DemandIndex *handle); + +bool wickra_demand_index_is_ready(struct DemandIndex *handle); + void wickra_demand_index_reset(struct DemandIndex *handle); void wickra_demand_index_free(struct DemandIndex *handle); @@ -4664,6 +5488,10 @@ void wickra_doji_batch(struct Doji *handle, double *out, uintptr_t n); +uintptr_t wickra_doji_warmup_period(struct Doji *handle); + +bool wickra_doji_is_ready(struct Doji *handle); + void wickra_doji_reset(struct Doji *handle); void wickra_doji_free(struct Doji *handle); @@ -4688,6 +5516,10 @@ void wickra_doji_star_batch(struct DojiStar *handle, double *out, uintptr_t n); +uintptr_t wickra_doji_star_warmup_period(struct DojiStar *handle); + +bool wickra_doji_star_is_ready(struct DojiStar *handle); + void wickra_doji_star_reset(struct DojiStar *handle); void wickra_doji_star_free(struct DojiStar *handle); @@ -4712,6 +5544,10 @@ void wickra_double_top_bottom_batch(struct DoubleTopBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_double_top_bottom_warmup_period(struct DoubleTopBottom *handle); + +bool wickra_double_top_bottom_is_ready(struct DoubleTopBottom *handle); + void wickra_double_top_bottom_reset(struct DoubleTopBottom *handle); void wickra_double_top_bottom_free(struct DoubleTopBottom *handle); @@ -4736,6 +5572,10 @@ void wickra_downside_gap_three_methods_batch(struct DownsideGapThreeMethods *han double *out, uintptr_t n); +uintptr_t wickra_downside_gap_three_methods_warmup_period(struct DownsideGapThreeMethods *handle); + +bool wickra_downside_gap_three_methods_is_ready(struct DownsideGapThreeMethods *handle); + void wickra_downside_gap_three_methods_reset(struct DownsideGapThreeMethods *handle); void wickra_downside_gap_three_methods_free(struct DownsideGapThreeMethods *handle); @@ -4760,6 +5600,10 @@ void wickra_dragonfly_doji_batch(struct DragonflyDoji *handle, double *out, uintptr_t n); +uintptr_t wickra_dragonfly_doji_warmup_period(struct DragonflyDoji *handle); + +bool wickra_dragonfly_doji_is_ready(struct DragonflyDoji *handle); + void wickra_dragonfly_doji_reset(struct DragonflyDoji *handle); void wickra_dragonfly_doji_free(struct DragonflyDoji *handle); @@ -4784,6 +5628,10 @@ void wickra_dumpling_top_batch(struct DumplingTop *handle, double *out, uintptr_t n); +uintptr_t wickra_dumpling_top_warmup_period(struct DumplingTop *handle); + +bool wickra_dumpling_top_is_ready(struct DumplingTop *handle); + void wickra_dumpling_top_reset(struct DumplingTop *handle); void wickra_dumpling_top_free(struct DumplingTop *handle); @@ -4808,6 +5656,10 @@ void wickra_dx_batch(struct Dx *handle, double *out, uintptr_t n); +uintptr_t wickra_dx_warmup_period(struct Dx *handle); + +bool wickra_dx_is_ready(struct Dx *handle); + void wickra_dx_reset(struct Dx *handle); void wickra_dx_free(struct Dx *handle); @@ -4832,6 +5684,10 @@ void wickra_ease_of_movement_batch(struct EaseOfMovement *handle, double *out, uintptr_t n); +uintptr_t wickra_ease_of_movement_warmup_period(struct EaseOfMovement *handle); + +bool wickra_ease_of_movement_is_ready(struct EaseOfMovement *handle); + void wickra_ease_of_movement_reset(struct EaseOfMovement *handle); void wickra_ease_of_movement_free(struct EaseOfMovement *handle); @@ -4856,6 +5712,10 @@ void wickra_engulfing_batch(struct Engulfing *handle, double *out, uintptr_t n); +uintptr_t wickra_engulfing_warmup_period(struct Engulfing *handle); + +bool wickra_engulfing_is_ready(struct Engulfing *handle); + void wickra_engulfing_reset(struct Engulfing *handle); void wickra_engulfing_free(struct Engulfing *handle); @@ -4880,6 +5740,10 @@ void wickra_evening_doji_star_batch(struct EveningDojiStar *handle, double *out, uintptr_t n); +uintptr_t wickra_evening_doji_star_warmup_period(struct EveningDojiStar *handle); + +bool wickra_evening_doji_star_is_ready(struct EveningDojiStar *handle); + void wickra_evening_doji_star_reset(struct EveningDojiStar *handle); void wickra_evening_doji_star_free(struct EveningDojiStar *handle); @@ -4904,6 +5768,10 @@ void wickra_evwma_batch(struct Evwma *handle, double *out, uintptr_t n); +uintptr_t wickra_evwma_warmup_period(struct Evwma *handle); + +bool wickra_evwma_is_ready(struct Evwma *handle); + void wickra_evwma_reset(struct Evwma *handle); void wickra_evwma_free(struct Evwma *handle); @@ -4928,6 +5796,10 @@ void wickra_falling_three_methods_batch(struct FallingThreeMethods *handle, double *out, uintptr_t n); +uintptr_t wickra_falling_three_methods_warmup_period(struct FallingThreeMethods *handle); + +bool wickra_falling_three_methods_is_ready(struct FallingThreeMethods *handle); + void wickra_falling_three_methods_reset(struct FallingThreeMethods *handle); void wickra_falling_three_methods_free(struct FallingThreeMethods *handle); @@ -4952,6 +5824,10 @@ void wickra_flag_pennant_batch(struct FlagPennant *handle, double *out, uintptr_t n); +uintptr_t wickra_flag_pennant_warmup_period(struct FlagPennant *handle); + +bool wickra_flag_pennant_is_ready(struct FlagPennant *handle); + void wickra_flag_pennant_reset(struct FlagPennant *handle); void wickra_flag_pennant_free(struct FlagPennant *handle); @@ -4976,6 +5852,10 @@ void wickra_force_index_batch(struct ForceIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_force_index_warmup_period(struct ForceIndex *handle); + +bool wickra_force_index_is_ready(struct ForceIndex *handle); + void wickra_force_index_reset(struct ForceIndex *handle); void wickra_force_index_free(struct ForceIndex *handle); @@ -5000,6 +5880,10 @@ void wickra_fry_pan_bottom_batch(struct FryPanBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_fry_pan_bottom_warmup_period(struct FryPanBottom *handle); + +bool wickra_fry_pan_bottom_is_ready(struct FryPanBottom *handle); + void wickra_fry_pan_bottom_reset(struct FryPanBottom *handle); void wickra_fry_pan_bottom_free(struct FryPanBottom *handle); @@ -5024,6 +5908,10 @@ void wickra_gap_side_by_side_white_batch(struct GapSideBySideWhite *handle, double *out, uintptr_t n); +uintptr_t wickra_gap_side_by_side_white_warmup_period(struct GapSideBySideWhite *handle); + +bool wickra_gap_side_by_side_white_is_ready(struct GapSideBySideWhite *handle); + void wickra_gap_side_by_side_white_reset(struct GapSideBySideWhite *handle); void wickra_gap_side_by_side_white_free(struct GapSideBySideWhite *handle); @@ -5049,6 +5937,10 @@ void wickra_garman_klass_volatility_batch(struct GarmanKlassVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_garman_klass_volatility_warmup_period(struct GarmanKlassVolatility *handle); + +bool wickra_garman_klass_volatility_is_ready(struct GarmanKlassVolatility *handle); + void wickra_garman_klass_volatility_reset(struct GarmanKlassVolatility *handle); void wickra_garman_klass_volatility_free(struct GarmanKlassVolatility *handle); @@ -5073,6 +5965,10 @@ void wickra_gartley_batch(struct Gartley *handle, double *out, uintptr_t n); +uintptr_t wickra_gartley_warmup_period(struct Gartley *handle); + +bool wickra_gartley_is_ready(struct Gartley *handle); + void wickra_gartley_reset(struct Gartley *handle); void wickra_gartley_free(struct Gartley *handle); @@ -5097,6 +5993,10 @@ void wickra_gravestone_doji_batch(struct GravestoneDoji *handle, double *out, uintptr_t n); +uintptr_t wickra_gravestone_doji_warmup_period(struct GravestoneDoji *handle); + +bool wickra_gravestone_doji_is_ready(struct GravestoneDoji *handle); + void wickra_gravestone_doji_reset(struct GravestoneDoji *handle); void wickra_gravestone_doji_free(struct GravestoneDoji *handle); @@ -5121,6 +6021,10 @@ void wickra_hammer_batch(struct Hammer *handle, double *out, uintptr_t n); +uintptr_t wickra_hammer_warmup_period(struct Hammer *handle); + +bool wickra_hammer_is_ready(struct Hammer *handle); + void wickra_hammer_reset(struct Hammer *handle); void wickra_hammer_free(struct Hammer *handle); @@ -5145,6 +6049,10 @@ void wickra_hanging_man_batch(struct HangingMan *handle, double *out, uintptr_t n); +uintptr_t wickra_hanging_man_warmup_period(struct HangingMan *handle); + +bool wickra_hanging_man_is_ready(struct HangingMan *handle); + void wickra_hanging_man_reset(struct HangingMan *handle); void wickra_hanging_man_free(struct HangingMan *handle); @@ -5169,6 +6077,10 @@ void wickra_harami_batch(struct Harami *handle, double *out, uintptr_t n); +uintptr_t wickra_harami_warmup_period(struct Harami *handle); + +bool wickra_harami_is_ready(struct Harami *handle); + void wickra_harami_reset(struct Harami *handle); void wickra_harami_free(struct Harami *handle); @@ -5193,6 +6105,10 @@ void wickra_harami_cross_batch(struct HaramiCross *handle, double *out, uintptr_t n); +uintptr_t wickra_harami_cross_warmup_period(struct HaramiCross *handle); + +bool wickra_harami_cross_is_ready(struct HaramiCross *handle); + void wickra_harami_cross_reset(struct HaramiCross *handle); void wickra_harami_cross_free(struct HaramiCross *handle); @@ -5217,6 +6133,10 @@ void wickra_head_and_shoulders_batch(struct HeadAndShoulders *handle, double *out, uintptr_t n); +uintptr_t wickra_head_and_shoulders_warmup_period(struct HeadAndShoulders *handle); + +bool wickra_head_and_shoulders_is_ready(struct HeadAndShoulders *handle); + void wickra_head_and_shoulders_reset(struct HeadAndShoulders *handle); void wickra_head_and_shoulders_free(struct HeadAndShoulders *handle); @@ -5241,6 +6161,10 @@ void wickra_heikin_ashi_oscillator_batch(struct HeikinAshiOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_heikin_ashi_oscillator_warmup_period(struct HeikinAshiOscillator *handle); + +bool wickra_heikin_ashi_oscillator_is_ready(struct HeikinAshiOscillator *handle); + void wickra_heikin_ashi_oscillator_reset(struct HeikinAshiOscillator *handle); void wickra_heikin_ashi_oscillator_free(struct HeikinAshiOscillator *handle); @@ -5265,6 +6189,10 @@ void wickra_high_low_range_batch(struct HighLowRange *handle, double *out, uintptr_t n); +uintptr_t wickra_high_low_range_warmup_period(struct HighLowRange *handle); + +bool wickra_high_low_range_is_ready(struct HighLowRange *handle); + void wickra_high_low_range_reset(struct HighLowRange *handle); void wickra_high_low_range_free(struct HighLowRange *handle); @@ -5289,6 +6217,10 @@ void wickra_high_wave_batch(struct HighWave *handle, double *out, uintptr_t n); +uintptr_t wickra_high_wave_warmup_period(struct HighWave *handle); + +bool wickra_high_wave_is_ready(struct HighWave *handle); + void wickra_high_wave_reset(struct HighWave *handle); void wickra_high_wave_free(struct HighWave *handle); @@ -5313,6 +6245,10 @@ void wickra_hikkake_batch(struct Hikkake *handle, double *out, uintptr_t n); +uintptr_t wickra_hikkake_warmup_period(struct Hikkake *handle); + +bool wickra_hikkake_is_ready(struct Hikkake *handle); + void wickra_hikkake_reset(struct Hikkake *handle); void wickra_hikkake_free(struct Hikkake *handle); @@ -5337,6 +6273,10 @@ void wickra_hikkake_modified_batch(struct HikkakeModified *handle, double *out, uintptr_t n); +uintptr_t wickra_hikkake_modified_warmup_period(struct HikkakeModified *handle); + +bool wickra_hikkake_modified_is_ready(struct HikkakeModified *handle); + void wickra_hikkake_modified_reset(struct HikkakeModified *handle); void wickra_hikkake_modified_free(struct HikkakeModified *handle); @@ -5361,6 +6301,10 @@ void wickra_hi_lo_activator_batch(struct HiLoActivator *handle, double *out, uintptr_t n); +uintptr_t wickra_hi_lo_activator_warmup_period(struct HiLoActivator *handle); + +bool wickra_hi_lo_activator_is_ready(struct HiLoActivator *handle); + void wickra_hi_lo_activator_reset(struct HiLoActivator *handle); void wickra_hi_lo_activator_free(struct HiLoActivator *handle); @@ -5385,6 +6329,10 @@ void wickra_homing_pigeon_batch(struct HomingPigeon *handle, double *out, uintptr_t n); +uintptr_t wickra_homing_pigeon_warmup_period(struct HomingPigeon *handle); + +bool wickra_homing_pigeon_is_ready(struct HomingPigeon *handle); + void wickra_homing_pigeon_reset(struct HomingPigeon *handle); void wickra_homing_pigeon_free(struct HomingPigeon *handle); @@ -5409,6 +6357,10 @@ void wickra_identical_three_crows_batch(struct IdenticalThreeCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_identical_three_crows_warmup_period(struct IdenticalThreeCrows *handle); + +bool wickra_identical_three_crows_is_ready(struct IdenticalThreeCrows *handle); + void wickra_identical_three_crows_reset(struct IdenticalThreeCrows *handle); void wickra_identical_three_crows_free(struct IdenticalThreeCrows *handle); @@ -5433,6 +6385,10 @@ void wickra_in_neck_batch(struct InNeck *handle, double *out, uintptr_t n); +uintptr_t wickra_in_neck_warmup_period(struct InNeck *handle); + +bool wickra_in_neck_is_ready(struct InNeck *handle); + void wickra_in_neck_reset(struct InNeck *handle); void wickra_in_neck_free(struct InNeck *handle); @@ -5457,6 +6413,10 @@ void wickra_inertia_batch(struct Inertia *handle, double *out, uintptr_t n); +uintptr_t wickra_inertia_warmup_period(struct Inertia *handle); + +bool wickra_inertia_is_ready(struct Inertia *handle); + void wickra_inertia_reset(struct Inertia *handle); void wickra_inertia_free(struct Inertia *handle); @@ -5481,6 +6441,10 @@ void wickra_intraday_intensity_batch(struct IntradayIntensity *handle, double *out, uintptr_t n); +uintptr_t wickra_intraday_intensity_warmup_period(struct IntradayIntensity *handle); + +bool wickra_intraday_intensity_is_ready(struct IntradayIntensity *handle); + void wickra_intraday_intensity_reset(struct IntradayIntensity *handle); void wickra_intraday_intensity_free(struct IntradayIntensity *handle); @@ -5505,6 +6469,10 @@ void wickra_intraday_momentum_index_batch(struct IntradayMomentumIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_intraday_momentum_index_warmup_period(struct IntradayMomentumIndex *handle); + +bool wickra_intraday_momentum_index_is_ready(struct IntradayMomentumIndex *handle); + void wickra_intraday_momentum_index_reset(struct IntradayMomentumIndex *handle); void wickra_intraday_momentum_index_free(struct IntradayMomentumIndex *handle); @@ -5529,6 +6497,10 @@ void wickra_inverted_hammer_batch(struct InvertedHammer *handle, double *out, uintptr_t n); +uintptr_t wickra_inverted_hammer_warmup_period(struct InvertedHammer *handle); + +bool wickra_inverted_hammer_is_ready(struct InvertedHammer *handle); + void wickra_inverted_hammer_reset(struct InvertedHammer *handle); void wickra_inverted_hammer_free(struct InvertedHammer *handle); @@ -5553,6 +6525,10 @@ void wickra_kicking_batch(struct Kicking *handle, double *out, uintptr_t n); +uintptr_t wickra_kicking_warmup_period(struct Kicking *handle); + +bool wickra_kicking_is_ready(struct Kicking *handle); + void wickra_kicking_reset(struct Kicking *handle); void wickra_kicking_free(struct Kicking *handle); @@ -5577,6 +6553,10 @@ void wickra_kicking_by_length_batch(struct KickingByLength *handle, double *out, uintptr_t n); +uintptr_t wickra_kicking_by_length_warmup_period(struct KickingByLength *handle); + +bool wickra_kicking_by_length_is_ready(struct KickingByLength *handle); + void wickra_kicking_by_length_reset(struct KickingByLength *handle); void wickra_kicking_by_length_free(struct KickingByLength *handle); @@ -5601,6 +6581,10 @@ void wickra_kvo_batch(struct Kvo *handle, double *out, uintptr_t n); +uintptr_t wickra_kvo_warmup_period(struct Kvo *handle); + +bool wickra_kvo_is_ready(struct Kvo *handle); + void wickra_kvo_reset(struct Kvo *handle); void wickra_kvo_free(struct Kvo *handle); @@ -5625,6 +6609,10 @@ void wickra_ladder_bottom_batch(struct LadderBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_ladder_bottom_warmup_period(struct LadderBottom *handle); + +bool wickra_ladder_bottom_is_ready(struct LadderBottom *handle); + void wickra_ladder_bottom_reset(struct LadderBottom *handle); void wickra_ladder_bottom_free(struct LadderBottom *handle); @@ -5649,6 +6637,10 @@ void wickra_long_legged_doji_batch(struct LongLeggedDoji *handle, double *out, uintptr_t n); +uintptr_t wickra_long_legged_doji_warmup_period(struct LongLeggedDoji *handle); + +bool wickra_long_legged_doji_is_ready(struct LongLeggedDoji *handle); + void wickra_long_legged_doji_reset(struct LongLeggedDoji *handle); void wickra_long_legged_doji_free(struct LongLeggedDoji *handle); @@ -5673,6 +6665,10 @@ void wickra_long_line_batch(struct LongLine *handle, double *out, uintptr_t n); +uintptr_t wickra_long_line_warmup_period(struct LongLine *handle); + +bool wickra_long_line_is_ready(struct LongLine *handle); + void wickra_long_line_reset(struct LongLine *handle); void wickra_long_line_free(struct LongLine *handle); @@ -5697,6 +6693,10 @@ void wickra_market_facilitation_index_batch(struct MarketFacilitationIndex *hand double *out, uintptr_t n); +uintptr_t wickra_market_facilitation_index_warmup_period(struct MarketFacilitationIndex *handle); + +bool wickra_market_facilitation_index_is_ready(struct MarketFacilitationIndex *handle); + void wickra_market_facilitation_index_reset(struct MarketFacilitationIndex *handle); void wickra_market_facilitation_index_free(struct MarketFacilitationIndex *handle); @@ -5721,6 +6721,10 @@ void wickra_marubozu_batch(struct Marubozu *handle, double *out, uintptr_t n); +uintptr_t wickra_marubozu_warmup_period(struct Marubozu *handle); + +bool wickra_marubozu_is_ready(struct Marubozu *handle); + void wickra_marubozu_reset(struct Marubozu *handle); void wickra_marubozu_free(struct Marubozu *handle); @@ -5745,6 +6749,10 @@ void wickra_mass_index_batch(struct MassIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_mass_index_warmup_period(struct MassIndex *handle); + +bool wickra_mass_index_is_ready(struct MassIndex *handle); + void wickra_mass_index_reset(struct MassIndex *handle); void wickra_mass_index_free(struct MassIndex *handle); @@ -5769,6 +6777,10 @@ void wickra_mat_hold_batch(struct MatHold *handle, double *out, uintptr_t n); +uintptr_t wickra_mat_hold_warmup_period(struct MatHold *handle); + +bool wickra_mat_hold_is_ready(struct MatHold *handle); + void wickra_mat_hold_reset(struct MatHold *handle); void wickra_mat_hold_free(struct MatHold *handle); @@ -5793,6 +6805,10 @@ void wickra_matching_low_batch(struct MatchingLow *handle, double *out, uintptr_t n); +uintptr_t wickra_matching_low_warmup_period(struct MatchingLow *handle); + +bool wickra_matching_low_is_ready(struct MatchingLow *handle); + void wickra_matching_low_reset(struct MatchingLow *handle); void wickra_matching_low_free(struct MatchingLow *handle); @@ -5817,6 +6833,10 @@ void wickra_median_price_batch(struct MedianPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_median_price_warmup_period(struct MedianPrice *handle); + +bool wickra_median_price_is_ready(struct MedianPrice *handle); + void wickra_median_price_reset(struct MedianPrice *handle); void wickra_median_price_free(struct MedianPrice *handle); @@ -5841,6 +6861,10 @@ void wickra_mfi_batch(struct Mfi *handle, double *out, uintptr_t n); +uintptr_t wickra_mfi_warmup_period(struct Mfi *handle); + +bool wickra_mfi_is_ready(struct Mfi *handle); + void wickra_mfi_reset(struct Mfi *handle); void wickra_mfi_free(struct Mfi *handle); @@ -5865,6 +6889,10 @@ void wickra_mid_price_batch(struct MidPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_mid_price_warmup_period(struct MidPrice *handle); + +bool wickra_mid_price_is_ready(struct MidPrice *handle); + void wickra_mid_price_reset(struct MidPrice *handle); void wickra_mid_price_free(struct MidPrice *handle); @@ -5889,6 +6917,10 @@ void wickra_minus_di_batch(struct MinusDi *handle, double *out, uintptr_t n); +uintptr_t wickra_minus_di_warmup_period(struct MinusDi *handle); + +bool wickra_minus_di_is_ready(struct MinusDi *handle); + void wickra_minus_di_reset(struct MinusDi *handle); void wickra_minus_di_free(struct MinusDi *handle); @@ -5913,6 +6945,10 @@ void wickra_minus_dm_batch(struct MinusDm *handle, double *out, uintptr_t n); +uintptr_t wickra_minus_dm_warmup_period(struct MinusDm *handle); + +bool wickra_minus_dm_is_ready(struct MinusDm *handle); + void wickra_minus_dm_reset(struct MinusDm *handle); void wickra_minus_dm_free(struct MinusDm *handle); @@ -5937,6 +6973,10 @@ void wickra_morning_doji_star_batch(struct MorningDojiStar *handle, double *out, uintptr_t n); +uintptr_t wickra_morning_doji_star_warmup_period(struct MorningDojiStar *handle); + +bool wickra_morning_doji_star_is_ready(struct MorningDojiStar *handle); + void wickra_morning_doji_star_reset(struct MorningDojiStar *handle); void wickra_morning_doji_star_free(struct MorningDojiStar *handle); @@ -5961,6 +7001,10 @@ void wickra_morning_evening_star_batch(struct MorningEveningStar *handle, double *out, uintptr_t n); +uintptr_t wickra_morning_evening_star_warmup_period(struct MorningEveningStar *handle); + +bool wickra_morning_evening_star_is_ready(struct MorningEveningStar *handle); + void wickra_morning_evening_star_reset(struct MorningEveningStar *handle); void wickra_morning_evening_star_free(struct MorningEveningStar *handle); @@ -5985,6 +7029,10 @@ void wickra_naked_poc_batch(struct NakedPoc *handle, double *out, uintptr_t n); +uintptr_t wickra_naked_poc_warmup_period(struct NakedPoc *handle); + +bool wickra_naked_poc_is_ready(struct NakedPoc *handle); + void wickra_naked_poc_reset(struct NakedPoc *handle); void wickra_naked_poc_free(struct NakedPoc *handle); @@ -6009,6 +7057,10 @@ void wickra_natr_batch(struct Natr *handle, double *out, uintptr_t n); +uintptr_t wickra_natr_warmup_period(struct Natr *handle); + +bool wickra_natr_is_ready(struct Natr *handle); + void wickra_natr_reset(struct Natr *handle); void wickra_natr_free(struct Natr *handle); @@ -6033,6 +7085,10 @@ void wickra_new_price_lines_batch(struct NewPriceLines *handle, double *out, uintptr_t n); +uintptr_t wickra_new_price_lines_warmup_period(struct NewPriceLines *handle); + +bool wickra_new_price_lines_is_ready(struct NewPriceLines *handle); + void wickra_new_price_lines_reset(struct NewPriceLines *handle); void wickra_new_price_lines_free(struct NewPriceLines *handle); @@ -6057,6 +7113,10 @@ void wickra_nvi_batch(struct Nvi *handle, double *out, uintptr_t n); +uintptr_t wickra_nvi_warmup_period(struct Nvi *handle); + +bool wickra_nvi_is_ready(struct Nvi *handle); + void wickra_nvi_reset(struct Nvi *handle); void wickra_nvi_free(struct Nvi *handle); @@ -6081,6 +7141,10 @@ void wickra_obv_batch(struct Obv *handle, double *out, uintptr_t n); +uintptr_t wickra_obv_warmup_period(struct Obv *handle); + +bool wickra_obv_is_ready(struct Obv *handle); + void wickra_obv_reset(struct Obv *handle); void wickra_obv_free(struct Obv *handle); @@ -6105,6 +7169,10 @@ void wickra_on_neck_batch(struct OnNeck *handle, double *out, uintptr_t n); +uintptr_t wickra_on_neck_warmup_period(struct OnNeck *handle); + +bool wickra_on_neck_is_ready(struct OnNeck *handle); + void wickra_on_neck_reset(struct OnNeck *handle); void wickra_on_neck_free(struct OnNeck *handle); @@ -6129,6 +7197,10 @@ void wickra_opening_marubozu_batch(struct OpeningMarubozu *handle, double *out, uintptr_t n); +uintptr_t wickra_opening_marubozu_warmup_period(struct OpeningMarubozu *handle); + +bool wickra_opening_marubozu_is_ready(struct OpeningMarubozu *handle); + void wickra_opening_marubozu_reset(struct OpeningMarubozu *handle); void wickra_opening_marubozu_free(struct OpeningMarubozu *handle); @@ -6153,6 +7225,10 @@ void wickra_overnight_gap_batch(struct OvernightGap *handle, double *out, uintptr_t n); +uintptr_t wickra_overnight_gap_warmup_period(struct OvernightGap *handle); + +bool wickra_overnight_gap_is_ready(struct OvernightGap *handle); + void wickra_overnight_gap_reset(struct OvernightGap *handle); void wickra_overnight_gap_free(struct OvernightGap *handle); @@ -6178,6 +7254,10 @@ void wickra_parkinson_volatility_batch(struct ParkinsonVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_parkinson_volatility_warmup_period(struct ParkinsonVolatility *handle); + +bool wickra_parkinson_volatility_is_ready(struct ParkinsonVolatility *handle); + void wickra_parkinson_volatility_reset(struct ParkinsonVolatility *handle); void wickra_parkinson_volatility_free(struct ParkinsonVolatility *handle); @@ -6202,6 +7282,10 @@ void wickra_pgo_batch(struct Pgo *handle, double *out, uintptr_t n); +uintptr_t wickra_pgo_warmup_period(struct Pgo *handle); + +bool wickra_pgo_is_ready(struct Pgo *handle); + void wickra_pgo_reset(struct Pgo *handle); void wickra_pgo_free(struct Pgo *handle); @@ -6226,6 +7310,10 @@ void wickra_piercing_dark_cloud_batch(struct PiercingDarkCloud *handle, double *out, uintptr_t n); +uintptr_t wickra_piercing_dark_cloud_warmup_period(struct PiercingDarkCloud *handle); + +bool wickra_piercing_dark_cloud_is_ready(struct PiercingDarkCloud *handle); + void wickra_piercing_dark_cloud_reset(struct PiercingDarkCloud *handle); void wickra_piercing_dark_cloud_free(struct PiercingDarkCloud *handle); @@ -6250,6 +7338,10 @@ void wickra_pivot_reversal_batch(struct PivotReversal *handle, double *out, uintptr_t n); +uintptr_t wickra_pivot_reversal_warmup_period(struct PivotReversal *handle); + +bool wickra_pivot_reversal_is_ready(struct PivotReversal *handle); + void wickra_pivot_reversal_reset(struct PivotReversal *handle); void wickra_pivot_reversal_free(struct PivotReversal *handle); @@ -6274,6 +7366,10 @@ void wickra_plus_di_batch(struct PlusDi *handle, double *out, uintptr_t n); +uintptr_t wickra_plus_di_warmup_period(struct PlusDi *handle); + +bool wickra_plus_di_is_ready(struct PlusDi *handle); + void wickra_plus_di_reset(struct PlusDi *handle); void wickra_plus_di_free(struct PlusDi *handle); @@ -6298,6 +7394,10 @@ void wickra_plus_dm_batch(struct PlusDm *handle, double *out, uintptr_t n); +uintptr_t wickra_plus_dm_warmup_period(struct PlusDm *handle); + +bool wickra_plus_dm_is_ready(struct PlusDm *handle); + void wickra_plus_dm_reset(struct PlusDm *handle); void wickra_plus_dm_free(struct PlusDm *handle); @@ -6322,6 +7422,10 @@ void wickra_profile_shape_batch(struct ProfileShape *handle, double *out, uintptr_t n); +uintptr_t wickra_profile_shape_warmup_period(struct ProfileShape *handle); + +bool wickra_profile_shape_is_ready(struct ProfileShape *handle); + void wickra_profile_shape_reset(struct ProfileShape *handle); void wickra_profile_shape_free(struct ProfileShape *handle); @@ -6346,6 +7450,10 @@ void wickra_projection_oscillator_batch(struct ProjectionOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_projection_oscillator_warmup_period(struct ProjectionOscillator *handle); + +bool wickra_projection_oscillator_is_ready(struct ProjectionOscillator *handle); + void wickra_projection_oscillator_reset(struct ProjectionOscillator *handle); void wickra_projection_oscillator_free(struct ProjectionOscillator *handle); @@ -6370,6 +7478,10 @@ void wickra_psar_batch(struct Psar *handle, double *out, uintptr_t n); +uintptr_t wickra_psar_warmup_period(struct Psar *handle); + +bool wickra_psar_is_ready(struct Psar *handle); + void wickra_psar_reset(struct Psar *handle); void wickra_psar_free(struct Psar *handle); @@ -6394,6 +7506,10 @@ void wickra_pvi_batch(struct Pvi *handle, double *out, uintptr_t n); +uintptr_t wickra_pvi_warmup_period(struct Pvi *handle); + +bool wickra_pvi_is_ready(struct Pvi *handle); + void wickra_pvi_reset(struct Pvi *handle); void wickra_pvi_free(struct Pvi *handle); @@ -6418,6 +7534,10 @@ void wickra_qstick_batch(struct Qstick *handle, double *out, uintptr_t n); +uintptr_t wickra_qstick_warmup_period(struct Qstick *handle); + +bool wickra_qstick_is_ready(struct Qstick *handle); + void wickra_qstick_reset(struct Qstick *handle); void wickra_qstick_free(struct Qstick *handle); @@ -6442,6 +7562,10 @@ void wickra_rectangle_range_batch(struct RectangleRange *handle, double *out, uintptr_t n); +uintptr_t wickra_rectangle_range_warmup_period(struct RectangleRange *handle); + +bool wickra_rectangle_range_is_ready(struct RectangleRange *handle); + void wickra_rectangle_range_reset(struct RectangleRange *handle); void wickra_rectangle_range_free(struct RectangleRange *handle); @@ -6466,6 +7590,10 @@ void wickra_rickshaw_man_batch(struct RickshawMan *handle, double *out, uintptr_t n); +uintptr_t wickra_rickshaw_man_warmup_period(struct RickshawMan *handle); + +bool wickra_rickshaw_man_is_ready(struct RickshawMan *handle); + void wickra_rickshaw_man_reset(struct RickshawMan *handle); void wickra_rickshaw_man_free(struct RickshawMan *handle); @@ -6490,6 +7618,10 @@ void wickra_rising_three_methods_batch(struct RisingThreeMethods *handle, double *out, uintptr_t n); +uintptr_t wickra_rising_three_methods_warmup_period(struct RisingThreeMethods *handle); + +bool wickra_rising_three_methods_is_ready(struct RisingThreeMethods *handle); + void wickra_rising_three_methods_reset(struct RisingThreeMethods *handle); void wickra_rising_three_methods_free(struct RisingThreeMethods *handle); @@ -6515,6 +7647,10 @@ void wickra_rogers_satchell_volatility_batch(struct RogersSatchellVolatility *ha double *out, uintptr_t n); +uintptr_t wickra_rogers_satchell_volatility_warmup_period(struct RogersSatchellVolatility *handle); + +bool wickra_rogers_satchell_volatility_is_ready(struct RogersSatchellVolatility *handle); + void wickra_rogers_satchell_volatility_reset(struct RogersSatchellVolatility *handle); void wickra_rogers_satchell_volatility_free(struct RogersSatchellVolatility *handle); @@ -6539,6 +7675,10 @@ void wickra_rvi_batch(struct Rvi *handle, double *out, uintptr_t n); +uintptr_t wickra_rvi_warmup_period(struct Rvi *handle); + +bool wickra_rvi_is_ready(struct Rvi *handle); + void wickra_rvi_reset(struct Rvi *handle); void wickra_rvi_free(struct Rvi *handle); @@ -6570,6 +7710,10 @@ void wickra_sar_ext_batch(struct SarExt *handle, double *out, uintptr_t n); +uintptr_t wickra_sar_ext_warmup_period(struct SarExt *handle); + +bool wickra_sar_ext_is_ready(struct SarExt *handle); + void wickra_sar_ext_reset(struct SarExt *handle); void wickra_sar_ext_free(struct SarExt *handle); @@ -6594,6 +7738,10 @@ void wickra_seasonal_z_score_batch(struct SeasonalZScore *handle, double *out, uintptr_t n); +uintptr_t wickra_seasonal_z_score_warmup_period(struct SeasonalZScore *handle); + +bool wickra_seasonal_z_score_is_ready(struct SeasonalZScore *handle); + void wickra_seasonal_z_score_reset(struct SeasonalZScore *handle); void wickra_seasonal_z_score_free(struct SeasonalZScore *handle); @@ -6618,6 +7766,10 @@ void wickra_separating_lines_batch(struct SeparatingLines *handle, double *out, uintptr_t n); +uintptr_t wickra_separating_lines_warmup_period(struct SeparatingLines *handle); + +bool wickra_separating_lines_is_ready(struct SeparatingLines *handle); + void wickra_separating_lines_reset(struct SeparatingLines *handle); void wickra_separating_lines_free(struct SeparatingLines *handle); @@ -6642,6 +7794,10 @@ void wickra_session_vwap_batch(struct SessionVwap *handle, double *out, uintptr_t n); +uintptr_t wickra_session_vwap_warmup_period(struct SessionVwap *handle); + +bool wickra_session_vwap_is_ready(struct SessionVwap *handle); + void wickra_session_vwap_reset(struct SessionVwap *handle); void wickra_session_vwap_free(struct SessionVwap *handle); @@ -6666,6 +7822,10 @@ void wickra_shark_batch(struct Shark *handle, double *out, uintptr_t n); +uintptr_t wickra_shark_warmup_period(struct Shark *handle); + +bool wickra_shark_is_ready(struct Shark *handle); + void wickra_shark_reset(struct Shark *handle); void wickra_shark_free(struct Shark *handle); @@ -6690,6 +7850,10 @@ void wickra_shooting_star_batch(struct ShootingStar *handle, double *out, uintptr_t n); +uintptr_t wickra_shooting_star_warmup_period(struct ShootingStar *handle); + +bool wickra_shooting_star_is_ready(struct ShootingStar *handle); + void wickra_shooting_star_reset(struct ShootingStar *handle); void wickra_shooting_star_free(struct ShootingStar *handle); @@ -6714,6 +7878,10 @@ void wickra_short_line_batch(struct ShortLine *handle, double *out, uintptr_t n); +uintptr_t wickra_short_line_warmup_period(struct ShortLine *handle); + +bool wickra_short_line_is_ready(struct ShortLine *handle); + void wickra_short_line_reset(struct ShortLine *handle); void wickra_short_line_free(struct ShortLine *handle); @@ -6738,6 +7906,10 @@ void wickra_single_prints_batch(struct SinglePrints *handle, double *out, uintptr_t n); +uintptr_t wickra_single_prints_warmup_period(struct SinglePrints *handle); + +bool wickra_single_prints_is_ready(struct SinglePrints *handle); + void wickra_single_prints_reset(struct SinglePrints *handle); void wickra_single_prints_free(struct SinglePrints *handle); @@ -6762,6 +7934,10 @@ void wickra_smi_batch(struct Smi *handle, double *out, uintptr_t n); +uintptr_t wickra_smi_warmup_period(struct Smi *handle); + +bool wickra_smi_is_ready(struct Smi *handle); + void wickra_smi_reset(struct Smi *handle); void wickra_smi_free(struct Smi *handle); @@ -6786,6 +7962,10 @@ void wickra_spinning_top_batch(struct SpinningTop *handle, double *out, uintptr_t n); +uintptr_t wickra_spinning_top_warmup_period(struct SpinningTop *handle); + +bool wickra_spinning_top_is_ready(struct SpinningTop *handle); + void wickra_spinning_top_reset(struct SpinningTop *handle); void wickra_spinning_top_free(struct SpinningTop *handle); @@ -6810,6 +7990,10 @@ void wickra_stalled_pattern_batch(struct StalledPattern *handle, double *out, uintptr_t n); +uintptr_t wickra_stalled_pattern_warmup_period(struct StalledPattern *handle); + +bool wickra_stalled_pattern_is_ready(struct StalledPattern *handle); + void wickra_stalled_pattern_reset(struct StalledPattern *handle); void wickra_stalled_pattern_free(struct StalledPattern *handle); @@ -6834,6 +8018,10 @@ void wickra_stick_sandwich_batch(struct StickSandwich *handle, double *out, uintptr_t n); +uintptr_t wickra_stick_sandwich_warmup_period(struct StickSandwich *handle); + +bool wickra_stick_sandwich_is_ready(struct StickSandwich *handle); + void wickra_stick_sandwich_reset(struct StickSandwich *handle); void wickra_stick_sandwich_free(struct StickSandwich *handle); @@ -6858,6 +8046,10 @@ void wickra_stochastic_cci_batch(struct StochasticCci *handle, double *out, uintptr_t n); +uintptr_t wickra_stochastic_cci_warmup_period(struct StochasticCci *handle); + +bool wickra_stochastic_cci_is_ready(struct StochasticCci *handle); + void wickra_stochastic_cci_reset(struct StochasticCci *handle); void wickra_stochastic_cci_free(struct StochasticCci *handle); @@ -6882,6 +8074,10 @@ void wickra_takuri_batch(struct Takuri *handle, double *out, uintptr_t n); +uintptr_t wickra_takuri_warmup_period(struct Takuri *handle); + +bool wickra_takuri_is_ready(struct Takuri *handle); + void wickra_takuri_reset(struct Takuri *handle); void wickra_takuri_free(struct Takuri *handle); @@ -6906,6 +8102,10 @@ void wickra_tasuki_gap_batch(struct TasukiGap *handle, double *out, uintptr_t n); +uintptr_t wickra_tasuki_gap_warmup_period(struct TasukiGap *handle); + +bool wickra_tasuki_gap_is_ready(struct TasukiGap *handle); + void wickra_tasuki_gap_reset(struct TasukiGap *handle); void wickra_tasuki_gap_free(struct TasukiGap *handle); @@ -6930,6 +8130,10 @@ void wickra_td_camouflage_batch(struct TdCamouflage *handle, double *out, uintptr_t n); +uintptr_t wickra_td_camouflage_warmup_period(struct TdCamouflage *handle); + +bool wickra_td_camouflage_is_ready(struct TdCamouflage *handle); + void wickra_td_camouflage_reset(struct TdCamouflage *handle); void wickra_td_camouflage_free(struct TdCamouflage *handle); @@ -6954,6 +8158,10 @@ void wickra_td_clop_batch(struct TdClop *handle, double *out, uintptr_t n); +uintptr_t wickra_td_clop_warmup_period(struct TdClop *handle); + +bool wickra_td_clop_is_ready(struct TdClop *handle); + void wickra_td_clop_reset(struct TdClop *handle); void wickra_td_clop_free(struct TdClop *handle); @@ -6978,6 +8186,10 @@ void wickra_td_clopwin_batch(struct TdClopwin *handle, double *out, uintptr_t n); +uintptr_t wickra_td_clopwin_warmup_period(struct TdClopwin *handle); + +bool wickra_td_clopwin_is_ready(struct TdClopwin *handle); + void wickra_td_clopwin_reset(struct TdClopwin *handle); void wickra_td_clopwin_free(struct TdClopwin *handle); @@ -7005,6 +8217,10 @@ void wickra_td_combo_batch(struct TdCombo *handle, double *out, uintptr_t n); +uintptr_t wickra_td_combo_warmup_period(struct TdCombo *handle); + +bool wickra_td_combo_is_ready(struct TdCombo *handle); + void wickra_td_combo_reset(struct TdCombo *handle); void wickra_td_combo_free(struct TdCombo *handle); @@ -7032,6 +8248,10 @@ void wickra_td_countdown_batch(struct TdCountdown *handle, double *out, uintptr_t n); +uintptr_t wickra_td_countdown_warmup_period(struct TdCountdown *handle); + +bool wickra_td_countdown_is_ready(struct TdCountdown *handle); + void wickra_td_countdown_reset(struct TdCountdown *handle); void wickra_td_countdown_free(struct TdCountdown *handle); @@ -7056,6 +8276,10 @@ void wickra_td_de_marker_batch(struct TdDeMarker *handle, double *out, uintptr_t n); +uintptr_t wickra_td_de_marker_warmup_period(struct TdDeMarker *handle); + +bool wickra_td_de_marker_is_ready(struct TdDeMarker *handle); + void wickra_td_de_marker_reset(struct TdDeMarker *handle); void wickra_td_de_marker_free(struct TdDeMarker *handle); @@ -7080,6 +8304,10 @@ void wickra_td_differential_batch(struct TdDifferential *handle, double *out, uintptr_t n); +uintptr_t wickra_td_differential_warmup_period(struct TdDifferential *handle); + +bool wickra_td_differential_is_ready(struct TdDifferential *handle); + void wickra_td_differential_reset(struct TdDifferential *handle); void wickra_td_differential_free(struct TdDifferential *handle); @@ -7104,6 +8332,10 @@ void wickra_td_d_wave_batch(struct TdDWave *handle, double *out, uintptr_t n); +uintptr_t wickra_td_d_wave_warmup_period(struct TdDWave *handle); + +bool wickra_td_d_wave_is_ready(struct TdDWave *handle); + void wickra_td_d_wave_reset(struct TdDWave *handle); void wickra_td_d_wave_free(struct TdDWave *handle); @@ -7128,6 +8360,10 @@ void wickra_td_open_batch(struct TdOpen *handle, double *out, uintptr_t n); +uintptr_t wickra_td_open_warmup_period(struct TdOpen *handle); + +bool wickra_td_open_is_ready(struct TdOpen *handle); + void wickra_td_open_reset(struct TdOpen *handle); void wickra_td_open_free(struct TdOpen *handle); @@ -7152,6 +8388,10 @@ void wickra_td_pressure_batch(struct TdPressure *handle, double *out, uintptr_t n); +uintptr_t wickra_td_pressure_warmup_period(struct TdPressure *handle); + +bool wickra_td_pressure_is_ready(struct TdPressure *handle); + void wickra_td_pressure_reset(struct TdPressure *handle); void wickra_td_pressure_free(struct TdPressure *handle); @@ -7176,6 +8416,10 @@ void wickra_td_propulsion_batch(struct TdPropulsion *handle, double *out, uintptr_t n); +uintptr_t wickra_td_propulsion_warmup_period(struct TdPropulsion *handle); + +bool wickra_td_propulsion_is_ready(struct TdPropulsion *handle); + void wickra_td_propulsion_reset(struct TdPropulsion *handle); void wickra_td_propulsion_free(struct TdPropulsion *handle); @@ -7200,6 +8444,10 @@ void wickra_td_rei_batch(struct TdRei *handle, double *out, uintptr_t n); +uintptr_t wickra_td_rei_warmup_period(struct TdRei *handle); + +bool wickra_td_rei_is_ready(struct TdRei *handle); + void wickra_td_rei_reset(struct TdRei *handle); void wickra_td_rei_free(struct TdRei *handle); @@ -7224,6 +8472,10 @@ void wickra_td_setup_batch(struct TdSetup *handle, double *out, uintptr_t n); +uintptr_t wickra_td_setup_warmup_period(struct TdSetup *handle); + +bool wickra_td_setup_is_ready(struct TdSetup *handle); + void wickra_td_setup_reset(struct TdSetup *handle); void wickra_td_setup_free(struct TdSetup *handle); @@ -7248,6 +8500,10 @@ void wickra_td_trap_batch(struct TdTrap *handle, double *out, uintptr_t n); +uintptr_t wickra_td_trap_warmup_period(struct TdTrap *handle); + +bool wickra_td_trap_is_ready(struct TdTrap *handle); + void wickra_td_trap_reset(struct TdTrap *handle); void wickra_td_trap_free(struct TdTrap *handle); @@ -7272,6 +8528,10 @@ void wickra_three_drives_batch(struct ThreeDrives *handle, double *out, uintptr_t n); +uintptr_t wickra_three_drives_warmup_period(struct ThreeDrives *handle); + +bool wickra_three_drives_is_ready(struct ThreeDrives *handle); + void wickra_three_drives_reset(struct ThreeDrives *handle); void wickra_three_drives_free(struct ThreeDrives *handle); @@ -7296,6 +8556,10 @@ void wickra_three_inside_batch(struct ThreeInside *handle, double *out, uintptr_t n); +uintptr_t wickra_three_inside_warmup_period(struct ThreeInside *handle); + +bool wickra_three_inside_is_ready(struct ThreeInside *handle); + void wickra_three_inside_reset(struct ThreeInside *handle); void wickra_three_inside_free(struct ThreeInside *handle); @@ -7320,6 +8584,10 @@ void wickra_three_line_break_batch(struct ThreeLineBreak *handle, double *out, uintptr_t n); +uintptr_t wickra_three_line_break_warmup_period(struct ThreeLineBreak *handle); + +bool wickra_three_line_break_is_ready(struct ThreeLineBreak *handle); + void wickra_three_line_break_reset(struct ThreeLineBreak *handle); void wickra_three_line_break_free(struct ThreeLineBreak *handle); @@ -7344,6 +8612,10 @@ void wickra_three_line_strike_batch(struct ThreeLineStrike *handle, double *out, uintptr_t n); +uintptr_t wickra_three_line_strike_warmup_period(struct ThreeLineStrike *handle); + +bool wickra_three_line_strike_is_ready(struct ThreeLineStrike *handle); + void wickra_three_line_strike_reset(struct ThreeLineStrike *handle); void wickra_three_line_strike_free(struct ThreeLineStrike *handle); @@ -7368,6 +8640,10 @@ void wickra_three_outside_batch(struct ThreeOutside *handle, double *out, uintptr_t n); +uintptr_t wickra_three_outside_warmup_period(struct ThreeOutside *handle); + +bool wickra_three_outside_is_ready(struct ThreeOutside *handle); + void wickra_three_outside_reset(struct ThreeOutside *handle); void wickra_three_outside_free(struct ThreeOutside *handle); @@ -7392,6 +8668,10 @@ void wickra_three_soldiers_or_crows_batch(struct ThreeSoldiersOrCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_three_soldiers_or_crows_warmup_period(struct ThreeSoldiersOrCrows *handle); + +bool wickra_three_soldiers_or_crows_is_ready(struct ThreeSoldiersOrCrows *handle); + void wickra_three_soldiers_or_crows_reset(struct ThreeSoldiersOrCrows *handle); void wickra_three_soldiers_or_crows_free(struct ThreeSoldiersOrCrows *handle); @@ -7416,6 +8696,10 @@ void wickra_three_stars_in_south_batch(struct ThreeStarsInSouth *handle, double *out, uintptr_t n); +uintptr_t wickra_three_stars_in_south_warmup_period(struct ThreeStarsInSouth *handle); + +bool wickra_three_stars_in_south_is_ready(struct ThreeStarsInSouth *handle); + void wickra_three_stars_in_south_reset(struct ThreeStarsInSouth *handle); void wickra_three_stars_in_south_free(struct ThreeStarsInSouth *handle); @@ -7440,6 +8724,10 @@ void wickra_thrusting_batch(struct Thrusting *handle, double *out, uintptr_t n); +uintptr_t wickra_thrusting_warmup_period(struct Thrusting *handle); + +bool wickra_thrusting_is_ready(struct Thrusting *handle); + void wickra_thrusting_reset(struct Thrusting *handle); void wickra_thrusting_free(struct Thrusting *handle); @@ -7464,6 +8752,10 @@ void wickra_time_based_stop_batch(struct TimeBasedStop *handle, double *out, uintptr_t n); +uintptr_t wickra_time_based_stop_warmup_period(struct TimeBasedStop *handle); + +bool wickra_time_based_stop_is_ready(struct TimeBasedStop *handle); + void wickra_time_based_stop_reset(struct TimeBasedStop *handle); void wickra_time_based_stop_free(struct TimeBasedStop *handle); @@ -7488,6 +8780,10 @@ void wickra_tower_top_bottom_batch(struct TowerTopBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_tower_top_bottom_warmup_period(struct TowerTopBottom *handle); + +bool wickra_tower_top_bottom_is_ready(struct TowerTopBottom *handle); + void wickra_tower_top_bottom_reset(struct TowerTopBottom *handle); void wickra_tower_top_bottom_free(struct TowerTopBottom *handle); @@ -7512,6 +8808,10 @@ void wickra_trade_volume_index_batch(struct TradeVolumeIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_trade_volume_index_warmup_period(struct TradeVolumeIndex *handle); + +bool wickra_trade_volume_index_is_ready(struct TradeVolumeIndex *handle); + void wickra_trade_volume_index_reset(struct TradeVolumeIndex *handle); void wickra_trade_volume_index_free(struct TradeVolumeIndex *handle); @@ -7536,6 +8836,10 @@ void wickra_triangle_batch(struct Triangle *handle, double *out, uintptr_t n); +uintptr_t wickra_triangle_warmup_period(struct Triangle *handle); + +bool wickra_triangle_is_ready(struct Triangle *handle); + void wickra_triangle_reset(struct Triangle *handle); void wickra_triangle_free(struct Triangle *handle); @@ -7560,6 +8864,10 @@ void wickra_triple_top_bottom_batch(struct TripleTopBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_triple_top_bottom_warmup_period(struct TripleTopBottom *handle); + +bool wickra_triple_top_bottom_is_ready(struct TripleTopBottom *handle); + void wickra_triple_top_bottom_reset(struct TripleTopBottom *handle); void wickra_triple_top_bottom_free(struct TripleTopBottom *handle); @@ -7584,6 +8892,10 @@ void wickra_tristar_batch(struct Tristar *handle, double *out, uintptr_t n); +uintptr_t wickra_tristar_warmup_period(struct Tristar *handle); + +bool wickra_tristar_is_ready(struct Tristar *handle); + void wickra_tristar_reset(struct Tristar *handle); void wickra_tristar_free(struct Tristar *handle); @@ -7608,6 +8920,10 @@ void wickra_true_range_batch(struct TrueRange *handle, double *out, uintptr_t n); +uintptr_t wickra_true_range_warmup_period(struct TrueRange *handle); + +bool wickra_true_range_is_ready(struct TrueRange *handle); + void wickra_true_range_reset(struct TrueRange *handle); void wickra_true_range_free(struct TrueRange *handle); @@ -7632,6 +8948,10 @@ void wickra_tsv_batch(struct Tsv *handle, double *out, uintptr_t n); +uintptr_t wickra_tsv_warmup_period(struct Tsv *handle); + +bool wickra_tsv_is_ready(struct Tsv *handle); + void wickra_tsv_reset(struct Tsv *handle); void wickra_tsv_free(struct Tsv *handle); @@ -7656,6 +8976,10 @@ void wickra_ttm_trend_batch(struct TtmTrend *handle, double *out, uintptr_t n); +uintptr_t wickra_ttm_trend_warmup_period(struct TtmTrend *handle); + +bool wickra_ttm_trend_is_ready(struct TtmTrend *handle); + void wickra_ttm_trend_reset(struct TtmTrend *handle); void wickra_ttm_trend_free(struct TtmTrend *handle); @@ -7682,6 +9006,10 @@ void wickra_turn_of_month_batch(struct TurnOfMonth *handle, double *out, uintptr_t n); +uintptr_t wickra_turn_of_month_warmup_period(struct TurnOfMonth *handle); + +bool wickra_turn_of_month_is_ready(struct TurnOfMonth *handle); + void wickra_turn_of_month_reset(struct TurnOfMonth *handle); void wickra_turn_of_month_free(struct TurnOfMonth *handle); @@ -7706,6 +9034,10 @@ void wickra_tweezer_batch(struct Tweezer *handle, double *out, uintptr_t n); +uintptr_t wickra_tweezer_warmup_period(struct Tweezer *handle); + +bool wickra_tweezer_is_ready(struct Tweezer *handle); + void wickra_tweezer_reset(struct Tweezer *handle); void wickra_tweezer_free(struct Tweezer *handle); @@ -7730,6 +9062,10 @@ void wickra_twiggs_money_flow_batch(struct TwiggsMoneyFlow *handle, double *out, uintptr_t n); +uintptr_t wickra_twiggs_money_flow_warmup_period(struct TwiggsMoneyFlow *handle); + +bool wickra_twiggs_money_flow_is_ready(struct TwiggsMoneyFlow *handle); + void wickra_twiggs_money_flow_reset(struct TwiggsMoneyFlow *handle); void wickra_twiggs_money_flow_free(struct TwiggsMoneyFlow *handle); @@ -7754,6 +9090,10 @@ void wickra_two_crows_batch(struct TwoCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_two_crows_warmup_period(struct TwoCrows *handle); + +bool wickra_two_crows_is_ready(struct TwoCrows *handle); + void wickra_two_crows_reset(struct TwoCrows *handle); void wickra_two_crows_free(struct TwoCrows *handle); @@ -7778,6 +9118,10 @@ void wickra_typical_price_batch(struct TypicalPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_typical_price_warmup_period(struct TypicalPrice *handle); + +bool wickra_typical_price_is_ready(struct TypicalPrice *handle); + void wickra_typical_price_reset(struct TypicalPrice *handle); void wickra_typical_price_free(struct TypicalPrice *handle); @@ -7804,6 +9148,10 @@ void wickra_ultimate_oscillator_batch(struct UltimateOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_ultimate_oscillator_warmup_period(struct UltimateOscillator *handle); + +bool wickra_ultimate_oscillator_is_ready(struct UltimateOscillator *handle); + void wickra_ultimate_oscillator_reset(struct UltimateOscillator *handle); void wickra_ultimate_oscillator_free(struct UltimateOscillator *handle); @@ -7828,6 +9176,10 @@ void wickra_unique_three_river_batch(struct UniqueThreeRiver *handle, double *out, uintptr_t n); +uintptr_t wickra_unique_three_river_warmup_period(struct UniqueThreeRiver *handle); + +bool wickra_unique_three_river_is_ready(struct UniqueThreeRiver *handle); + void wickra_unique_three_river_reset(struct UniqueThreeRiver *handle); void wickra_unique_three_river_free(struct UniqueThreeRiver *handle); @@ -7852,6 +9204,10 @@ void wickra_upside_gap_three_methods_batch(struct UpsideGapThreeMethods *handle, double *out, uintptr_t n); +uintptr_t wickra_upside_gap_three_methods_warmup_period(struct UpsideGapThreeMethods *handle); + +bool wickra_upside_gap_three_methods_is_ready(struct UpsideGapThreeMethods *handle); + void wickra_upside_gap_three_methods_reset(struct UpsideGapThreeMethods *handle); void wickra_upside_gap_three_methods_free(struct UpsideGapThreeMethods *handle); @@ -7876,6 +9232,10 @@ void wickra_upside_gap_two_crows_batch(struct UpsideGapTwoCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_upside_gap_two_crows_warmup_period(struct UpsideGapTwoCrows *handle); + +bool wickra_upside_gap_two_crows_is_ready(struct UpsideGapTwoCrows *handle); + void wickra_upside_gap_two_crows_reset(struct UpsideGapTwoCrows *handle); void wickra_upside_gap_two_crows_free(struct UpsideGapTwoCrows *handle); @@ -7900,6 +9260,10 @@ void wickra_volatility_ratio_batch(struct VolatilityRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_volatility_ratio_warmup_period(struct VolatilityRatio *handle); + +bool wickra_volatility_ratio_is_ready(struct VolatilityRatio *handle); + void wickra_volatility_ratio_reset(struct VolatilityRatio *handle); void wickra_volatility_ratio_free(struct VolatilityRatio *handle); @@ -7924,6 +9288,10 @@ void wickra_volty_stop_batch(struct VoltyStop *handle, double *out, uintptr_t n); +uintptr_t wickra_volty_stop_warmup_period(struct VoltyStop *handle); + +bool wickra_volty_stop_is_ready(struct VoltyStop *handle); + void wickra_volty_stop_reset(struct VoltyStop *handle); void wickra_volty_stop_free(struct VoltyStop *handle); @@ -7948,6 +9316,10 @@ void wickra_volume_oscillator_batch(struct VolumeOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_volume_oscillator_warmup_period(struct VolumeOscillator *handle); + +bool wickra_volume_oscillator_is_ready(struct VolumeOscillator *handle); + void wickra_volume_oscillator_reset(struct VolumeOscillator *handle); void wickra_volume_oscillator_free(struct VolumeOscillator *handle); @@ -7972,6 +9344,10 @@ void wickra_volume_rsi_batch(struct VolumeRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_volume_rsi_warmup_period(struct VolumeRsi *handle); + +bool wickra_volume_rsi_is_ready(struct VolumeRsi *handle); + void wickra_volume_rsi_reset(struct VolumeRsi *handle); void wickra_volume_rsi_free(struct VolumeRsi *handle); @@ -7996,6 +9372,10 @@ void wickra_volume_price_trend_batch(struct VolumePriceTrend *handle, double *out, uintptr_t n); +uintptr_t wickra_volume_price_trend_warmup_period(struct VolumePriceTrend *handle); + +bool wickra_volume_price_trend_is_ready(struct VolumePriceTrend *handle); + void wickra_volume_price_trend_reset(struct VolumePriceTrend *handle); void wickra_volume_price_trend_free(struct VolumePriceTrend *handle); @@ -8020,6 +9400,10 @@ void wickra_vwap_batch(struct Vwap *handle, double *out, uintptr_t n); +uintptr_t wickra_vwap_warmup_period(struct Vwap *handle); + +bool wickra_vwap_is_ready(struct Vwap *handle); + void wickra_vwap_reset(struct Vwap *handle); void wickra_vwap_free(struct Vwap *handle); @@ -8044,6 +9428,10 @@ void wickra_rolling_vwap_batch(struct RollingVwap *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_vwap_warmup_period(struct RollingVwap *handle); + +bool wickra_rolling_vwap_is_ready(struct RollingVwap *handle); + void wickra_rolling_vwap_reset(struct RollingVwap *handle); void wickra_rolling_vwap_free(struct RollingVwap *handle); @@ -8068,6 +9456,10 @@ void wickra_vwma_batch(struct Vwma *handle, double *out, uintptr_t n); +uintptr_t wickra_vwma_warmup_period(struct Vwma *handle); + +bool wickra_vwma_is_ready(struct Vwma *handle); + void wickra_vwma_reset(struct Vwma *handle); void wickra_vwma_free(struct Vwma *handle); @@ -8092,6 +9484,10 @@ void wickra_vzo_batch(struct Vzo *handle, double *out, uintptr_t n); +uintptr_t wickra_vzo_warmup_period(struct Vzo *handle); + +bool wickra_vzo_is_ready(struct Vzo *handle); + void wickra_vzo_reset(struct Vzo *handle); void wickra_vzo_free(struct Vzo *handle); @@ -8116,6 +9512,10 @@ void wickra_wad_batch(struct Wad *handle, double *out, uintptr_t n); +uintptr_t wickra_wad_warmup_period(struct Wad *handle); + +bool wickra_wad_is_ready(struct Wad *handle); + void wickra_wad_reset(struct Wad *handle); void wickra_wad_free(struct Wad *handle); @@ -8140,6 +9540,10 @@ void wickra_wedge_batch(struct Wedge *handle, double *out, uintptr_t n); +uintptr_t wickra_wedge_warmup_period(struct Wedge *handle); + +bool wickra_wedge_is_ready(struct Wedge *handle); + void wickra_wedge_reset(struct Wedge *handle); void wickra_wedge_free(struct Wedge *handle); @@ -8164,6 +9568,10 @@ void wickra_weighted_close_batch(struct WeightedClose *handle, double *out, uintptr_t n); +uintptr_t wickra_weighted_close_warmup_period(struct WeightedClose *handle); + +bool wickra_weighted_close_is_ready(struct WeightedClose *handle); + void wickra_weighted_close_reset(struct WeightedClose *handle); void wickra_weighted_close_free(struct WeightedClose *handle); @@ -8188,6 +9596,10 @@ void wickra_wick_ratio_batch(struct WickRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_wick_ratio_warmup_period(struct WickRatio *handle); + +bool wickra_wick_ratio_is_ready(struct WickRatio *handle); + void wickra_wick_ratio_reset(struct WickRatio *handle); void wickra_wick_ratio_free(struct WickRatio *handle); @@ -8212,6 +9624,10 @@ void wickra_williams_r_batch(struct WilliamsR *handle, double *out, uintptr_t n); +uintptr_t wickra_williams_r_warmup_period(struct WilliamsR *handle); + +bool wickra_williams_r_is_ready(struct WilliamsR *handle); + void wickra_williams_r_reset(struct WilliamsR *handle); void wickra_williams_r_free(struct WilliamsR *handle); @@ -8237,6 +9653,10 @@ void wickra_yang_zhang_volatility_batch(struct YangZhangVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_yang_zhang_volatility_warmup_period(struct YangZhangVolatility *handle); + +bool wickra_yang_zhang_volatility_is_ready(struct YangZhangVolatility *handle); + void wickra_yang_zhang_volatility_reset(struct YangZhangVolatility *handle); void wickra_yang_zhang_volatility_free(struct YangZhangVolatility *handle); @@ -8261,6 +9681,10 @@ void wickra_yoyo_exit_batch(struct YoyoExit *handle, double *out, uintptr_t n); +uintptr_t wickra_yoyo_exit_warmup_period(struct YoyoExit *handle); + +bool wickra_yoyo_exit_is_ready(struct YoyoExit *handle); + void wickra_yoyo_exit_reset(struct YoyoExit *handle); void wickra_yoyo_exit_free(struct YoyoExit *handle); @@ -8273,6 +9697,10 @@ double wickra_amihud_illiquidity_update(struct AmihudIlliquidity *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_amihud_illiquidity_warmup_period(struct AmihudIlliquidity *handle); + +bool wickra_amihud_illiquidity_is_ready(struct AmihudIlliquidity *handle); + void wickra_amihud_illiquidity_reset(struct AmihudIlliquidity *handle); void wickra_amihud_illiquidity_free(struct AmihudIlliquidity *handle); @@ -8285,6 +9713,10 @@ double wickra_cumulative_volume_delta_update(struct CumulativeVolumeDelta *handl bool is_buy, int64_t timestamp); +uintptr_t wickra_cumulative_volume_delta_warmup_period(struct CumulativeVolumeDelta *handle); + +bool wickra_cumulative_volume_delta_is_ready(struct CumulativeVolumeDelta *handle); + void wickra_cumulative_volume_delta_reset(struct CumulativeVolumeDelta *handle); void wickra_cumulative_volume_delta_free(struct CumulativeVolumeDelta *handle); @@ -8297,6 +9729,10 @@ double wickra_pin_update(struct Pin *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_pin_warmup_period(struct Pin *handle); + +bool wickra_pin_is_ready(struct Pin *handle); + void wickra_pin_reset(struct Pin *handle); void wickra_pin_free(struct Pin *handle); @@ -8309,6 +9745,10 @@ double wickra_roll_measure_update(struct RollMeasure *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_roll_measure_warmup_period(struct RollMeasure *handle); + +bool wickra_roll_measure_is_ready(struct RollMeasure *handle); + void wickra_roll_measure_reset(struct RollMeasure *handle); void wickra_roll_measure_free(struct RollMeasure *handle); @@ -8321,6 +9761,10 @@ double wickra_signed_volume_update(struct SignedVolume *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_signed_volume_warmup_period(struct SignedVolume *handle); + +bool wickra_signed_volume_is_ready(struct SignedVolume *handle); + void wickra_signed_volume_reset(struct SignedVolume *handle); void wickra_signed_volume_free(struct SignedVolume *handle); @@ -8333,6 +9777,10 @@ double wickra_trade_imbalance_update(struct TradeImbalance *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_trade_imbalance_warmup_period(struct TradeImbalance *handle); + +bool wickra_trade_imbalance_is_ready(struct TradeImbalance *handle); + void wickra_trade_imbalance_reset(struct TradeImbalance *handle); void wickra_trade_imbalance_free(struct TradeImbalance *handle); @@ -8345,6 +9793,10 @@ double wickra_trade_sign_autocorrelation_update(struct TradeSignAutocorrelation bool is_buy, int64_t timestamp); +uintptr_t wickra_trade_sign_autocorrelation_warmup_period(struct TradeSignAutocorrelation *handle); + +bool wickra_trade_sign_autocorrelation_is_ready(struct TradeSignAutocorrelation *handle); + void wickra_trade_sign_autocorrelation_reset(struct TradeSignAutocorrelation *handle); void wickra_trade_sign_autocorrelation_free(struct TradeSignAutocorrelation *handle); @@ -8357,6 +9809,10 @@ double wickra_vpin_update(struct Vpin *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_vpin_warmup_period(struct Vpin *handle); + +bool wickra_vpin_is_ready(struct Vpin *handle); + void wickra_vpin_reset(struct Vpin *handle); void wickra_vpin_free(struct Vpin *handle); @@ -8370,6 +9826,10 @@ double wickra_effective_spread_update(struct EffectiveSpread *handle, int64_t timestamp, double mid); +uintptr_t wickra_effective_spread_warmup_period(struct EffectiveSpread *handle); + +bool wickra_effective_spread_is_ready(struct EffectiveSpread *handle); + void wickra_effective_spread_reset(struct EffectiveSpread *handle); void wickra_effective_spread_free(struct EffectiveSpread *handle); @@ -8383,6 +9843,10 @@ double wickra_kyles_lambda_update(struct KylesLambda *handle, int64_t timestamp, double mid); +uintptr_t wickra_kyles_lambda_warmup_period(struct KylesLambda *handle); + +bool wickra_kyles_lambda_is_ready(struct KylesLambda *handle); + void wickra_kyles_lambda_reset(struct KylesLambda *handle); void wickra_kyles_lambda_free(struct KylesLambda *handle); @@ -8396,6 +9860,10 @@ double wickra_realized_spread_update(struct RealizedSpread *handle, int64_t timestamp, double mid); +uintptr_t wickra_realized_spread_warmup_period(struct RealizedSpread *handle); + +bool wickra_realized_spread_is_ready(struct RealizedSpread *handle); + void wickra_realized_spread_reset(struct RealizedSpread *handle); void wickra_realized_spread_free(struct RealizedSpread *handle); @@ -8416,6 +9884,10 @@ double wickra_calendar_spread_update(struct CalendarSpread *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_calendar_spread_warmup_period(struct CalendarSpread *handle); + +bool wickra_calendar_spread_is_ready(struct CalendarSpread *handle); + void wickra_calendar_spread_reset(struct CalendarSpread *handle); void wickra_calendar_spread_free(struct CalendarSpread *handle); @@ -8436,6 +9908,10 @@ double wickra_estimated_leverage_ratio_update(struct EstimatedLeverageRatio *han double short_liquidation, int64_t timestamp); +uintptr_t wickra_estimated_leverage_ratio_warmup_period(struct EstimatedLeverageRatio *handle); + +bool wickra_estimated_leverage_ratio_is_ready(struct EstimatedLeverageRatio *handle); + void wickra_estimated_leverage_ratio_reset(struct EstimatedLeverageRatio *handle); void wickra_estimated_leverage_ratio_free(struct EstimatedLeverageRatio *handle); @@ -8456,6 +9932,10 @@ double wickra_funding_basis_update(struct FundingBasis *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_basis_warmup_period(struct FundingBasis *handle); + +bool wickra_funding_basis_is_ready(struct FundingBasis *handle); + void wickra_funding_basis_reset(struct FundingBasis *handle); void wickra_funding_basis_free(struct FundingBasis *handle); @@ -8476,6 +9956,10 @@ double wickra_funding_implied_apr_update(struct FundingImpliedApr *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_implied_apr_warmup_period(struct FundingImpliedApr *handle); + +bool wickra_funding_implied_apr_is_ready(struct FundingImpliedApr *handle); + void wickra_funding_implied_apr_reset(struct FundingImpliedApr *handle); void wickra_funding_implied_apr_free(struct FundingImpliedApr *handle); @@ -8496,6 +9980,10 @@ double wickra_funding_rate_update(struct FundingRate *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_rate_warmup_period(struct FundingRate *handle); + +bool wickra_funding_rate_is_ready(struct FundingRate *handle); + void wickra_funding_rate_reset(struct FundingRate *handle); void wickra_funding_rate_free(struct FundingRate *handle); @@ -8516,6 +10004,10 @@ double wickra_funding_rate_mean_update(struct FundingRateMean *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_rate_mean_warmup_period(struct FundingRateMean *handle); + +bool wickra_funding_rate_mean_is_ready(struct FundingRateMean *handle); + void wickra_funding_rate_mean_reset(struct FundingRateMean *handle); void wickra_funding_rate_mean_free(struct FundingRateMean *handle); @@ -8536,6 +10028,10 @@ double wickra_funding_rate_z_score_update(struct FundingRateZScore *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_rate_z_score_warmup_period(struct FundingRateZScore *handle); + +bool wickra_funding_rate_z_score_is_ready(struct FundingRateZScore *handle); + void wickra_funding_rate_z_score_reset(struct FundingRateZScore *handle); void wickra_funding_rate_z_score_free(struct FundingRateZScore *handle); @@ -8556,6 +10052,10 @@ double wickra_long_short_ratio_update(struct LongShortRatio *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_long_short_ratio_warmup_period(struct LongShortRatio *handle); + +bool wickra_long_short_ratio_is_ready(struct LongShortRatio *handle); + void wickra_long_short_ratio_reset(struct LongShortRatio *handle); void wickra_long_short_ratio_free(struct LongShortRatio *handle); @@ -8576,6 +10076,10 @@ double wickra_open_interest_delta_update(struct OpenInterestDelta *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_open_interest_delta_warmup_period(struct OpenInterestDelta *handle); + +bool wickra_open_interest_delta_is_ready(struct OpenInterestDelta *handle); + void wickra_open_interest_delta_reset(struct OpenInterestDelta *handle); void wickra_open_interest_delta_free(struct OpenInterestDelta *handle); @@ -8596,6 +10100,10 @@ double wickra_oi_price_divergence_update(struct OIPriceDivergence *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_oi_price_divergence_warmup_period(struct OIPriceDivergence *handle); + +bool wickra_oi_price_divergence_is_ready(struct OIPriceDivergence *handle); + void wickra_oi_price_divergence_reset(struct OIPriceDivergence *handle); void wickra_oi_price_divergence_free(struct OIPriceDivergence *handle); @@ -8616,6 +10124,10 @@ double wickra_oi_to_volume_ratio_update(struct OiToVolumeRatio *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_oi_to_volume_ratio_warmup_period(struct OiToVolumeRatio *handle); + +bool wickra_oi_to_volume_ratio_is_ready(struct OiToVolumeRatio *handle); + void wickra_oi_to_volume_ratio_reset(struct OiToVolumeRatio *handle); void wickra_oi_to_volume_ratio_free(struct OiToVolumeRatio *handle); @@ -8636,6 +10148,10 @@ double wickra_oi_weighted_update(struct OIWeighted *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_oi_weighted_warmup_period(struct OIWeighted *handle); + +bool wickra_oi_weighted_is_ready(struct OIWeighted *handle); + void wickra_oi_weighted_reset(struct OIWeighted *handle); void wickra_oi_weighted_free(struct OIWeighted *handle); @@ -8656,6 +10172,10 @@ double wickra_open_interest_momentum_update(struct OpenInterestMomentum *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_open_interest_momentum_warmup_period(struct OpenInterestMomentum *handle); + +bool wickra_open_interest_momentum_is_ready(struct OpenInterestMomentum *handle); + void wickra_open_interest_momentum_reset(struct OpenInterestMomentum *handle); void wickra_open_interest_momentum_free(struct OpenInterestMomentum *handle); @@ -8676,6 +10196,10 @@ double wickra_perpetual_premium_index_update(struct PerpetualPremiumIndex *handl double short_liquidation, int64_t timestamp); +uintptr_t wickra_perpetual_premium_index_warmup_period(struct PerpetualPremiumIndex *handle); + +bool wickra_perpetual_premium_index_is_ready(struct PerpetualPremiumIndex *handle); + void wickra_perpetual_premium_index_reset(struct PerpetualPremiumIndex *handle); void wickra_perpetual_premium_index_free(struct PerpetualPremiumIndex *handle); @@ -8696,6 +10220,10 @@ double wickra_taker_buy_sell_ratio_update(struct TakerBuySellRatio *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_taker_buy_sell_ratio_warmup_period(struct TakerBuySellRatio *handle); + +bool wickra_taker_buy_sell_ratio_is_ready(struct TakerBuySellRatio *handle); + void wickra_taker_buy_sell_ratio_reset(struct TakerBuySellRatio *handle); void wickra_taker_buy_sell_ratio_free(struct TakerBuySellRatio *handle); @@ -8716,6 +10244,10 @@ double wickra_term_structure_basis_update(struct TermStructureBasis *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_term_structure_basis_warmup_period(struct TermStructureBasis *handle); + +bool wickra_term_structure_basis_is_ready(struct TermStructureBasis *handle); + void wickra_term_structure_basis_reset(struct TermStructureBasis *handle); void wickra_term_structure_basis_free(struct TermStructureBasis *handle); @@ -8730,6 +10262,10 @@ double wickra_depth_slope_update(struct DepthSlope *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_depth_slope_warmup_period(struct DepthSlope *handle); + +bool wickra_depth_slope_is_ready(struct DepthSlope *handle); + void wickra_depth_slope_reset(struct DepthSlope *handle); void wickra_depth_slope_free(struct DepthSlope *handle); @@ -8744,6 +10280,10 @@ double wickra_microprice_update(struct Microprice *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_microprice_warmup_period(struct Microprice *handle); + +bool wickra_microprice_is_ready(struct Microprice *handle); + void wickra_microprice_reset(struct Microprice *handle); void wickra_microprice_free(struct Microprice *handle); @@ -8758,6 +10298,10 @@ double wickra_order_book_imbalance_full_update(struct OrderBookImbalanceFull *ha const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_book_imbalance_full_warmup_period(struct OrderBookImbalanceFull *handle); + +bool wickra_order_book_imbalance_full_is_ready(struct OrderBookImbalanceFull *handle); + void wickra_order_book_imbalance_full_reset(struct OrderBookImbalanceFull *handle); void wickra_order_book_imbalance_full_free(struct OrderBookImbalanceFull *handle); @@ -8772,6 +10316,10 @@ double wickra_order_book_imbalance_top1_update(struct OrderBookImbalanceTop1 *ha const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_book_imbalance_top1_warmup_period(struct OrderBookImbalanceTop1 *handle); + +bool wickra_order_book_imbalance_top1_is_ready(struct OrderBookImbalanceTop1 *handle); + void wickra_order_book_imbalance_top1_reset(struct OrderBookImbalanceTop1 *handle); void wickra_order_book_imbalance_top1_free(struct OrderBookImbalanceTop1 *handle); @@ -8786,6 +10334,10 @@ double wickra_order_book_imbalance_top_n_update(struct OrderBookImbalanceTopN *h const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_book_imbalance_top_n_warmup_period(struct OrderBookImbalanceTopN *handle); + +bool wickra_order_book_imbalance_top_n_is_ready(struct OrderBookImbalanceTopN *handle); + void wickra_order_book_imbalance_top_n_reset(struct OrderBookImbalanceTopN *handle); void wickra_order_book_imbalance_top_n_free(struct OrderBookImbalanceTopN *handle); @@ -8800,6 +10352,10 @@ double wickra_order_flow_imbalance_update(struct OrderFlowImbalance *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_flow_imbalance_warmup_period(struct OrderFlowImbalance *handle); + +bool wickra_order_flow_imbalance_is_ready(struct OrderFlowImbalance *handle); + void wickra_order_flow_imbalance_reset(struct OrderFlowImbalance *handle); void wickra_order_flow_imbalance_free(struct OrderFlowImbalance *handle); @@ -8814,6 +10370,10 @@ double wickra_quoted_spread_update(struct QuotedSpread *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_quoted_spread_warmup_period(struct QuotedSpread *handle); + +bool wickra_quoted_spread_is_ready(struct QuotedSpread *handle); + void wickra_quoted_spread_reset(struct QuotedSpread *handle); void wickra_quoted_spread_free(struct QuotedSpread *handle); @@ -8830,6 +10390,10 @@ double wickra_absolute_breadth_index_update(struct AbsoluteBreadthIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_absolute_breadth_index_warmup_period(struct AbsoluteBreadthIndex *handle); + +bool wickra_absolute_breadth_index_is_ready(struct AbsoluteBreadthIndex *handle); + void wickra_absolute_breadth_index_reset(struct AbsoluteBreadthIndex *handle); void wickra_absolute_breadth_index_free(struct AbsoluteBreadthIndex *handle); @@ -8846,6 +10410,10 @@ double wickra_ad_volume_line_update(struct AdVolumeLine *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_ad_volume_line_warmup_period(struct AdVolumeLine *handle); + +bool wickra_ad_volume_line_is_ready(struct AdVolumeLine *handle); + void wickra_ad_volume_line_reset(struct AdVolumeLine *handle); void wickra_ad_volume_line_free(struct AdVolumeLine *handle); @@ -8862,6 +10430,10 @@ double wickra_advance_decline_update(struct AdvanceDecline *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_advance_decline_warmup_period(struct AdvanceDecline *handle); + +bool wickra_advance_decline_is_ready(struct AdvanceDecline *handle); + void wickra_advance_decline_reset(struct AdvanceDecline *handle); void wickra_advance_decline_free(struct AdvanceDecline *handle); @@ -8878,6 +10450,10 @@ double wickra_advance_decline_ratio_update(struct AdvanceDeclineRatio *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_advance_decline_ratio_warmup_period(struct AdvanceDeclineRatio *handle); + +bool wickra_advance_decline_ratio_is_ready(struct AdvanceDeclineRatio *handle); + void wickra_advance_decline_ratio_reset(struct AdvanceDeclineRatio *handle); void wickra_advance_decline_ratio_free(struct AdvanceDeclineRatio *handle); @@ -8894,6 +10470,10 @@ double wickra_breadth_thrust_update(struct BreadthThrust *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_breadth_thrust_warmup_period(struct BreadthThrust *handle); + +bool wickra_breadth_thrust_is_ready(struct BreadthThrust *handle); + void wickra_breadth_thrust_reset(struct BreadthThrust *handle); void wickra_breadth_thrust_free(struct BreadthThrust *handle); @@ -8910,6 +10490,10 @@ double wickra_bullish_percent_index_update(struct BullishPercentIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_bullish_percent_index_warmup_period(struct BullishPercentIndex *handle); + +bool wickra_bullish_percent_index_is_ready(struct BullishPercentIndex *handle); + void wickra_bullish_percent_index_reset(struct BullishPercentIndex *handle); void wickra_bullish_percent_index_free(struct BullishPercentIndex *handle); @@ -8926,6 +10510,10 @@ double wickra_cumulative_volume_index_update(struct CumulativeVolumeIndex *handl uintptr_t n, int64_t timestamp); +uintptr_t wickra_cumulative_volume_index_warmup_period(struct CumulativeVolumeIndex *handle); + +bool wickra_cumulative_volume_index_is_ready(struct CumulativeVolumeIndex *handle); + void wickra_cumulative_volume_index_reset(struct CumulativeVolumeIndex *handle); void wickra_cumulative_volume_index_free(struct CumulativeVolumeIndex *handle); @@ -8942,6 +10530,10 @@ double wickra_high_low_index_update(struct HighLowIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_high_low_index_warmup_period(struct HighLowIndex *handle); + +bool wickra_high_low_index_is_ready(struct HighLowIndex *handle); + void wickra_high_low_index_reset(struct HighLowIndex *handle); void wickra_high_low_index_free(struct HighLowIndex *handle); @@ -8958,6 +10550,10 @@ double wickra_mc_clellan_oscillator_update(struct McClellanOscillator *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_mc_clellan_oscillator_warmup_period(struct McClellanOscillator *handle); + +bool wickra_mc_clellan_oscillator_is_ready(struct McClellanOscillator *handle); + void wickra_mc_clellan_oscillator_reset(struct McClellanOscillator *handle); void wickra_mc_clellan_oscillator_free(struct McClellanOscillator *handle); @@ -8974,6 +10570,10 @@ double wickra_mc_clellan_summation_index_update(struct McClellanSummationIndex * uintptr_t n, int64_t timestamp); +uintptr_t wickra_mc_clellan_summation_index_warmup_period(struct McClellanSummationIndex *handle); + +bool wickra_mc_clellan_summation_index_is_ready(struct McClellanSummationIndex *handle); + void wickra_mc_clellan_summation_index_reset(struct McClellanSummationIndex *handle); void wickra_mc_clellan_summation_index_free(struct McClellanSummationIndex *handle); @@ -8990,6 +10590,10 @@ double wickra_new_highs_new_lows_update(struct NewHighsNewLows *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_new_highs_new_lows_warmup_period(struct NewHighsNewLows *handle); + +bool wickra_new_highs_new_lows_is_ready(struct NewHighsNewLows *handle); + void wickra_new_highs_new_lows_reset(struct NewHighsNewLows *handle); void wickra_new_highs_new_lows_free(struct NewHighsNewLows *handle); @@ -9006,6 +10610,10 @@ double wickra_percent_above_ma_update(struct PercentAboveMa *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_percent_above_ma_warmup_period(struct PercentAboveMa *handle); + +bool wickra_percent_above_ma_is_ready(struct PercentAboveMa *handle); + void wickra_percent_above_ma_reset(struct PercentAboveMa *handle); void wickra_percent_above_ma_free(struct PercentAboveMa *handle); @@ -9022,6 +10630,10 @@ double wickra_tick_index_update(struct TickIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_tick_index_warmup_period(struct TickIndex *handle); + +bool wickra_tick_index_is_ready(struct TickIndex *handle); + void wickra_tick_index_reset(struct TickIndex *handle); void wickra_tick_index_free(struct TickIndex *handle); @@ -9038,6 +10650,10 @@ double wickra_trin_update(struct Trin *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_trin_warmup_period(struct Trin *handle); + +bool wickra_trin_is_ready(struct Trin *handle); + void wickra_trin_reset(struct Trin *handle); void wickra_trin_free(struct Trin *handle); @@ -9054,6 +10670,10 @@ double wickra_up_down_volume_ratio_update(struct UpDownVolumeRatio *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_up_down_volume_ratio_warmup_period(struct UpDownVolumeRatio *handle); + +bool wickra_up_down_volume_ratio_is_ready(struct UpDownVolumeRatio *handle); + void wickra_up_down_volume_ratio_reset(struct UpDownVolumeRatio *handle); void wickra_up_down_volume_ratio_free(struct UpDownVolumeRatio *handle); @@ -9069,6 +10689,10 @@ bool wickra_acceleration_bands_update(struct AccelerationBands *handle, int64_t timestamp, struct WickraAccelerationBandsOutput *out); +uintptr_t wickra_acceleration_bands_warmup_period(struct AccelerationBands *handle); + +bool wickra_acceleration_bands_is_ready(struct AccelerationBands *handle); + void wickra_acceleration_bands_reset(struct AccelerationBands *handle); void wickra_acceleration_bands_free(struct AccelerationBands *handle); @@ -9084,6 +10708,10 @@ bool wickra_adx_update(struct Adx *handle, int64_t timestamp, struct WickraAdxOutput *out); +uintptr_t wickra_adx_warmup_period(struct Adx *handle); + +bool wickra_adx_is_ready(struct Adx *handle); + void wickra_adx_reset(struct Adx *handle); void wickra_adx_free(struct Adx *handle); @@ -9101,6 +10729,10 @@ bool wickra_alligator_update(struct Alligator *handle, int64_t timestamp, struct WickraAlligatorOutput *out); +uintptr_t wickra_alligator_warmup_period(struct Alligator *handle); + +bool wickra_alligator_is_ready(struct Alligator *handle); + void wickra_alligator_reset(struct Alligator *handle); void wickra_alligator_free(struct Alligator *handle); @@ -9116,6 +10748,10 @@ bool wickra_andrews_pitchfork_update(struct AndrewsPitchfork *handle, int64_t timestamp, struct WickraAndrewsPitchforkOutput *out); +uintptr_t wickra_andrews_pitchfork_warmup_period(struct AndrewsPitchfork *handle); + +bool wickra_andrews_pitchfork_is_ready(struct AndrewsPitchfork *handle); + void wickra_andrews_pitchfork_reset(struct AndrewsPitchfork *handle); void wickra_andrews_pitchfork_free(struct AndrewsPitchfork *handle); @@ -9131,6 +10767,10 @@ bool wickra_aroon_update(struct Aroon *handle, int64_t timestamp, struct WickraAroonOutput *out); +uintptr_t wickra_aroon_warmup_period(struct Aroon *handle); + +bool wickra_aroon_is_ready(struct Aroon *handle); + void wickra_aroon_reset(struct Aroon *handle); void wickra_aroon_free(struct Aroon *handle); @@ -9146,6 +10786,10 @@ bool wickra_atr_bands_update(struct AtrBands *handle, int64_t timestamp, struct WickraAtrBandsOutput *out); +uintptr_t wickra_atr_bands_warmup_period(struct AtrBands *handle); + +bool wickra_atr_bands_is_ready(struct AtrBands *handle); + void wickra_atr_bands_reset(struct AtrBands *handle); void wickra_atr_bands_free(struct AtrBands *handle); @@ -9163,6 +10807,10 @@ bool wickra_atr_ratchet_update(struct AtrRatchet *handle, int64_t timestamp, struct WickraAtrRatchetOutput *out); +uintptr_t wickra_atr_ratchet_warmup_period(struct AtrRatchet *handle); + +bool wickra_atr_ratchet_is_ready(struct AtrRatchet *handle); + void wickra_atr_ratchet_reset(struct AtrRatchet *handle); void wickra_atr_ratchet_free(struct AtrRatchet *handle); @@ -9178,6 +10826,10 @@ bool wickra_auto_fib_update(struct AutoFib *handle, int64_t timestamp, struct WickraAutoFibOutput *out); +uintptr_t wickra_auto_fib_warmup_period(struct AutoFib *handle); + +bool wickra_auto_fib_is_ready(struct AutoFib *handle); + void wickra_auto_fib_reset(struct AutoFib *handle); void wickra_auto_fib_free(struct AutoFib *handle); @@ -9188,6 +10840,10 @@ bool wickra_bollinger_bands_update(struct BollingerBands *handle, double value, struct WickraBollingerOutput *out); +uintptr_t wickra_bollinger_bands_warmup_period(struct BollingerBands *handle); + +bool wickra_bollinger_bands_is_ready(struct BollingerBands *handle); + void wickra_bollinger_bands_reset(struct BollingerBands *handle); void wickra_bollinger_bands_free(struct BollingerBands *handle); @@ -9198,6 +10854,10 @@ bool wickra_bomar_bands_update(struct BomarBands *handle, double value, struct WickraBomarBandsOutput *out); +uintptr_t wickra_bomar_bands_warmup_period(struct BomarBands *handle); + +bool wickra_bomar_bands_is_ready(struct BomarBands *handle); + void wickra_bomar_bands_reset(struct BomarBands *handle); void wickra_bomar_bands_free(struct BomarBands *handle); @@ -9213,6 +10873,10 @@ bool wickra_camarilla_update(struct Camarilla *handle, int64_t timestamp, struct WickraCamarillaPivotsOutput *out); +uintptr_t wickra_camarilla_warmup_period(struct Camarilla *handle); + +bool wickra_camarilla_is_ready(struct Camarilla *handle); + void wickra_camarilla_reset(struct Camarilla *handle); void wickra_camarilla_free(struct Camarilla *handle); @@ -9228,6 +10892,10 @@ bool wickra_candle_volume_update(struct CandleVolume *handle, int64_t timestamp, struct WickraCandleVolumeOutput *out); +uintptr_t wickra_candle_volume_warmup_period(struct CandleVolume *handle); + +bool wickra_candle_volume_is_ready(struct CandleVolume *handle); + void wickra_candle_volume_reset(struct CandleVolume *handle); void wickra_candle_volume_free(struct CandleVolume *handle); @@ -9243,6 +10911,10 @@ bool wickra_central_pivot_range_update(struct CentralPivotRange *handle, int64_t timestamp, struct WickraCentralPivotRangeOutput *out); +uintptr_t wickra_central_pivot_range_warmup_period(struct CentralPivotRange *handle); + +bool wickra_central_pivot_range_is_ready(struct CentralPivotRange *handle); + void wickra_central_pivot_range_reset(struct CentralPivotRange *handle); void wickra_central_pivot_range_free(struct CentralPivotRange *handle); @@ -9260,6 +10932,10 @@ bool wickra_chande_kroll_stop_update(struct ChandeKrollStop *handle, int64_t timestamp, struct WickraChandeKrollStopOutput *out); +uintptr_t wickra_chande_kroll_stop_warmup_period(struct ChandeKrollStop *handle); + +bool wickra_chande_kroll_stop_is_ready(struct ChandeKrollStop *handle); + void wickra_chande_kroll_stop_reset(struct ChandeKrollStop *handle); void wickra_chande_kroll_stop_free(struct ChandeKrollStop *handle); @@ -9275,6 +10951,10 @@ bool wickra_chandelier_exit_update(struct ChandelierExit *handle, int64_t timestamp, struct WickraChandelierExitOutput *out); +uintptr_t wickra_chandelier_exit_warmup_period(struct ChandelierExit *handle); + +bool wickra_chandelier_exit_is_ready(struct ChandelierExit *handle); + void wickra_chandelier_exit_reset(struct ChandelierExit *handle); void wickra_chandelier_exit_free(struct ChandelierExit *handle); @@ -9290,6 +10970,10 @@ bool wickra_classic_pivots_update(struct ClassicPivots *handle, int64_t timestamp, struct WickraClassicPivotsOutput *out); +uintptr_t wickra_classic_pivots_warmup_period(struct ClassicPivots *handle); + +bool wickra_classic_pivots_is_ready(struct ClassicPivots *handle); + void wickra_classic_pivots_reset(struct ClassicPivots *handle); void wickra_classic_pivots_free(struct ClassicPivots *handle); @@ -9301,6 +10985,10 @@ bool wickra_cointegration_update(struct Cointegration *handle, double y, struct WickraCointegrationOutput *out); +uintptr_t wickra_cointegration_warmup_period(struct Cointegration *handle); + +bool wickra_cointegration_is_ready(struct Cointegration *handle); + void wickra_cointegration_reset(struct Cointegration *handle); void wickra_cointegration_free(struct Cointegration *handle); @@ -9318,6 +11006,10 @@ bool wickra_composite_profile_update(struct CompositeProfile *handle, int64_t timestamp, struct WickraCompositeProfileOutput *out); +uintptr_t wickra_composite_profile_warmup_period(struct CompositeProfile *handle); + +bool wickra_composite_profile_is_ready(struct CompositeProfile *handle); + void wickra_composite_profile_reset(struct CompositeProfile *handle); void wickra_composite_profile_free(struct CompositeProfile *handle); @@ -9333,6 +11025,10 @@ bool wickra_demark_pivots_update(struct DemarkPivots *handle, int64_t timestamp, struct WickraDemarkPivotsOutput *out); +uintptr_t wickra_demark_pivots_warmup_period(struct DemarkPivots *handle); + +bool wickra_demark_pivots_is_ready(struct DemarkPivots *handle); + void wickra_demark_pivots_reset(struct DemarkPivots *handle); void wickra_demark_pivots_free(struct DemarkPivots *handle); @@ -9348,6 +11044,10 @@ bool wickra_donchian_update(struct Donchian *handle, int64_t timestamp, struct WickraDonchianOutput *out); +uintptr_t wickra_donchian_warmup_period(struct Donchian *handle); + +bool wickra_donchian_is_ready(struct Donchian *handle); + void wickra_donchian_reset(struct Donchian *handle); void wickra_donchian_free(struct Donchian *handle); @@ -9363,6 +11063,10 @@ bool wickra_donchian_stop_update(struct DonchianStop *handle, int64_t timestamp, struct WickraDonchianStopOutput *out); +uintptr_t wickra_donchian_stop_warmup_period(struct DonchianStop *handle); + +bool wickra_donchian_stop_is_ready(struct DonchianStop *handle); + void wickra_donchian_stop_reset(struct DonchianStop *handle); void wickra_donchian_stop_free(struct DonchianStop *handle); @@ -9375,6 +11079,10 @@ bool wickra_double_bollinger_update(struct DoubleBollinger *handle, double value, struct WickraDoubleBollingerOutput *out); +uintptr_t wickra_double_bollinger_warmup_period(struct DoubleBollinger *handle); + +bool wickra_double_bollinger_is_ready(struct DoubleBollinger *handle); + void wickra_double_bollinger_reset(struct DoubleBollinger *handle); void wickra_double_bollinger_free(struct DoubleBollinger *handle); @@ -9390,6 +11098,10 @@ bool wickra_elder_ray_update(struct ElderRay *handle, int64_t timestamp, struct WickraElderRayOutput *out); +uintptr_t wickra_elder_ray_warmup_period(struct ElderRay *handle); + +bool wickra_elder_ray_is_ready(struct ElderRay *handle); + void wickra_elder_ray_reset(struct ElderRay *handle); void wickra_elder_ray_free(struct ElderRay *handle); @@ -9405,6 +11117,10 @@ bool wickra_elder_safe_zone_update(struct ElderSafeZone *handle, int64_t timestamp, struct WickraElderSafeZoneOutput *out); +uintptr_t wickra_elder_safe_zone_warmup_period(struct ElderSafeZone *handle); + +bool wickra_elder_safe_zone_is_ready(struct ElderSafeZone *handle); + void wickra_elder_safe_zone_reset(struct ElderSafeZone *handle); void wickra_elder_safe_zone_free(struct ElderSafeZone *handle); @@ -9420,6 +11136,10 @@ bool wickra_equivolume_update(struct Equivolume *handle, int64_t timestamp, struct WickraEquivolumeOutput *out); +uintptr_t wickra_equivolume_warmup_period(struct Equivolume *handle); + +bool wickra_equivolume_is_ready(struct Equivolume *handle); + void wickra_equivolume_reset(struct Equivolume *handle); void wickra_equivolume_free(struct Equivolume *handle); @@ -9435,6 +11155,10 @@ bool wickra_fib_arcs_update(struct FibArcs *handle, int64_t timestamp, struct WickraFibArcsOutput *out); +uintptr_t wickra_fib_arcs_warmup_period(struct FibArcs *handle); + +bool wickra_fib_arcs_is_ready(struct FibArcs *handle); + void wickra_fib_arcs_reset(struct FibArcs *handle); void wickra_fib_arcs_free(struct FibArcs *handle); @@ -9450,6 +11174,10 @@ bool wickra_fib_channel_update(struct FibChannel *handle, int64_t timestamp, struct WickraFibChannelOutput *out); +uintptr_t wickra_fib_channel_warmup_period(struct FibChannel *handle); + +bool wickra_fib_channel_is_ready(struct FibChannel *handle); + void wickra_fib_channel_reset(struct FibChannel *handle); void wickra_fib_channel_free(struct FibChannel *handle); @@ -9465,6 +11193,10 @@ bool wickra_fib_confluence_update(struct FibConfluence *handle, int64_t timestamp, struct WickraFibConfluenceOutput *out); +uintptr_t wickra_fib_confluence_warmup_period(struct FibConfluence *handle); + +bool wickra_fib_confluence_is_ready(struct FibConfluence *handle); + void wickra_fib_confluence_reset(struct FibConfluence *handle); void wickra_fib_confluence_free(struct FibConfluence *handle); @@ -9480,6 +11212,10 @@ bool wickra_fib_extension_update(struct FibExtension *handle, int64_t timestamp, struct WickraFibExtensionOutput *out); +uintptr_t wickra_fib_extension_warmup_period(struct FibExtension *handle); + +bool wickra_fib_extension_is_ready(struct FibExtension *handle); + void wickra_fib_extension_reset(struct FibExtension *handle); void wickra_fib_extension_free(struct FibExtension *handle); @@ -9495,6 +11231,10 @@ bool wickra_fib_fan_update(struct FibFan *handle, int64_t timestamp, struct WickraFibFanOutput *out); +uintptr_t wickra_fib_fan_warmup_period(struct FibFan *handle); + +bool wickra_fib_fan_is_ready(struct FibFan *handle); + void wickra_fib_fan_reset(struct FibFan *handle); void wickra_fib_fan_free(struct FibFan *handle); @@ -9510,6 +11250,10 @@ bool wickra_fib_projection_update(struct FibProjection *handle, int64_t timestamp, struct WickraFibProjectionOutput *out); +uintptr_t wickra_fib_projection_warmup_period(struct FibProjection *handle); + +bool wickra_fib_projection_is_ready(struct FibProjection *handle); + void wickra_fib_projection_reset(struct FibProjection *handle); void wickra_fib_projection_free(struct FibProjection *handle); @@ -9525,6 +11269,10 @@ bool wickra_fib_retracement_update(struct FibRetracement *handle, int64_t timestamp, struct WickraFibRetracementOutput *out); +uintptr_t wickra_fib_retracement_warmup_period(struct FibRetracement *handle); + +bool wickra_fib_retracement_is_ready(struct FibRetracement *handle); + void wickra_fib_retracement_reset(struct FibRetracement *handle); void wickra_fib_retracement_free(struct FibRetracement *handle); @@ -9540,6 +11288,10 @@ bool wickra_fib_time_zones_update(struct FibTimeZones *handle, int64_t timestamp, struct WickraFibTimeZonesOutput *out); +uintptr_t wickra_fib_time_zones_warmup_period(struct FibTimeZones *handle); + +bool wickra_fib_time_zones_is_ready(struct FibTimeZones *handle); + void wickra_fib_time_zones_reset(struct FibTimeZones *handle); void wickra_fib_time_zones_free(struct FibTimeZones *handle); @@ -9555,6 +11307,10 @@ bool wickra_fibonacci_pivots_update(struct FibonacciPivots *handle, int64_t timestamp, struct WickraFibonacciPivotsOutput *out); +uintptr_t wickra_fibonacci_pivots_warmup_period(struct FibonacciPivots *handle); + +bool wickra_fibonacci_pivots_is_ready(struct FibonacciPivots *handle); + void wickra_fibonacci_pivots_reset(struct FibonacciPivots *handle); void wickra_fibonacci_pivots_free(struct FibonacciPivots *handle); @@ -9570,6 +11326,10 @@ bool wickra_fractal_chaos_bands_update(struct FractalChaosBands *handle, int64_t timestamp, struct WickraFractalChaosBandsOutput *out); +uintptr_t wickra_fractal_chaos_bands_warmup_period(struct FractalChaosBands *handle); + +bool wickra_fractal_chaos_bands_is_ready(struct FractalChaosBands *handle); + void wickra_fractal_chaos_bands_reset(struct FractalChaosBands *handle); void wickra_fractal_chaos_bands_free(struct FractalChaosBands *handle); @@ -9587,6 +11347,10 @@ bool wickra_gator_oscillator_update(struct GatorOscillator *handle, int64_t timestamp, struct WickraGatorOscillatorOutput *out); +uintptr_t wickra_gator_oscillator_warmup_period(struct GatorOscillator *handle); + +bool wickra_gator_oscillator_is_ready(struct GatorOscillator *handle); + void wickra_gator_oscillator_reset(struct GatorOscillator *handle); void wickra_gator_oscillator_free(struct GatorOscillator *handle); @@ -9602,6 +11366,10 @@ bool wickra_golden_pocket_update(struct GoldenPocket *handle, int64_t timestamp, struct WickraGoldenPocketOutput *out); +uintptr_t wickra_golden_pocket_warmup_period(struct GoldenPocket *handle); + +bool wickra_golden_pocket_is_ready(struct GoldenPocket *handle); + void wickra_golden_pocket_reset(struct GoldenPocket *handle); void wickra_golden_pocket_free(struct GoldenPocket *handle); @@ -9617,6 +11385,10 @@ bool wickra_heikin_ashi_update(struct HeikinAshi *handle, int64_t timestamp, struct WickraHeikinAshiOutput *out); +uintptr_t wickra_heikin_ashi_warmup_period(struct HeikinAshi *handle); + +bool wickra_heikin_ashi_is_ready(struct HeikinAshi *handle); + void wickra_heikin_ashi_reset(struct HeikinAshi *handle); void wickra_heikin_ashi_free(struct HeikinAshi *handle); @@ -9632,6 +11404,10 @@ bool wickra_high_low_volume_nodes_update(struct HighLowVolumeNodes *handle, int64_t timestamp, struct WickraHighLowVolumeNodesOutput *out); +uintptr_t wickra_high_low_volume_nodes_warmup_period(struct HighLowVolumeNodes *handle); + +bool wickra_high_low_volume_nodes_is_ready(struct HighLowVolumeNodes *handle); + void wickra_high_low_volume_nodes_reset(struct HighLowVolumeNodes *handle); void wickra_high_low_volume_nodes_free(struct HighLowVolumeNodes *handle); @@ -9642,6 +11418,10 @@ bool wickra_ht_phasor_update(struct HtPhasor *handle, double value, struct WickraHtPhasorOutput *out); +uintptr_t wickra_ht_phasor_warmup_period(struct HtPhasor *handle); + +bool wickra_ht_phasor_is_ready(struct HtPhasor *handle); + void wickra_ht_phasor_reset(struct HtPhasor *handle); void wickra_ht_phasor_free(struct HtPhasor *handle); @@ -9657,6 +11437,10 @@ bool wickra_hurst_channel_update(struct HurstChannel *handle, int64_t timestamp, struct WickraHurstChannelOutput *out); +uintptr_t wickra_hurst_channel_warmup_period(struct HurstChannel *handle); + +bool wickra_hurst_channel_is_ready(struct HurstChannel *handle); + void wickra_hurst_channel_reset(struct HurstChannel *handle); void wickra_hurst_channel_free(struct HurstChannel *handle); @@ -9675,6 +11459,10 @@ bool wickra_ichimoku_update(struct Ichimoku *handle, int64_t timestamp, struct WickraIchimokuOutput *out); +uintptr_t wickra_ichimoku_warmup_period(struct Ichimoku *handle); + +bool wickra_ichimoku_is_ready(struct Ichimoku *handle); + void wickra_ichimoku_reset(struct Ichimoku *handle); void wickra_ichimoku_free(struct Ichimoku *handle); @@ -9690,6 +11478,10 @@ bool wickra_initial_balance_update(struct InitialBalance *handle, int64_t timestamp, struct WickraInitialBalanceOutput *out); +uintptr_t wickra_initial_balance_warmup_period(struct InitialBalance *handle); + +bool wickra_initial_balance_is_ready(struct InitialBalance *handle); + void wickra_initial_balance_reset(struct InitialBalance *handle); void wickra_initial_balance_free(struct InitialBalance *handle); @@ -9701,6 +11493,10 @@ bool wickra_kalman_hedge_ratio_update(struct KalmanHedgeRatio *handle, double y, struct WickraKalmanHedgeRatioOutput *out); +uintptr_t wickra_kalman_hedge_ratio_warmup_period(struct KalmanHedgeRatio *handle); + +bool wickra_kalman_hedge_ratio_is_ready(struct KalmanHedgeRatio *handle); + void wickra_kalman_hedge_ratio_reset(struct KalmanHedgeRatio *handle); void wickra_kalman_hedge_ratio_free(struct KalmanHedgeRatio *handle); @@ -9716,6 +11512,10 @@ bool wickra_kase_dev_stop_update(struct KaseDevStop *handle, int64_t timestamp, struct WickraKaseDevStopOutput *out); +uintptr_t wickra_kase_dev_stop_warmup_period(struct KaseDevStop *handle); + +bool wickra_kase_dev_stop_is_ready(struct KaseDevStop *handle); + void wickra_kase_dev_stop_reset(struct KaseDevStop *handle); void wickra_kase_dev_stop_free(struct KaseDevStop *handle); @@ -9732,6 +11532,10 @@ bool wickra_kase_permission_stochastic_update(struct KasePermissionStochastic *h int64_t timestamp, struct WickraKasePermissionStochasticOutput *out); +uintptr_t wickra_kase_permission_stochastic_warmup_period(struct KasePermissionStochastic *handle); + +bool wickra_kase_permission_stochastic_is_ready(struct KasePermissionStochastic *handle); + void wickra_kase_permission_stochastic_reset(struct KasePermissionStochastic *handle); void wickra_kase_permission_stochastic_free(struct KasePermissionStochastic *handle); @@ -9747,6 +11551,10 @@ bool wickra_keltner_update(struct Keltner *handle, int64_t timestamp, struct WickraKeltnerOutput *out); +uintptr_t wickra_keltner_warmup_period(struct Keltner *handle); + +bool wickra_keltner_is_ready(struct Keltner *handle); + void wickra_keltner_reset(struct Keltner *handle); void wickra_keltner_free(struct Keltner *handle); @@ -9763,6 +11571,10 @@ struct Kst *wickra_kst_new(uintptr_t roc1, bool wickra_kst_update(struct Kst *handle, double value, struct WickraKstOutput *out); +uintptr_t wickra_kst_warmup_period(struct Kst *handle); + +bool wickra_kst_is_ready(struct Kst *handle); + void wickra_kst_reset(struct Kst *handle); void wickra_kst_free(struct Kst *handle); @@ -9775,6 +11587,10 @@ bool wickra_lead_lag_cross_correlation_update(struct LeadLagCrossCorrelation *ha double y, struct WickraLeadLagCrossCorrelationOutput *out); +uintptr_t wickra_lead_lag_cross_correlation_warmup_period(struct LeadLagCrossCorrelation *handle); + +bool wickra_lead_lag_cross_correlation_is_ready(struct LeadLagCrossCorrelation *handle); + void wickra_lead_lag_cross_correlation_reset(struct LeadLagCrossCorrelation *handle); void wickra_lead_lag_cross_correlation_free(struct LeadLagCrossCorrelation *handle); @@ -9785,6 +11601,10 @@ bool wickra_lin_reg_channel_update(struct LinRegChannel *handle, double value, struct WickraLinRegChannelOutput *out); +uintptr_t wickra_lin_reg_channel_warmup_period(struct LinRegChannel *handle); + +bool wickra_lin_reg_channel_is_ready(struct LinRegChannel *handle); + void wickra_lin_reg_channel_reset(struct LinRegChannel *handle); void wickra_lin_reg_channel_free(struct LinRegChannel *handle); @@ -9806,6 +11626,10 @@ bool wickra_liquidation_features_update(struct LiquidationFeatures *handle, int64_t timestamp, struct WickraLiquidationFeaturesOutput *out); +uintptr_t wickra_liquidation_features_warmup_period(struct LiquidationFeatures *handle); + +bool wickra_liquidation_features_is_ready(struct LiquidationFeatures *handle); + void wickra_liquidation_features_reset(struct LiquidationFeatures *handle); void wickra_liquidation_features_free(struct LiquidationFeatures *handle); @@ -9816,6 +11640,10 @@ bool wickra_ma_envelope_update(struct MaEnvelope *handle, double value, struct WickraMaEnvelopeOutput *out); +uintptr_t wickra_ma_envelope_warmup_period(struct MaEnvelope *handle); + +bool wickra_ma_envelope_is_ready(struct MaEnvelope *handle); + void wickra_ma_envelope_reset(struct MaEnvelope *handle); void wickra_ma_envelope_free(struct MaEnvelope *handle); @@ -9826,6 +11654,10 @@ bool wickra_macd_indicator_update(struct MacdIndicator *handle, double value, struct WickraMacdOutput *out); +uintptr_t wickra_macd_indicator_warmup_period(struct MacdIndicator *handle); + +bool wickra_macd_indicator_is_ready(struct MacdIndicator *handle); + void wickra_macd_indicator_reset(struct MacdIndicator *handle); void wickra_macd_indicator_free(struct MacdIndicator *handle); @@ -9834,6 +11666,10 @@ struct MacdFix *wickra_macd_fix_new(uintptr_t signal); bool wickra_macd_fix_update(struct MacdFix *handle, double value, struct WickraMacdOutput *out); +uintptr_t wickra_macd_fix_warmup_period(struct MacdFix *handle); + +bool wickra_macd_fix_is_ready(struct MacdFix *handle); + void wickra_macd_fix_reset(struct MacdFix *handle); void wickra_macd_fix_free(struct MacdFix *handle); @@ -9842,6 +11678,10 @@ struct Mama *wickra_mama_new(double fast_limit, double slow_limit); bool wickra_mama_update(struct Mama *handle, double value, struct WickraMamaOutput *out); +uintptr_t wickra_mama_warmup_period(struct Mama *handle); + +bool wickra_mama_is_ready(struct Mama *handle); + void wickra_mama_reset(struct Mama *handle); void wickra_mama_free(struct Mama *handle); @@ -9852,6 +11692,10 @@ bool wickra_median_channel_update(struct MedianChannel *handle, double value, struct WickraMedianChannelOutput *out); +uintptr_t wickra_median_channel_warmup_period(struct MedianChannel *handle); + +bool wickra_median_channel_is_ready(struct MedianChannel *handle); + void wickra_median_channel_reset(struct MedianChannel *handle); void wickra_median_channel_free(struct MedianChannel *handle); @@ -9867,6 +11711,10 @@ bool wickra_modified_ma_stop_update(struct ModifiedMaStop *handle, int64_t timestamp, struct WickraModifiedMaStopOutput *out); +uintptr_t wickra_modified_ma_stop_warmup_period(struct ModifiedMaStop *handle); + +bool wickra_modified_ma_stop_is_ready(struct ModifiedMaStop *handle); + void wickra_modified_ma_stop_reset(struct ModifiedMaStop *handle); void wickra_modified_ma_stop_free(struct ModifiedMaStop *handle); @@ -9882,6 +11730,10 @@ bool wickra_murrey_math_lines_update(struct MurreyMathLines *handle, int64_t timestamp, struct WickraMurreyMathLinesOutput *out); +uintptr_t wickra_murrey_math_lines_warmup_period(struct MurreyMathLines *handle); + +bool wickra_murrey_math_lines_is_ready(struct MurreyMathLines *handle); + void wickra_murrey_math_lines_reset(struct MurreyMathLines *handle); void wickra_murrey_math_lines_free(struct MurreyMathLines *handle); @@ -9897,6 +11749,10 @@ bool wickra_nrtr_update(struct Nrtr *handle, int64_t timestamp, struct WickraNrtrOutput *out); +uintptr_t wickra_nrtr_warmup_period(struct Nrtr *handle); + +bool wickra_nrtr_is_ready(struct Nrtr *handle); + void wickra_nrtr_reset(struct Nrtr *handle); void wickra_nrtr_free(struct Nrtr *handle); @@ -9912,6 +11768,10 @@ bool wickra_opening_range_update(struct OpeningRange *handle, int64_t timestamp, struct WickraOpeningRangeOutput *out); +uintptr_t wickra_opening_range_warmup_period(struct OpeningRange *handle); + +bool wickra_opening_range_is_ready(struct OpeningRange *handle); + void wickra_opening_range_reset(struct OpeningRange *handle); void wickra_opening_range_free(struct OpeningRange *handle); @@ -9927,6 +11787,10 @@ bool wickra_overnight_intraday_return_update(struct OvernightIntradayReturn *han int64_t timestamp, struct WickraOvernightIntradayReturnOutput *out); +uintptr_t wickra_overnight_intraday_return_warmup_period(struct OvernightIntradayReturn *handle); + +bool wickra_overnight_intraday_return_is_ready(struct OvernightIntradayReturn *handle); + void wickra_overnight_intraday_return_reset(struct OvernightIntradayReturn *handle); void wickra_overnight_intraday_return_free(struct OvernightIntradayReturn *handle); @@ -9942,6 +11806,10 @@ bool wickra_projection_bands_update(struct ProjectionBands *handle, int64_t timestamp, struct WickraProjectionBandsOutput *out); +uintptr_t wickra_projection_bands_warmup_period(struct ProjectionBands *handle); + +bool wickra_projection_bands_is_ready(struct ProjectionBands *handle); + void wickra_projection_bands_reset(struct ProjectionBands *handle); void wickra_projection_bands_free(struct ProjectionBands *handle); @@ -9950,6 +11818,10 @@ struct Qqe *wickra_qqe_new(uintptr_t rsi_period, uintptr_t smoothing, double fac bool wickra_qqe_update(struct Qqe *handle, double value, struct WickraQqeOutput *out); +uintptr_t wickra_qqe_warmup_period(struct Qqe *handle); + +bool wickra_qqe_is_ready(struct Qqe *handle); + void wickra_qqe_reset(struct Qqe *handle); void wickra_qqe_free(struct Qqe *handle); @@ -9960,6 +11832,10 @@ bool wickra_quartile_bands_update(struct QuartileBands *handle, double value, struct WickraQuartileBandsOutput *out); +uintptr_t wickra_quartile_bands_warmup_period(struct QuartileBands *handle); + +bool wickra_quartile_bands_is_ready(struct QuartileBands *handle); + void wickra_quartile_bands_reset(struct QuartileBands *handle); void wickra_quartile_bands_free(struct QuartileBands *handle); @@ -9972,6 +11848,10 @@ bool wickra_relative_strength_ab_update(struct RelativeStrengthAB *handle, double y, struct WickraRelativeStrengthOutput *out); +uintptr_t wickra_relative_strength_ab_warmup_period(struct RelativeStrengthAB *handle); + +bool wickra_relative_strength_ab_is_ready(struct RelativeStrengthAB *handle); + void wickra_relative_strength_ab_reset(struct RelativeStrengthAB *handle); void wickra_relative_strength_ab_free(struct RelativeStrengthAB *handle); @@ -9987,6 +11867,10 @@ bool wickra_rwi_update(struct Rwi *handle, int64_t timestamp, struct WickraRwiOutput *out); +uintptr_t wickra_rwi_warmup_period(struct Rwi *handle); + +bool wickra_rwi_is_ready(struct Rwi *handle); + void wickra_rwi_reset(struct Rwi *handle); void wickra_rwi_free(struct Rwi *handle); @@ -10002,6 +11886,10 @@ bool wickra_session_high_low_update(struct SessionHighLow *handle, int64_t timestamp, struct WickraSessionHighLowOutput *out); +uintptr_t wickra_session_high_low_warmup_period(struct SessionHighLow *handle); + +bool wickra_session_high_low_is_ready(struct SessionHighLow *handle); + void wickra_session_high_low_reset(struct SessionHighLow *handle); void wickra_session_high_low_free(struct SessionHighLow *handle); @@ -10017,6 +11905,10 @@ bool wickra_session_range_update(struct SessionRange *handle, int64_t timestamp, struct WickraSessionRangeOutput *out); +uintptr_t wickra_session_range_warmup_period(struct SessionRange *handle); + +bool wickra_session_range_is_ready(struct SessionRange *handle); + void wickra_session_range_reset(struct SessionRange *handle); void wickra_session_range_free(struct SessionRange *handle); @@ -10032,6 +11924,10 @@ bool wickra_smoothed_heikin_ashi_update(struct SmoothedHeikinAshi *handle, int64_t timestamp, struct WickraSmoothedHeikinAshiOutput *out); +uintptr_t wickra_smoothed_heikin_ashi_warmup_period(struct SmoothedHeikinAshi *handle); + +bool wickra_smoothed_heikin_ashi_is_ready(struct SmoothedHeikinAshi *handle); + void wickra_smoothed_heikin_ashi_reset(struct SmoothedHeikinAshi *handle); void wickra_smoothed_heikin_ashi_free(struct SmoothedHeikinAshi *handle); @@ -10043,6 +11939,10 @@ bool wickra_spread_bollinger_bands_update(struct SpreadBollingerBands *handle, double y, struct WickraSpreadBollingerBandsOutput *out); +uintptr_t wickra_spread_bollinger_bands_warmup_period(struct SpreadBollingerBands *handle); + +bool wickra_spread_bollinger_bands_is_ready(struct SpreadBollingerBands *handle); + void wickra_spread_bollinger_bands_reset(struct SpreadBollingerBands *handle); void wickra_spread_bollinger_bands_free(struct SpreadBollingerBands *handle); @@ -10053,6 +11953,10 @@ bool wickra_standard_error_bands_update(struct StandardErrorBands *handle, double value, struct WickraStandardErrorBandsOutput *out); +uintptr_t wickra_standard_error_bands_warmup_period(struct StandardErrorBands *handle); + +bool wickra_standard_error_bands_is_ready(struct StandardErrorBands *handle); + void wickra_standard_error_bands_reset(struct StandardErrorBands *handle); void wickra_standard_error_bands_free(struct StandardErrorBands *handle); @@ -10070,6 +11974,10 @@ bool wickra_starc_bands_update(struct StarcBands *handle, int64_t timestamp, struct WickraStarcBandsOutput *out); +uintptr_t wickra_starc_bands_warmup_period(struct StarcBands *handle); + +bool wickra_starc_bands_is_ready(struct StarcBands *handle); + void wickra_starc_bands_reset(struct StarcBands *handle); void wickra_starc_bands_free(struct StarcBands *handle); @@ -10085,6 +11993,10 @@ bool wickra_stochastic_update(struct Stochastic *handle, int64_t timestamp, struct WickraStochasticOutput *out); +uintptr_t wickra_stochastic_warmup_period(struct Stochastic *handle); + +bool wickra_stochastic_is_ready(struct Stochastic *handle); + void wickra_stochastic_reset(struct Stochastic *handle); void wickra_stochastic_free(struct Stochastic *handle); @@ -10100,6 +12012,10 @@ bool wickra_super_trend_update(struct SuperTrend *handle, int64_t timestamp, struct WickraSuperTrendOutput *out); +uintptr_t wickra_super_trend_warmup_period(struct SuperTrend *handle); + +bool wickra_super_trend_is_ready(struct SuperTrend *handle); + void wickra_super_trend_reset(struct SuperTrend *handle); void wickra_super_trend_free(struct SuperTrend *handle); @@ -10115,6 +12031,10 @@ bool wickra_td_lines_update(struct TdLines *handle, int64_t timestamp, struct WickraTdLinesOutput *out); +uintptr_t wickra_td_lines_warmup_period(struct TdLines *handle); + +bool wickra_td_lines_is_ready(struct TdLines *handle); + void wickra_td_lines_reset(struct TdLines *handle); void wickra_td_lines_free(struct TdLines *handle); @@ -10130,6 +12050,10 @@ bool wickra_td_moving_average_update(struct TdMovingAverage *handle, int64_t timestamp, struct WickraTdMovingAverageOutput *out); +uintptr_t wickra_td_moving_average_warmup_period(struct TdMovingAverage *handle); + +bool wickra_td_moving_average_is_ready(struct TdMovingAverage *handle); + void wickra_td_moving_average_reset(struct TdMovingAverage *handle); void wickra_td_moving_average_free(struct TdMovingAverage *handle); @@ -10145,6 +12069,10 @@ bool wickra_td_range_projection_update(struct TdRangeProjection *handle, int64_t timestamp, struct WickraTdRangeProjectionOutput *out); +uintptr_t wickra_td_range_projection_warmup_period(struct TdRangeProjection *handle); + +bool wickra_td_range_projection_is_ready(struct TdRangeProjection *handle); + void wickra_td_range_projection_reset(struct TdRangeProjection *handle); void wickra_td_range_projection_free(struct TdRangeProjection *handle); @@ -10160,6 +12088,10 @@ bool wickra_td_risk_level_update(struct TdRiskLevel *handle, int64_t timestamp, struct WickraTdRiskLevelOutput *out); +uintptr_t wickra_td_risk_level_warmup_period(struct TdRiskLevel *handle); + +bool wickra_td_risk_level_is_ready(struct TdRiskLevel *handle); + void wickra_td_risk_level_reset(struct TdRiskLevel *handle); void wickra_td_risk_level_free(struct TdRiskLevel *handle); @@ -10178,6 +12110,10 @@ bool wickra_td_sequential_update(struct TdSequential *handle, int64_t timestamp, struct WickraTdSequentialOutput *out); +uintptr_t wickra_td_sequential_warmup_period(struct TdSequential *handle); + +bool wickra_td_sequential_is_ready(struct TdSequential *handle); + void wickra_td_sequential_reset(struct TdSequential *handle); void wickra_td_sequential_free(struct TdSequential *handle); @@ -10193,6 +12129,10 @@ bool wickra_ttm_squeeze_update(struct TtmSqueeze *handle, int64_t timestamp, struct WickraTtmSqueezeOutput *out); +uintptr_t wickra_ttm_squeeze_warmup_period(struct TtmSqueeze *handle); + +bool wickra_ttm_squeeze_is_ready(struct TtmSqueeze *handle); + void wickra_ttm_squeeze_reset(struct TtmSqueeze *handle); void wickra_ttm_squeeze_free(struct TtmSqueeze *handle); @@ -10210,6 +12150,10 @@ bool wickra_value_area_update(struct ValueArea *handle, int64_t timestamp, struct WickraValueAreaOutput *out); +uintptr_t wickra_value_area_warmup_period(struct ValueArea *handle); + +bool wickra_value_area_is_ready(struct ValueArea *handle); + void wickra_value_area_reset(struct ValueArea *handle); void wickra_value_area_free(struct ValueArea *handle); @@ -10225,6 +12169,10 @@ bool wickra_volatility_cone_update(struct VolatilityCone *handle, int64_t timestamp, struct WickraVolatilityConeOutput *out); +uintptr_t wickra_volatility_cone_warmup_period(struct VolatilityCone *handle); + +bool wickra_volatility_cone_is_ready(struct VolatilityCone *handle); + void wickra_volatility_cone_reset(struct VolatilityCone *handle); void wickra_volatility_cone_free(struct VolatilityCone *handle); @@ -10242,6 +12190,10 @@ bool wickra_volume_weighted_macd_update(struct VolumeWeightedMacd *handle, int64_t timestamp, struct WickraVolumeWeightedMacdOutput *out); +uintptr_t wickra_volume_weighted_macd_warmup_period(struct VolumeWeightedMacd *handle); + +bool wickra_volume_weighted_macd_is_ready(struct VolumeWeightedMacd *handle); + void wickra_volume_weighted_macd_reset(struct VolumeWeightedMacd *handle); void wickra_volume_weighted_macd_free(struct VolumeWeightedMacd *handle); @@ -10257,6 +12209,10 @@ bool wickra_volume_weighted_sr_update(struct VolumeWeightedSr *handle, int64_t timestamp, struct WickraVolumeWeightedSrOutput *out); +uintptr_t wickra_volume_weighted_sr_warmup_period(struct VolumeWeightedSr *handle); + +bool wickra_volume_weighted_sr_is_ready(struct VolumeWeightedSr *handle); + void wickra_volume_weighted_sr_reset(struct VolumeWeightedSr *handle); void wickra_volume_weighted_sr_free(struct VolumeWeightedSr *handle); @@ -10272,6 +12228,10 @@ bool wickra_vortex_update(struct Vortex *handle, int64_t timestamp, struct WickraVortexOutput *out); +uintptr_t wickra_vortex_warmup_period(struct Vortex *handle); + +bool wickra_vortex_is_ready(struct Vortex *handle); + void wickra_vortex_reset(struct Vortex *handle); void wickra_vortex_free(struct Vortex *handle); @@ -10287,6 +12247,10 @@ bool wickra_vwap_std_dev_bands_update(struct VwapStdDevBands *handle, int64_t timestamp, struct WickraVwapStdDevBandsOutput *out); +uintptr_t wickra_vwap_std_dev_bands_warmup_period(struct VwapStdDevBands *handle); + +bool wickra_vwap_std_dev_bands_is_ready(struct VwapStdDevBands *handle); + void wickra_vwap_std_dev_bands_reset(struct VwapStdDevBands *handle); void wickra_vwap_std_dev_bands_free(struct VwapStdDevBands *handle); @@ -10304,6 +12268,10 @@ bool wickra_wave_trend_update(struct WaveTrend *handle, int64_t timestamp, struct WickraWaveTrendOutput *out); +uintptr_t wickra_wave_trend_warmup_period(struct WaveTrend *handle); + +bool wickra_wave_trend_is_ready(struct WaveTrend *handle); + void wickra_wave_trend_reset(struct WaveTrend *handle); void wickra_wave_trend_free(struct WaveTrend *handle); @@ -10319,6 +12287,10 @@ bool wickra_williams_fractals_update(struct WilliamsFractals *handle, int64_t timestamp, struct WickraWilliamsFractalsOutput *out); +uintptr_t wickra_williams_fractals_warmup_period(struct WilliamsFractals *handle); + +bool wickra_williams_fractals_is_ready(struct WilliamsFractals *handle); + void wickra_williams_fractals_reset(struct WilliamsFractals *handle); void wickra_williams_fractals_free(struct WilliamsFractals *handle); @@ -10334,6 +12306,10 @@ bool wickra_woodie_pivots_update(struct WoodiePivots *handle, int64_t timestamp, struct WickraWoodiePivotsOutput *out); +uintptr_t wickra_woodie_pivots_warmup_period(struct WoodiePivots *handle); + +bool wickra_woodie_pivots_is_ready(struct WoodiePivots *handle); + void wickra_woodie_pivots_reset(struct WoodiePivots *handle); void wickra_woodie_pivots_free(struct WoodiePivots *handle); @@ -10344,6 +12320,10 @@ bool wickra_zero_lag_macd_update(struct ZeroLagMacd *handle, double value, struct WickraZeroLagMacdOutput *out); +uintptr_t wickra_zero_lag_macd_warmup_period(struct ZeroLagMacd *handle); + +bool wickra_zero_lag_macd_is_ready(struct ZeroLagMacd *handle); + void wickra_zero_lag_macd_reset(struct ZeroLagMacd *handle); void wickra_zero_lag_macd_free(struct ZeroLagMacd *handle); @@ -10359,6 +12339,10 @@ bool wickra_zig_zag_update(struct ZigZag *handle, int64_t timestamp, struct WickraZigZagOutput *out); +uintptr_t wickra_zig_zag_warmup_period(struct ZigZag *handle); + +bool wickra_zig_zag_is_ready(struct ZigZag *handle); + void wickra_zig_zag_reset(struct ZigZag *handle); void wickra_zig_zag_free(struct ZigZag *handle); @@ -10375,6 +12359,10 @@ intptr_t wickra_day_of_week_profile_update(struct DayOfWeekProfile *handle, double *values, uintptr_t cap); +uintptr_t wickra_day_of_week_profile_warmup_period(struct DayOfWeekProfile *handle); + +bool wickra_day_of_week_profile_is_ready(struct DayOfWeekProfile *handle); + void wickra_day_of_week_profile_reset(struct DayOfWeekProfile *handle); void wickra_day_of_week_profile_free(struct DayOfWeekProfile *handle); @@ -10392,6 +12380,10 @@ intptr_t wickra_intraday_volatility_profile_update(struct IntradayVolatilityProf double *values, uintptr_t cap); +uintptr_t wickra_intraday_volatility_profile_warmup_period(struct IntradayVolatilityProfile *handle); + +bool wickra_intraday_volatility_profile_is_ready(struct IntradayVolatilityProfile *handle); + void wickra_intraday_volatility_profile_reset(struct IntradayVolatilityProfile *handle); void wickra_intraday_volatility_profile_free(struct IntradayVolatilityProfile *handle); @@ -10409,6 +12401,10 @@ intptr_t wickra_time_of_day_return_profile_update(struct TimeOfDayReturnProfile double *values, uintptr_t cap); +uintptr_t wickra_time_of_day_return_profile_warmup_period(struct TimeOfDayReturnProfile *handle); + +bool wickra_time_of_day_return_profile_is_ready(struct TimeOfDayReturnProfile *handle); + void wickra_time_of_day_return_profile_reset(struct TimeOfDayReturnProfile *handle); void wickra_time_of_day_return_profile_free(struct TimeOfDayReturnProfile *handle); @@ -10426,6 +12422,10 @@ intptr_t wickra_tpo_profile_update(struct TpoProfile *handle, double *values, uintptr_t cap); +uintptr_t wickra_tpo_profile_warmup_period(struct TpoProfile *handle); + +bool wickra_tpo_profile_is_ready(struct TpoProfile *handle); + void wickra_tpo_profile_reset(struct TpoProfile *handle); void wickra_tpo_profile_free(struct TpoProfile *handle); @@ -10443,6 +12443,10 @@ intptr_t wickra_volume_by_time_profile_update(struct VolumeByTimeProfile *handle double *values, uintptr_t cap); +uintptr_t wickra_volume_by_time_profile_warmup_period(struct VolumeByTimeProfile *handle); + +bool wickra_volume_by_time_profile_is_ready(struct VolumeByTimeProfile *handle); + void wickra_volume_by_time_profile_reset(struct VolumeByTimeProfile *handle); void wickra_volume_by_time_profile_free(struct VolumeByTimeProfile *handle); @@ -10460,6 +12464,10 @@ intptr_t wickra_volume_profile_update(struct VolumeProfile *handle, double *values, uintptr_t cap); +uintptr_t wickra_volume_profile_warmup_period(struct VolumeProfile *handle); + +bool wickra_volume_profile_is_ready(struct VolumeProfile *handle); + void wickra_volume_profile_reset(struct VolumeProfile *handle); void wickra_volume_profile_free(struct VolumeProfile *handle); @@ -10633,6 +12641,10 @@ struct MacdExt *wickra_macd_ext_new(uintptr_t fast, bool wickra_macd_ext_update(struct MacdExt *handle, double value, struct WickraMacdOutput *out); +uintptr_t wickra_macd_ext_warmup_period(struct MacdExt *handle); + +bool wickra_macd_ext_is_ready(struct MacdExt *handle); + void wickra_macd_ext_reset(struct MacdExt *handle); void wickra_macd_ext_free(struct MacdExt *handle); @@ -10647,6 +12659,10 @@ intptr_t wickra_footprint_update(struct Footprint *handle, struct WickraFootprintLevel *out, uintptr_t cap); +uintptr_t wickra_footprint_warmup_period(struct Footprint *handle); + +bool wickra_footprint_is_ready(struct Footprint *handle); + void wickra_footprint_reset(struct Footprint *handle); void wickra_footprint_free(struct Footprint *handle); diff --git a/bindings/c/src/lib.rs b/bindings/c/src/lib.rs index 4c143377..12370ed7 100644 --- a/bindings/c/src/lib.rs +++ b/bindings/c/src/lib.rs @@ -7,6 +7,11 @@ //! while warming up / if `h` is `NULL` / if the inputs are invalid. //! - `wickra__batch(h, ..., out, n)` — write one output per input into the //! caller-owned `out` buffer (length `n`), `NaN` at warmup positions. +//! - `wickra__warmup_period(h)` — updates needed before a non-`NaN` output +//! (`0` on a `NULL` handle). +//! - `wickra__is_ready(h)` — whether enough input has been consumed to emit +//! a value (`false` on a `NULL` handle). Both are absent for the alt-chart bar +//! builders, which have no warmup. //! - `wickra__reset(h)` — clear all state. //! - `wickra__free(h)` — destroy the handle. Every `_new` must be paired //! with exactly one `_free`; there is no RAII across the C boundary. @@ -150,6 +155,32 @@ pub unsafe extern "C" fn wickra_adaptive_cycle_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_cycle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_cycle_warmup_period(handle: *mut AdaptiveCycle) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_cycle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_cycle_is_ready(handle: *mut AdaptiveCycle) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -222,6 +253,36 @@ pub unsafe extern "C" fn wickra_adaptive_laguerre_filter_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_laguerre_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_laguerre_filter_warmup_period( + handle: *mut AdaptiveLaguerreFilter, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_laguerre_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_laguerre_filter_is_ready( + handle: *mut AdaptiveLaguerreFilter, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -291,6 +352,32 @@ pub unsafe extern "C" fn wickra_adaptive_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_rsi_warmup_period(handle: *mut AdaptiveRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_rsi_is_ready(handle: *mut AdaptiveRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -358,6 +445,32 @@ pub unsafe extern "C" fn wickra_alma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_alma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_alma_warmup_period(handle: *mut Alma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_alma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_alma_is_ready(handle: *mut Alma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -422,6 +535,32 @@ pub unsafe extern "C" fn wickra_anchored_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_anchored_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_anchored_rsi_warmup_period(handle: *mut AnchoredRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_anchored_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_anchored_rsi_is_ready(handle: *mut AnchoredRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -489,6 +628,32 @@ pub unsafe extern "C" fn wickra_apo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_apo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_apo_warmup_period(handle: *mut Apo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_apo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_apo_is_ready(handle: *mut Apo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -559,6 +724,34 @@ pub unsafe extern "C" fn wickra_autocorrelation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_autocorrelation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_autocorrelation_warmup_period( + handle: *mut Autocorrelation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_autocorrelation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_autocorrelation_is_ready(handle: *mut Autocorrelation) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -632,6 +825,36 @@ pub unsafe extern "C" fn wickra_autocorrelation_periodogram_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_autocorrelation_periodogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_autocorrelation_periodogram_warmup_period( + handle: *mut AutocorrelationPeriodogram, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_autocorrelation_periodogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_autocorrelation_periodogram_is_ready( + handle: *mut AutocorrelationPeriodogram, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -706,6 +929,34 @@ pub unsafe extern "C" fn wickra_average_drawdown_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_average_drawdown_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_average_drawdown_warmup_period( + handle: *mut AverageDrawdown, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_average_drawdown_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_average_drawdown_is_ready(handle: *mut AverageDrawdown) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -776,6 +1027,34 @@ pub unsafe extern "C" fn wickra_bandpass_filter_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bandpass_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bandpass_filter_warmup_period( + handle: *mut BandpassFilter, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bandpass_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bandpass_filter_is_ready(handle: *mut BandpassFilter) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -846,6 +1125,34 @@ pub unsafe extern "C" fn wickra_bipower_variation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bipower_variation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bipower_variation_warmup_period( + handle: *mut BipowerVariation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bipower_variation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bipower_variation_is_ready(handle: *mut BipowerVariation) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -919,6 +1226,36 @@ pub unsafe extern "C" fn wickra_bollinger_bandwidth_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bollinger_bandwidth_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bollinger_bandwidth_warmup_period( + handle: *mut BollingerBandwidth, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bollinger_bandwidth_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bollinger_bandwidth_is_ready( + handle: *mut BollingerBandwidth, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -986,6 +1323,32 @@ pub unsafe extern "C" fn wickra_burke_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_burke_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_burke_ratio_warmup_period(handle: *mut BurkeRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_burke_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_burke_ratio_is_ready(handle: *mut BurkeRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1053,6 +1416,32 @@ pub unsafe extern "C" fn wickra_calmar_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_calmar_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_calmar_ratio_warmup_period(handle: *mut CalmarRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_calmar_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_calmar_ratio_is_ready(handle: *mut CalmarRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1123,6 +1512,34 @@ pub unsafe extern "C" fn wickra_center_of_gravity_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_center_of_gravity_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_center_of_gravity_warmup_period( + handle: *mut CenterOfGravity, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_center_of_gravity_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_center_of_gravity_is_ready(handle: *mut CenterOfGravity) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1190,6 +1607,32 @@ pub unsafe extern "C" fn wickra_cfo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cfo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cfo_warmup_period(handle: *mut Cfo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cfo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cfo_is_ready(handle: *mut Cfo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1257,6 +1700,32 @@ pub unsafe extern "C" fn wickra_cmo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cmo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cmo_warmup_period(handle: *mut Cmo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cmo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cmo_is_ready(handle: *mut Cmo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1329,6 +1798,36 @@ pub unsafe extern "C" fn wickra_coefficient_of_variation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_coefficient_of_variation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_coefficient_of_variation_warmup_period( + handle: *mut CoefficientOfVariation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_coefficient_of_variation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_coefficient_of_variation_is_ready( + handle: *mut CoefficientOfVariation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1401,6 +1900,34 @@ pub unsafe extern "C" fn wickra_common_sense_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_common_sense_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_common_sense_ratio_warmup_period( + handle: *mut CommonSenseRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_common_sense_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_common_sense_ratio_is_ready(handle: *mut CommonSenseRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1474,6 +2001,36 @@ pub unsafe extern "C" fn wickra_conditional_value_at_risk_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_conditional_value_at_risk_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_conditional_value_at_risk_warmup_period( + handle: *mut ConditionalValueAtRisk, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_conditional_value_at_risk_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_conditional_value_at_risk_is_ready( + handle: *mut ConditionalValueAtRisk, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1549,6 +2106,32 @@ pub unsafe extern "C" fn wickra_connors_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_connors_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_connors_rsi_warmup_period(handle: *mut ConnorsRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_connors_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_connors_rsi_is_ready(handle: *mut ConnorsRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1620,6 +2203,32 @@ pub unsafe extern "C" fn wickra_coppock_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_coppock_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_coppock_warmup_period(handle: *mut Coppock) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_coppock_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_coppock_is_ready(handle: *mut Coppock) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1692,6 +2301,36 @@ pub unsafe extern "C" fn wickra_correlation_trend_indicator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_correlation_trend_indicator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_correlation_trend_indicator_warmup_period( + handle: *mut CorrelationTrendIndicator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_correlation_trend_indicator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_correlation_trend_indicator_is_ready( + handle: *mut CorrelationTrendIndicator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1766,6 +2405,34 @@ pub unsafe extern "C" fn wickra_cybernetic_cycle_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cybernetic_cycle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cybernetic_cycle_warmup_period( + handle: *mut CyberneticCycle, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cybernetic_cycle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cybernetic_cycle_is_ready(handle: *mut CyberneticCycle) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1833,6 +2500,32 @@ pub unsafe extern "C" fn wickra_decycler_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_decycler_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_decycler_warmup_period(handle: *mut Decycler) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_decycler_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_decycler_is_ready(handle: *mut Decycler) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1906,6 +2599,36 @@ pub unsafe extern "C" fn wickra_decycler_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_decycler_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_decycler_oscillator_warmup_period( + handle: *mut DecyclerOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_decycler_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_decycler_oscillator_is_ready( + handle: *mut DecyclerOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -1973,6 +2696,32 @@ pub unsafe extern "C" fn wickra_dema_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dema_warmup_period(handle: *mut Dema) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dema_is_ready(handle: *mut Dema) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2048,6 +2797,36 @@ pub unsafe extern "C" fn wickra_derivative_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_derivative_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_derivative_oscillator_warmup_period( + handle: *mut DerivativeOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_derivative_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_derivative_oscillator_is_ready( + handle: *mut DerivativeOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2118,6 +2897,34 @@ pub unsafe extern "C" fn wickra_detrended_std_dev_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_detrended_std_dev_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_detrended_std_dev_warmup_period( + handle: *mut DetrendedStdDev, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_detrended_std_dev_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_detrended_std_dev_is_ready(handle: *mut DetrendedStdDev) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2188,6 +2995,34 @@ pub unsafe extern "C" fn wickra_disparity_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_disparity_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_disparity_index_warmup_period( + handle: *mut DisparityIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_disparity_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_disparity_index_is_ready(handle: *mut DisparityIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2255,6 +3090,32 @@ pub unsafe extern "C" fn wickra_dpo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dpo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dpo_warmup_period(handle: *mut Dpo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dpo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dpo_is_ready(handle: *mut Dpo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2322,6 +3183,34 @@ pub unsafe extern "C" fn wickra_drawdown_duration_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_drawdown_duration_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_drawdown_duration_warmup_period( + handle: *mut DrawdownDuration, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_drawdown_duration_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_drawdown_duration_is_ready(handle: *mut DrawdownDuration) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2392,6 +3281,36 @@ pub unsafe extern "C" fn wickra_dynamic_momentum_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dynamic_momentum_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dynamic_momentum_index_warmup_period( + handle: *mut DynamicMomentumIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dynamic_momentum_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dynamic_momentum_index_is_ready( + handle: *mut DynamicMomentumIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2462,6 +3381,34 @@ pub unsafe extern "C" fn wickra_ehlers_stochastic_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ehlers_stochastic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ehlers_stochastic_warmup_period( + handle: *mut EhlersStochastic, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ehlers_stochastic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ehlers_stochastic_is_ready(handle: *mut EhlersStochastic) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2529,6 +3476,32 @@ pub unsafe extern "C" fn wickra_ehma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ehma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ehma_warmup_period(handle: *mut Ehma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ehma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ehma_is_ready(handle: *mut Ehma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2601,6 +3574,32 @@ pub unsafe extern "C" fn wickra_elder_impulse_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_elder_impulse_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_elder_impulse_warmup_period(handle: *mut ElderImpulse) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_elder_impulse_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_elder_impulse_is_ready(handle: *mut ElderImpulse) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2668,6 +3667,32 @@ pub unsafe extern "C" fn wickra_ema_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ema_warmup_period(handle: *mut Ema) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ema_is_ready(handle: *mut Ema) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2741,6 +3766,36 @@ pub unsafe extern "C" fn wickra_empirical_mode_decomposition_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_empirical_mode_decomposition_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_empirical_mode_decomposition_warmup_period( + handle: *mut EmpiricalModeDecomposition, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_empirical_mode_decomposition_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_empirical_mode_decomposition_is_ready( + handle: *mut EmpiricalModeDecomposition, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2818,6 +3873,36 @@ pub unsafe extern "C" fn wickra_even_better_sinewave_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_even_better_sinewave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_even_better_sinewave_warmup_period( + handle: *mut EvenBetterSinewave, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_even_better_sinewave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_even_better_sinewave_is_ready( + handle: *mut EvenBetterSinewave, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2888,6 +3973,34 @@ pub unsafe extern "C" fn wickra_ewma_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ewma_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ewma_volatility_warmup_period( + handle: *mut EwmaVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ewma_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ewma_volatility_is_ready(handle: *mut EwmaVolatility) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -2955,6 +4068,32 @@ pub unsafe extern "C" fn wickra_expectancy_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_expectancy_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_expectancy_warmup_period(handle: *mut Expectancy) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_expectancy_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_expectancy_is_ready(handle: *mut Expectancy) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3022,6 +4161,32 @@ pub unsafe extern "C" fn wickra_fama_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fama_warmup_period(handle: *mut Fama) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fama_is_ready(handle: *mut Fama) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3089,6 +4254,32 @@ pub unsafe extern "C" fn wickra_fisher_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fisher_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fisher_rsi_warmup_period(handle: *mut FisherRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fisher_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fisher_rsi_is_ready(handle: *mut FisherRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3159,6 +4350,34 @@ pub unsafe extern "C" fn wickra_fisher_transform_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fisher_transform_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fisher_transform_warmup_period( + handle: *mut FisherTransform, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fisher_transform_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fisher_transform_is_ready(handle: *mut FisherTransform) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3226,6 +4445,32 @@ pub unsafe extern "C" fn wickra_frama_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_frama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_frama_warmup_period(handle: *mut Frama) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_frama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_frama_is_ready(handle: *mut Frama) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3296,6 +4541,32 @@ pub unsafe extern "C" fn wickra_gain_loss_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gain_loss_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gain_loss_ratio_warmup_period(handle: *mut GainLossRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gain_loss_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gain_loss_ratio_is_ready(handle: *mut GainLossRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3366,6 +4637,34 @@ pub unsafe extern "C" fn wickra_gain_to_pain_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gain_to_pain_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gain_to_pain_ratio_warmup_period( + handle: *mut GainToPainRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gain_to_pain_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gain_to_pain_ratio_is_ready(handle: *mut GainToPainRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3433,6 +4732,32 @@ pub unsafe extern "C" fn wickra_garch11_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_garch11_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_garch11_warmup_period(handle: *mut Garch11) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_garch11_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_garch11_is_ready(handle: *mut Garch11) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3503,6 +4828,34 @@ pub unsafe extern "C" fn wickra_generalized_dema_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_generalized_dema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_generalized_dema_warmup_period( + handle: *mut GeneralizedDema, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_generalized_dema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_generalized_dema_is_ready(handle: *mut GeneralizedDema) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3570,6 +4923,32 @@ pub unsafe extern "C" fn wickra_geometric_ma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_geometric_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_geometric_ma_warmup_period(handle: *mut GeometricMa) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_geometric_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_geometric_ma_is_ready(handle: *mut GeometricMa) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3640,6 +5019,34 @@ pub unsafe extern "C" fn wickra_highpass_filter_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_highpass_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_highpass_filter_warmup_period( + handle: *mut HighpassFilter, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_highpass_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_highpass_filter_is_ready(handle: *mut HighpassFilter) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3707,6 +5114,36 @@ pub unsafe extern "C" fn wickra_hilbert_dominant_cycle_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hilbert_dominant_cycle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hilbert_dominant_cycle_warmup_period( + handle: *mut HilbertDominantCycle, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hilbert_dominant_cycle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hilbert_dominant_cycle_is_ready( + handle: *mut HilbertDominantCycle, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3780,6 +5217,36 @@ pub unsafe extern "C" fn wickra_historical_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_historical_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_historical_volatility_warmup_period( + handle: *mut HistoricalVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_historical_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_historical_volatility_is_ready( + handle: *mut HistoricalVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3847,6 +5314,32 @@ pub unsafe extern "C" fn wickra_hma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hma_warmup_period(handle: *mut Hma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hma_is_ready(handle: *mut Hma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3914,6 +5407,32 @@ pub unsafe extern "C" fn wickra_holt_winters_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_holt_winters_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_holt_winters_warmup_period(handle: *mut HoltWinters) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_holt_winters_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_holt_winters_is_ready(handle: *mut HoltWinters) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -3978,6 +5497,32 @@ pub unsafe extern "C" fn wickra_ht_dc_phase_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ht_dc_phase_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ht_dc_phase_warmup_period(handle: *mut HtDcPhase) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ht_dc_phase_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ht_dc_phase_is_ready(handle: *mut HtDcPhase) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4042,6 +5587,32 @@ pub unsafe extern "C" fn wickra_ht_trend_mode_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ht_trend_mode_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ht_trend_mode_warmup_period(handle: *mut HtTrendMode) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ht_trend_mode_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ht_trend_mode_is_ready(handle: *mut HtTrendMode) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4112,6 +5683,32 @@ pub unsafe extern "C" fn wickra_hurst_exponent_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hurst_exponent_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hurst_exponent_warmup_period(handle: *mut HurstExponent) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hurst_exponent_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hurst_exponent_is_ready(handle: *mut HurstExponent) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4182,6 +5779,36 @@ pub unsafe extern "C" fn wickra_instantaneous_trendline_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_instantaneous_trendline_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_instantaneous_trendline_warmup_period( + handle: *mut InstantaneousTrendline, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_instantaneous_trendline_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_instantaneous_trendline_is_ready( + handle: *mut InstantaneousTrendline, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4252,6 +5879,36 @@ pub unsafe extern "C" fn wickra_inverse_fisher_transform_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_inverse_fisher_transform_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_inverse_fisher_transform_warmup_period( + handle: *mut InverseFisherTransform, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_inverse_fisher_transform_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_inverse_fisher_transform_is_ready( + handle: *mut InverseFisherTransform, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4321,6 +5978,32 @@ pub unsafe extern "C" fn wickra_jarque_bera_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_jarque_bera_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_jarque_bera_warmup_period(handle: *mut JarqueBera) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_jarque_bera_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_jarque_bera_is_ready(handle: *mut JarqueBera) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4388,6 +6071,32 @@ pub unsafe extern "C" fn wickra_jma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_jma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_jma_warmup_period(handle: *mut Jma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_jma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_jma_is_ready(handle: *mut Jma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4458,6 +6167,32 @@ pub unsafe extern "C" fn wickra_jump_indicator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_jump_indicator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_jump_indicator_warmup_period(handle: *mut JumpIndicator) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_jump_indicator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_jump_indicator_is_ready(handle: *mut JumpIndicator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4525,6 +6260,32 @@ pub unsafe extern "C" fn wickra_k_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_k_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_k_ratio_warmup_period(handle: *mut KRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_k_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_k_ratio_is_ready(handle: *mut KRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4592,6 +6353,32 @@ pub unsafe extern "C" fn wickra_kama_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kama_warmup_period(handle: *mut Kama) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kama_is_ready(handle: *mut Kama) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4662,6 +6449,34 @@ pub unsafe extern "C" fn wickra_kelly_criterion_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kelly_criterion_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kelly_criterion_warmup_period( + handle: *mut KellyCriterion, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kelly_criterion_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kelly_criterion_is_ready(handle: *mut KellyCriterion) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4729,6 +6544,32 @@ pub unsafe extern "C" fn wickra_kurtosis_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kurtosis_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kurtosis_warmup_period(handle: *mut Kurtosis) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kurtosis_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kurtosis_is_ready(handle: *mut Kurtosis) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4796,6 +6637,32 @@ pub unsafe extern "C" fn wickra_laguerre_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_laguerre_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_laguerre_rsi_warmup_period(handle: *mut LaguerreRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_laguerre_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_laguerre_rsi_is_ready(handle: *mut LaguerreRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4866,6 +6733,34 @@ pub unsafe extern "C" fn wickra_linear_regression_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_linear_regression_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_linear_regression_warmup_period( + handle: *mut LinearRegression, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_linear_regression_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_linear_regression_is_ready(handle: *mut LinearRegression) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -4933,6 +6828,32 @@ pub unsafe extern "C" fn wickra_lin_reg_angle_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_angle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_angle_warmup_period(handle: *mut LinRegAngle) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_angle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_angle_is_ready(handle: *mut LinRegAngle) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5003,6 +6924,34 @@ pub unsafe extern "C" fn wickra_lin_reg_intercept_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_intercept_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_intercept_warmup_period( + handle: *mut LinRegIntercept, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_intercept_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_intercept_is_ready(handle: *mut LinRegIntercept) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5070,6 +7019,32 @@ pub unsafe extern "C" fn wickra_lin_reg_slope_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_slope_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_slope_warmup_period(handle: *mut LinRegSlope) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_slope_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_slope_is_ready(handle: *mut LinRegSlope) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5137,6 +7112,32 @@ pub unsafe extern "C" fn wickra_log_return_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_log_return_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_log_return_warmup_period(handle: *mut LogReturn) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_log_return_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_log_return_is_ready(handle: *mut LogReturn) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5208,6 +7209,32 @@ pub unsafe extern "C" fn wickra_m2_measure_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_m2_measure_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_m2_measure_warmup_period(handle: *mut M2Measure) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_m2_measure_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_m2_measure_is_ready(handle: *mut M2Measure) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5282,6 +7309,32 @@ pub unsafe extern "C" fn wickra_macd_histogram_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_histogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_histogram_warmup_period(handle: *mut MacdHistogram) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_histogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_histogram_is_ready(handle: *mut MacdHistogram) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5349,6 +7402,32 @@ pub unsafe extern "C" fn wickra_martin_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_martin_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_martin_ratio_warmup_period(handle: *mut MartinRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_martin_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_martin_ratio_is_ready(handle: *mut MartinRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5416,6 +7495,32 @@ pub unsafe extern "C" fn wickra_max_drawdown_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_max_drawdown_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_max_drawdown_warmup_period(handle: *mut MaxDrawdown) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_max_drawdown_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_max_drawdown_is_ready(handle: *mut MaxDrawdown) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5486,6 +7591,34 @@ pub unsafe extern "C" fn wickra_mc_ginley_dynamic_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mc_ginley_dynamic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mc_ginley_dynamic_warmup_period( + handle: *mut McGinleyDynamic, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mc_ginley_dynamic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mc_ginley_dynamic_is_ready(handle: *mut McGinleyDynamic) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5558,6 +7691,36 @@ pub unsafe extern "C" fn wickra_median_absolute_deviation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_absolute_deviation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_absolute_deviation_warmup_period( + handle: *mut MedianAbsoluteDeviation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_absolute_deviation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_absolute_deviation_is_ready( + handle: *mut MedianAbsoluteDeviation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5629,6 +7792,32 @@ pub unsafe extern "C" fn wickra_median_ma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_ma_warmup_period(handle: *mut MedianMa) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_ma_is_ready(handle: *mut MedianMa) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5696,6 +7885,32 @@ pub unsafe extern "C" fn wickra_mid_point_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mid_point_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mid_point_warmup_period(handle: *mut MidPoint) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mid_point_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mid_point_is_ready(handle: *mut MidPoint) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5763,6 +7978,32 @@ pub unsafe extern "C" fn wickra_mom_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mom_warmup_period(handle: *mut Mom) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mom_is_ready(handle: *mut Mom) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5830,6 +8071,32 @@ pub unsafe extern "C" fn wickra_omega_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_omega_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_omega_ratio_warmup_period(handle: *mut OmegaRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_omega_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_omega_ratio_is_ready(handle: *mut OmegaRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5897,6 +8164,32 @@ pub unsafe extern "C" fn wickra_pain_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pain_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pain_index_warmup_period(handle: *mut PainIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pain_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pain_index_is_ready(handle: *mut PainIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -5964,6 +8257,32 @@ pub unsafe extern "C" fn wickra_percent_b_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_percent_b_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_percent_b_warmup_period(handle: *mut PercentB) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_percent_b_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_percent_b_is_ready(handle: *mut PercentB) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6034,6 +8353,36 @@ pub unsafe extern "C" fn wickra_percentage_trailing_stop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_percentage_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_percentage_trailing_stop_warmup_period( + handle: *mut PercentageTrailingStop, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_percentage_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_percentage_trailing_stop_is_ready( + handle: *mut PercentageTrailingStop, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6103,6 +8452,32 @@ pub unsafe extern "C" fn wickra_pmo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pmo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pmo_warmup_period(handle: *mut Pmo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pmo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pmo_is_ready(handle: *mut Pmo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6176,6 +8551,36 @@ pub unsafe extern "C" fn wickra_polarized_fractal_efficiency_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_polarized_fractal_efficiency_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_polarized_fractal_efficiency_warmup_period( + handle: *mut PolarizedFractalEfficiency, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_polarized_fractal_efficiency_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_polarized_fractal_efficiency_is_ready( + handle: *mut PolarizedFractalEfficiency, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6247,6 +8652,32 @@ pub unsafe extern "C" fn wickra_ppo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ppo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ppo_warmup_period(handle: *mut Ppo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ppo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ppo_is_ready(handle: *mut Ppo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6318,6 +8749,32 @@ pub unsafe extern "C" fn wickra_ppo_histogram_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ppo_histogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ppo_histogram_warmup_period(handle: *mut PpoHistogram) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ppo_histogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ppo_histogram_is_ready(handle: *mut PpoHistogram) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6385,6 +8842,32 @@ pub unsafe extern "C" fn wickra_profit_factor_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_profit_factor_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_profit_factor_warmup_period(handle: *mut ProfitFactor) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_profit_factor_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_profit_factor_is_ready(handle: *mut ProfitFactor) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6452,6 +8935,32 @@ pub unsafe extern "C" fn wickra_r_squared_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_r_squared_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_r_squared_warmup_period(handle: *mut RSquared) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_r_squared_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_r_squared_is_ready(handle: *mut RSquared) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6522,6 +9031,36 @@ pub unsafe extern "C" fn wickra_realized_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_realized_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_realized_volatility_warmup_period( + handle: *mut RealizedVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_realized_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_realized_volatility_is_ready( + handle: *mut RealizedVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6589,6 +9128,34 @@ pub unsafe extern "C" fn wickra_recovery_factor_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_recovery_factor_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_recovery_factor_warmup_period( + handle: *mut RecoveryFactor, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_recovery_factor_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_recovery_factor_is_ready(handle: *mut RecoveryFactor) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6656,6 +9223,32 @@ pub unsafe extern "C" fn wickra_reflex_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_reflex_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_reflex_warmup_period(handle: *mut Reflex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_reflex_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_reflex_is_ready(handle: *mut Reflex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6723,6 +9316,32 @@ pub unsafe extern "C" fn wickra_regime_label_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_regime_label_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_regime_label_warmup_period(handle: *mut RegimeLabel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_regime_label_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_regime_label_is_ready(handle: *mut RegimeLabel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6793,6 +9412,36 @@ pub unsafe extern "C" fn wickra_renko_trailing_stop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_renko_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_renko_trailing_stop_warmup_period( + handle: *mut RenkoTrailingStop, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_renko_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_renko_trailing_stop_is_ready( + handle: *mut RenkoTrailingStop, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6860,6 +9509,32 @@ pub unsafe extern "C" fn wickra_rmi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rmi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rmi_warmup_period(handle: *mut Rmi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rmi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rmi_is_ready(handle: *mut Rmi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6927,6 +9602,32 @@ pub unsafe extern "C" fn wickra_roc_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_roc_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_roc_warmup_period(handle: *mut Roc) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_roc_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_roc_is_ready(handle: *mut Roc) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -6994,6 +9695,32 @@ pub unsafe extern "C" fn wickra_rocp_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rocp_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rocp_warmup_period(handle: *mut Rocp) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rocp_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rocp_is_ready(handle: *mut Rocp) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7061,6 +9788,32 @@ pub unsafe extern "C" fn wickra_rocr_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rocr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rocr_warmup_period(handle: *mut Rocr) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rocr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rocr_is_ready(handle: *mut Rocr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7128,6 +9881,32 @@ pub unsafe extern "C" fn wickra_rocr100_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rocr100_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rocr100_warmup_period(handle: *mut Rocr100) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rocr100_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rocr100_is_ready(handle: *mut Rocr100) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7195,6 +9974,32 @@ pub unsafe extern "C" fn wickra_rolling_iqr_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_iqr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_iqr_warmup_period(handle: *mut RollingIqr) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_iqr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_iqr_is_ready(handle: *mut RollingIqr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7265,6 +10070,36 @@ pub unsafe extern "C" fn wickra_rolling_min_max_scaler_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_min_max_scaler_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_min_max_scaler_warmup_period( + handle: *mut RollingMinMaxScaler, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_min_max_scaler_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_min_max_scaler_is_ready( + handle: *mut RollingMinMaxScaler, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7335,6 +10170,36 @@ pub unsafe extern "C" fn wickra_rolling_percentile_rank_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_percentile_rank_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_percentile_rank_warmup_period( + handle: *mut RollingPercentileRank, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_percentile_rank_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_percentile_rank_is_ready( + handle: *mut RollingPercentileRank, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7408,6 +10273,34 @@ pub unsafe extern "C" fn wickra_rolling_quantile_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_quantile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_quantile_warmup_period( + handle: *mut RollingQuantile, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_quantile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_quantile_is_ready(handle: *mut RollingQuantile) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7481,6 +10374,32 @@ pub unsafe extern "C" fn wickra_roofing_filter_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_roofing_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_roofing_filter_warmup_period(handle: *mut RoofingFilter) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_roofing_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_roofing_filter_is_ready(handle: *mut RoofingFilter) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7548,6 +10467,32 @@ pub unsafe extern "C" fn wickra_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rsi_warmup_period(handle: *mut Rsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rsi_is_ready(handle: *mut Rsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7615,6 +10560,32 @@ pub unsafe extern "C" fn wickra_rsx_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rsx_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rsx_warmup_period(handle: *mut Rsx) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rsx_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rsx_is_ready(handle: *mut Rsx) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7685,6 +10656,32 @@ pub unsafe extern "C" fn wickra_rvi_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rvi_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rvi_volatility_warmup_period(handle: *mut RviVolatility) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rvi_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rvi_volatility_is_ready(handle: *mut RviVolatility) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7759,6 +10756,32 @@ pub unsafe extern "C" fn wickra_sample_entropy_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sample_entropy_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sample_entropy_warmup_period(handle: *mut SampleEntropy) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sample_entropy_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sample_entropy_is_ready(handle: *mut SampleEntropy) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7829,6 +10852,34 @@ pub unsafe extern "C" fn wickra_shannon_entropy_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_shannon_entropy_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_shannon_entropy_warmup_period( + handle: *mut ShannonEntropy, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_shannon_entropy_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_shannon_entropy_is_ready(handle: *mut ShannonEntropy) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7896,6 +10947,32 @@ pub unsafe extern "C" fn wickra_sharpe_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sharpe_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sharpe_ratio_warmup_period(handle: *mut SharpeRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sharpe_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sharpe_ratio_is_ready(handle: *mut SharpeRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -7960,6 +11037,32 @@ pub unsafe extern "C" fn wickra_sine_wave_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sine_wave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sine_wave_warmup_period(handle: *mut SineWave) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sine_wave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sine_wave_is_ready(handle: *mut SineWave) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8030,6 +11133,34 @@ pub unsafe extern "C" fn wickra_sine_weighted_ma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sine_weighted_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sine_weighted_ma_warmup_period( + handle: *mut SineWeightedMa, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sine_weighted_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sine_weighted_ma_is_ready(handle: *mut SineWeightedMa) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8097,6 +11228,32 @@ pub unsafe extern "C" fn wickra_skewness_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_skewness_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_skewness_warmup_period(handle: *mut Skewness) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_skewness_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_skewness_is_ready(handle: *mut Skewness) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8164,6 +11321,32 @@ pub unsafe extern "C" fn wickra_sma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sma_warmup_period(handle: *mut Sma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sma_is_ready(handle: *mut Sma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8231,6 +11414,32 @@ pub unsafe extern "C" fn wickra_smma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_smma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_smma_warmup_period(handle: *mut Smma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_smma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_smma_is_ready(handle: *mut Smma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8298,6 +11507,32 @@ pub unsafe extern "C" fn wickra_sortino_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sortino_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sortino_ratio_warmup_period(handle: *mut SortinoRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sortino_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sortino_ratio_is_ready(handle: *mut SortinoRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8368,6 +11603,32 @@ pub unsafe extern "C" fn wickra_standard_error_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_standard_error_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_standard_error_warmup_period(handle: *mut StandardError) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_standard_error_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_standard_error_is_ready(handle: *mut StandardError) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8440,6 +11701,32 @@ pub unsafe extern "C" fn wickra_stc_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stc_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stc_warmup_period(handle: *mut Stc) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stc_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stc_is_ready(handle: *mut Stc) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8507,6 +11794,32 @@ pub unsafe extern "C" fn wickra_std_dev_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_std_dev_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_std_dev_warmup_period(handle: *mut StdDev) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_std_dev_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_std_dev_is_ready(handle: *mut StdDev) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8577,6 +11890,34 @@ pub unsafe extern "C" fn wickra_step_trailing_stop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_step_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_step_trailing_stop_warmup_period( + handle: *mut StepTrailingStop, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_step_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_step_trailing_stop_is_ready(handle: *mut StepTrailingStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8647,6 +11988,32 @@ pub unsafe extern "C" fn wickra_sterling_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sterling_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sterling_ratio_warmup_period(handle: *mut SterlingRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sterling_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sterling_ratio_is_ready(handle: *mut SterlingRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8714,6 +12081,32 @@ pub unsafe extern "C" fn wickra_stoch_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stoch_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stoch_rsi_warmup_period(handle: *mut StochRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stoch_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stoch_rsi_is_ready(handle: *mut StochRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8784,6 +12177,32 @@ pub unsafe extern "C" fn wickra_super_smoother_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_super_smoother_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_super_smoother_warmup_period(handle: *mut SuperSmoother) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_super_smoother_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_super_smoother_is_ready(handle: *mut SuperSmoother) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8851,6 +12270,32 @@ pub unsafe extern "C" fn wickra_t3_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_t3_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_t3_warmup_period(handle: *mut T3) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_t3_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_t3_is_ready(handle: *mut T3) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8918,6 +12363,32 @@ pub unsafe extern "C" fn wickra_tail_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tail_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tail_ratio_warmup_period(handle: *mut TailRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tail_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tail_ratio_is_ready(handle: *mut TailRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -8985,6 +12456,32 @@ pub unsafe extern "C" fn wickra_tema_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tema_warmup_period(handle: *mut Tema) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tema_is_ready(handle: *mut Tema) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9052,6 +12549,32 @@ pub unsafe extern "C" fn wickra_tii_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tii_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tii_warmup_period(handle: *mut Tii) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tii_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tii_is_ready(handle: *mut Tii) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9119,6 +12642,32 @@ pub unsafe extern "C" fn wickra_trend_label_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trend_label_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trend_label_warmup_period(handle: *mut TrendLabel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trend_label_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trend_label_is_ready(handle: *mut TrendLabel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9189,6 +12738,36 @@ pub unsafe extern "C" fn wickra_trend_strength_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trend_strength_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trend_strength_index_warmup_period( + handle: *mut TrendStrengthIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trend_strength_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trend_strength_index_is_ready( + handle: *mut TrendStrengthIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9256,6 +12835,32 @@ pub unsafe extern "C" fn wickra_trendflex_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trendflex_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trendflex_warmup_period(handle: *mut Trendflex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trendflex_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trendflex_is_ready(handle: *mut Trendflex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9323,6 +12928,32 @@ pub unsafe extern "C" fn wickra_trima_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trima_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trima_warmup_period(handle: *mut Trima) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trima_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trima_is_ready(handle: *mut Trima) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9390,6 +13021,32 @@ pub unsafe extern "C" fn wickra_trix_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trix_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trix_warmup_period(handle: *mut Trix) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trix_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trix_is_ready(handle: *mut Trix) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9457,6 +13114,32 @@ pub unsafe extern "C" fn wickra_tsf_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsf_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsf_warmup_period(handle: *mut Tsf) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsf_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsf_is_ready(handle: *mut Tsf) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9527,6 +13210,32 @@ pub unsafe extern "C" fn wickra_tsf_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsf_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsf_oscillator_warmup_period(handle: *mut TsfOscillator) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsf_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsf_oscillator_is_ready(handle: *mut TsfOscillator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9594,6 +13303,32 @@ pub unsafe extern "C" fn wickra_tsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsi_warmup_period(handle: *mut Tsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsi_is_ready(handle: *mut Tsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9661,6 +13396,32 @@ pub unsafe extern "C" fn wickra_ulcer_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ulcer_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ulcer_index_warmup_period(handle: *mut UlcerIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ulcer_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ulcer_index_is_ready(handle: *mut UlcerIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9731,6 +13492,36 @@ pub unsafe extern "C" fn wickra_universal_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_universal_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_universal_oscillator_warmup_period( + handle: *mut UniversalOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_universal_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_universal_oscillator_is_ready( + handle: *mut UniversalOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9804,6 +13595,36 @@ pub unsafe extern "C" fn wickra_upside_potential_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_upside_potential_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_upside_potential_ratio_warmup_period( + handle: *mut UpsidePotentialRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_upside_potential_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_upside_potential_ratio_is_ready( + handle: *mut UpsidePotentialRatio, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9871,6 +13692,32 @@ pub unsafe extern "C" fn wickra_value_at_risk_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_value_at_risk_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_value_at_risk_warmup_period(handle: *mut ValueAtRisk) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_value_at_risk_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_value_at_risk_is_ready(handle: *mut ValueAtRisk) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -9938,6 +13785,32 @@ pub unsafe extern "C" fn wickra_variance_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_variance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_variance_warmup_period(handle: *mut Variance) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_variance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_variance_is_ready(handle: *mut Variance) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10010,6 +13883,36 @@ pub unsafe extern "C" fn wickra_vertical_horizontal_filter_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vertical_horizontal_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vertical_horizontal_filter_warmup_period( + handle: *mut VerticalHorizontalFilter, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vertical_horizontal_filter_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vertical_horizontal_filter_is_ready( + handle: *mut VerticalHorizontalFilter, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10081,6 +13984,32 @@ pub unsafe extern "C" fn wickra_vidya_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vidya_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vidya_warmup_period(handle: *mut Vidya) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vidya_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vidya_is_ready(handle: *mut Vidya) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10154,6 +14083,36 @@ pub unsafe extern "C" fn wickra_volatility_of_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volatility_of_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volatility_of_volatility_warmup_period( + handle: *mut VolatilityOfVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volatility_of_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volatility_of_volatility_is_ready( + handle: *mut VolatilityOfVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10223,6 +14182,32 @@ pub unsafe extern "C" fn wickra_wave_pm_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wave_pm_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wave_pm_warmup_period(handle: *mut WavePm) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wave_pm_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wave_pm_is_ready(handle: *mut WavePm) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10290,6 +14275,32 @@ pub unsafe extern "C" fn wickra_win_rate_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_win_rate_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_win_rate_warmup_period(handle: *mut WinRate) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_win_rate_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_win_rate_is_ready(handle: *mut WinRate) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10357,6 +14368,32 @@ pub unsafe extern "C" fn wickra_wma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wma_warmup_period(handle: *mut Wma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wma_is_ready(handle: *mut Wma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10424,6 +14461,32 @@ pub unsafe extern "C" fn wickra_z_score_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_z_score_warmup_period(handle: *mut ZScore) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_z_score_is_ready(handle: *mut ZScore) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10491,6 +14554,32 @@ pub unsafe extern "C" fn wickra_zlema_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_zlema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_zlema_warmup_period(handle: *mut Zlema) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_zlema_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_zlema_is_ready(handle: *mut Zlema) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10562,6 +14651,32 @@ pub unsafe extern "C" fn wickra_alpha_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_alpha_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_alpha_warmup_period(handle: *mut Alpha) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_alpha_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_alpha_is_ready(handle: *mut Alpha) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10631,6 +14746,32 @@ pub unsafe extern "C" fn wickra_beta_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_beta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_beta_warmup_period(handle: *mut Beta) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_beta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_beta_is_ready(handle: *mut Beta) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10704,6 +14845,36 @@ pub unsafe extern "C" fn wickra_beta_neutral_spread_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_beta_neutral_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_beta_neutral_spread_warmup_period( + handle: *mut BetaNeutralSpread, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_beta_neutral_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_beta_neutral_spread_is_ready( + handle: *mut BetaNeutralSpread, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10777,6 +14948,32 @@ pub unsafe extern "C" fn wickra_distance_ssd_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_distance_ssd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_distance_ssd_warmup_period(handle: *mut DistanceSsd) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_distance_ssd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_distance_ssd_is_ready(handle: *mut DistanceSsd) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10850,6 +15047,34 @@ pub unsafe extern "C" fn wickra_granger_causality_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_granger_causality_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_granger_causality_warmup_period( + handle: *mut GrangerCausality, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_granger_causality_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_granger_causality_is_ready(handle: *mut GrangerCausality) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -10925,6 +15150,36 @@ pub unsafe extern "C" fn wickra_hasbrouck_information_share_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hasbrouck_information_share_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hasbrouck_information_share_warmup_period( + handle: *mut HasbrouckInformationShare, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hasbrouck_information_share_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hasbrouck_information_share_is_ready( + handle: *mut HasbrouckInformationShare, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11002,6 +15257,34 @@ pub unsafe extern "C" fn wickra_information_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_information_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_information_ratio_warmup_period( + handle: *mut InformationRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_information_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_information_ratio_is_ready(handle: *mut InformationRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11071,6 +15354,32 @@ pub unsafe extern "C" fn wickra_kendall_tau_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kendall_tau_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kendall_tau_warmup_period(handle: *mut KendallTau) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kendall_tau_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kendall_tau_is_ready(handle: *mut KendallTau) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11144,6 +15453,32 @@ pub unsafe extern "C" fn wickra_ou_half_life_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ou_half_life_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ou_half_life_warmup_period(handle: *mut OuHalfLife) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ou_half_life_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ou_half_life_is_ready(handle: *mut OuHalfLife) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11220,6 +15555,36 @@ pub unsafe extern "C" fn wickra_pair_spread_z_score_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pair_spread_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pair_spread_z_score_warmup_period( + handle: *mut PairSpreadZScore, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pair_spread_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pair_spread_z_score_is_ready( + handle: *mut PairSpreadZScore, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11293,6 +15658,32 @@ pub unsafe extern "C" fn wickra_pairwise_beta_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pairwise_beta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pairwise_beta_warmup_period(handle: *mut PairwiseBeta) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pairwise_beta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pairwise_beta_is_ready(handle: *mut PairwiseBeta) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11366,6 +15757,36 @@ pub unsafe extern "C" fn wickra_pearson_correlation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pearson_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pearson_correlation_warmup_period( + handle: *mut PearsonCorrelation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pearson_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pearson_correlation_is_ready( + handle: *mut PearsonCorrelation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11439,6 +15860,36 @@ pub unsafe extern "C" fn wickra_rolling_correlation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_correlation_warmup_period( + handle: *mut RollingCorrelation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_correlation_is_ready( + handle: *mut RollingCorrelation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11512,6 +15963,36 @@ pub unsafe extern "C" fn wickra_rolling_covariance_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_covariance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_covariance_warmup_period( + handle: *mut RollingCovariance, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_covariance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_covariance_is_ready( + handle: *mut RollingCovariance, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11585,6 +16066,36 @@ pub unsafe extern "C" fn wickra_spearman_correlation_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spearman_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spearman_correlation_warmup_period( + handle: *mut SpearmanCorrelation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spearman_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spearman_correlation_is_ready( + handle: *mut SpearmanCorrelation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11658,6 +16169,36 @@ pub unsafe extern "C" fn wickra_spread_ar1_coefficient_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spread_ar1_coefficient_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spread_ar1_coefficient_warmup_period( + handle: *mut SpreadAr1Coefficient, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spread_ar1_coefficient_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spread_ar1_coefficient_is_ready( + handle: *mut SpreadAr1Coefficient, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11731,6 +16272,32 @@ pub unsafe extern "C" fn wickra_spread_hurst_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spread_hurst_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spread_hurst_warmup_period(handle: *mut SpreadHurst) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spread_hurst_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spread_hurst_is_ready(handle: *mut SpreadHurst) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11804,6 +16371,32 @@ pub unsafe extern "C" fn wickra_treynor_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_treynor_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_treynor_ratio_warmup_period(handle: *mut TreynorRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_treynor_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_treynor_ratio_is_ready(handle: *mut TreynorRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11877,6 +16470,32 @@ pub unsafe extern "C" fn wickra_variance_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_variance_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_variance_ratio_warmup_period(handle: *mut VarianceRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_variance_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_variance_ratio_is_ready(handle: *mut VarianceRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -11985,6 +16604,32 @@ pub unsafe extern "C" fn wickra_abandoned_baby_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_abandoned_baby_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_abandoned_baby_warmup_period(handle: *mut AbandonedBaby) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_abandoned_baby_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_abandoned_baby_is_ready(handle: *mut AbandonedBaby) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12091,6 +16736,32 @@ pub unsafe extern "C" fn wickra_abcd_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_abcd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_abcd_warmup_period(handle: *mut Abcd) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_abcd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_abcd_is_ready(handle: *mut Abcd) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12204,6 +16875,36 @@ pub unsafe extern "C" fn wickra_accelerator_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_accelerator_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_accelerator_oscillator_warmup_period( + handle: *mut AcceleratorOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_accelerator_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_accelerator_oscillator_is_ready( + handle: *mut AcceleratorOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12310,6 +17011,32 @@ pub unsafe extern "C" fn wickra_ad_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ad_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ad_oscillator_warmup_period(handle: *mut AdOscillator) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ad_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ad_oscillator_is_ready(handle: *mut AdOscillator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12419,6 +17146,32 @@ pub unsafe extern "C" fn wickra_adaptive_cci_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_cci_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_cci_warmup_period(handle: *mut AdaptiveCci) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adaptive_cci_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adaptive_cci_is_ready(handle: *mut AdaptiveCci) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12525,6 +17278,32 @@ pub unsafe extern "C" fn wickra_adl_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adl_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adl_warmup_period(handle: *mut Adl) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adl_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adl_is_ready(handle: *mut Adl) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12631,6 +17410,32 @@ pub unsafe extern "C" fn wickra_advance_block_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_advance_block_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_advance_block_warmup_period(handle: *mut AdvanceBlock) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_advance_block_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_advance_block_is_ready(handle: *mut AdvanceBlock) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12740,6 +17545,32 @@ pub unsafe extern "C" fn wickra_adxr_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adxr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adxr_warmup_period(handle: *mut Adxr) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adxr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adxr_is_ready(handle: *mut Adxr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12846,6 +17677,32 @@ pub unsafe extern "C" fn wickra_anchored_vwap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_anchored_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_anchored_vwap_warmup_period(handle: *mut AnchoredVwap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_anchored_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_anchored_vwap_is_ready(handle: *mut AnchoredVwap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -12955,6 +17812,34 @@ pub unsafe extern "C" fn wickra_aroon_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_aroon_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_aroon_oscillator_warmup_period( + handle: *mut AroonOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_aroon_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_aroon_oscillator_is_ready(handle: *mut AroonOscillator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13064,6 +17949,32 @@ pub unsafe extern "C" fn wickra_atr_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_warmup_period(handle: *mut Atr) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_is_ready(handle: *mut Atr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13176,6 +18087,34 @@ pub unsafe extern "C" fn wickra_atr_trailing_stop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_trailing_stop_warmup_period( + handle: *mut AtrTrailingStop, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_trailing_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_trailing_stop_is_ready(handle: *mut AtrTrailingStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13288,6 +18227,36 @@ pub unsafe extern "C" fn wickra_average_daily_range_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_average_daily_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_average_daily_range_warmup_period( + handle: *mut AverageDailyRange, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_average_daily_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_average_daily_range_is_ready( + handle: *mut AverageDailyRange, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13394,6 +18363,32 @@ pub unsafe extern "C" fn wickra_avg_price_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_avg_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_avg_price_warmup_period(handle: *mut AvgPrice) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_avg_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_avg_price_is_ready(handle: *mut AvgPrice) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13506,6 +18501,36 @@ pub unsafe extern "C" fn wickra_awesome_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_awesome_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_awesome_oscillator_warmup_period( + handle: *mut AwesomeOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_awesome_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_awesome_oscillator_is_ready( + handle: *mut AwesomeOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13619,6 +18644,36 @@ pub unsafe extern "C" fn wickra_awesome_oscillator_histogram_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_awesome_oscillator_histogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_awesome_oscillator_histogram_warmup_period( + handle: *mut AwesomeOscillatorHistogram, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_awesome_oscillator_histogram_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_awesome_oscillator_histogram_is_ready( + handle: *mut AwesomeOscillatorHistogram, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13729,6 +18784,34 @@ pub unsafe extern "C" fn wickra_balance_of_power_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_balance_of_power_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_balance_of_power_warmup_period( + handle: *mut BalanceOfPower, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_balance_of_power_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_balance_of_power_is_ready(handle: *mut BalanceOfPower) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13835,6 +18918,32 @@ pub unsafe extern "C" fn wickra_bat_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bat_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bat_warmup_period(handle: *mut Bat) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bat_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bat_is_ready(handle: *mut Bat) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -13941,6 +19050,32 @@ pub unsafe extern "C" fn wickra_belt_hold_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_belt_hold_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_belt_hold_warmup_period(handle: *mut BeltHold) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_belt_hold_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_belt_hold_is_ready(handle: *mut BeltHold) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14050,6 +19185,32 @@ pub unsafe extern "C" fn wickra_better_volume_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_better_volume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_better_volume_warmup_period(handle: *mut BetterVolume) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_better_volume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_better_volume_is_ready(handle: *mut BetterVolume) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14156,6 +19317,32 @@ pub unsafe extern "C" fn wickra_body_size_pct_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_body_size_pct_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_body_size_pct_warmup_period(handle: *mut BodySizePct) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_body_size_pct_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_body_size_pct_is_ready(handle: *mut BodySizePct) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14262,6 +19449,32 @@ pub unsafe extern "C" fn wickra_breakaway_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_breakaway_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_breakaway_warmup_period(handle: *mut Breakaway) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_breakaway_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_breakaway_is_ready(handle: *mut Breakaway) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14368,6 +19581,32 @@ pub unsafe extern "C" fn wickra_butterfly_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_butterfly_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_butterfly_warmup_period(handle: *mut Butterfly) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_butterfly_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_butterfly_is_ready(handle: *mut Butterfly) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14477,6 +19716,32 @@ pub unsafe extern "C" fn wickra_cci_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cci_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cci_warmup_period(handle: *mut Cci) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cci_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cci_is_ready(handle: *mut Cci) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14589,6 +19854,36 @@ pub unsafe extern "C" fn wickra_chaikin_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chaikin_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chaikin_oscillator_warmup_period( + handle: *mut ChaikinOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chaikin_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chaikin_oscillator_is_ready( + handle: *mut ChaikinOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14701,6 +19996,36 @@ pub unsafe extern "C" fn wickra_chaikin_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chaikin_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chaikin_volatility_warmup_period( + handle: *mut ChaikinVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chaikin_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chaikin_volatility_is_ready( + handle: *mut ChaikinVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14810,6 +20135,34 @@ pub unsafe extern "C" fn wickra_choppiness_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_choppiness_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_choppiness_index_warmup_period( + handle: *mut ChoppinessIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_choppiness_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_choppiness_index_is_ready(handle: *mut ChoppinessIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -14916,6 +20269,32 @@ pub unsafe extern "C" fn wickra_close_vs_open_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_close_vs_open_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_close_vs_open_warmup_period(handle: *mut CloseVsOpen) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_close_vs_open_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_close_vs_open_is_ready(handle: *mut CloseVsOpen) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15022,6 +20401,34 @@ pub unsafe extern "C" fn wickra_closing_marubozu_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_closing_marubozu_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_closing_marubozu_warmup_period( + handle: *mut ClosingMarubozu, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_closing_marubozu_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_closing_marubozu_is_ready(handle: *mut ClosingMarubozu) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15131,6 +20538,34 @@ pub unsafe extern "C" fn wickra_chaikin_money_flow_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chaikin_money_flow_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chaikin_money_flow_warmup_period( + handle: *mut ChaikinMoneyFlow, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chaikin_money_flow_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chaikin_money_flow_is_ready(handle: *mut ChaikinMoneyFlow) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15237,6 +20672,36 @@ pub unsafe extern "C" fn wickra_concealing_baby_swallow_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_concealing_baby_swallow_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_concealing_baby_swallow_warmup_period( + handle: *mut ConcealingBabySwallow, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_concealing_baby_swallow_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_concealing_baby_swallow_is_ready( + handle: *mut ConcealingBabySwallow, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15343,6 +20808,32 @@ pub unsafe extern "C" fn wickra_counterattack_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_counterattack_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_counterattack_warmup_period(handle: *mut Counterattack) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_counterattack_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_counterattack_is_ready(handle: *mut Counterattack) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15449,6 +20940,32 @@ pub unsafe extern "C" fn wickra_crab_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_crab_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_crab_warmup_period(handle: *mut Crab) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_crab_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_crab_is_ready(handle: *mut Crab) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15555,6 +21072,32 @@ pub unsafe extern "C" fn wickra_cup_and_handle_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cup_and_handle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cup_and_handle_warmup_period(handle: *mut CupAndHandle) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cup_and_handle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cup_and_handle_is_ready(handle: *mut CupAndHandle) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15661,6 +21204,32 @@ pub unsafe extern "C" fn wickra_cypher_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cypher_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cypher_warmup_period(handle: *mut Cypher) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cypher_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cypher_is_ready(handle: *mut Cypher) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15770,6 +21339,32 @@ pub unsafe extern "C" fn wickra_demand_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_demand_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_demand_index_warmup_period(handle: *mut DemandIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_demand_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_demand_index_is_ready(handle: *mut DemandIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15876,6 +21471,32 @@ pub unsafe extern "C" fn wickra_doji_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_doji_warmup_period(handle: *mut Doji) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_doji_is_ready(handle: *mut Doji) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -15982,6 +21603,32 @@ pub unsafe extern "C" fn wickra_doji_star_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_doji_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_doji_star_warmup_period(handle: *mut DojiStar) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_doji_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_doji_star_is_ready(handle: *mut DojiStar) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16088,6 +21735,34 @@ pub unsafe extern "C" fn wickra_double_top_bottom_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_double_top_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_double_top_bottom_warmup_period( + handle: *mut DoubleTopBottom, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_double_top_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_double_top_bottom_is_ready(handle: *mut DoubleTopBottom) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16194,6 +21869,36 @@ pub unsafe extern "C" fn wickra_downside_gap_three_methods_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_downside_gap_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_downside_gap_three_methods_warmup_period( + handle: *mut DownsideGapThreeMethods, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_downside_gap_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_downside_gap_three_methods_is_ready( + handle: *mut DownsideGapThreeMethods, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16304,6 +22009,32 @@ pub unsafe extern "C" fn wickra_dragonfly_doji_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dragonfly_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dragonfly_doji_warmup_period(handle: *mut DragonflyDoji) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dragonfly_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dragonfly_doji_is_ready(handle: *mut DragonflyDoji) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16413,6 +22144,32 @@ pub unsafe extern "C" fn wickra_dumpling_top_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dumpling_top_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dumpling_top_warmup_period(handle: *mut DumplingTop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dumpling_top_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dumpling_top_is_ready(handle: *mut DumplingTop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16522,6 +22279,32 @@ pub unsafe extern "C" fn wickra_dx_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dx_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dx_warmup_period(handle: *mut Dx) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_dx_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_dx_is_ready(handle: *mut Dx) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16631,6 +22414,34 @@ pub unsafe extern "C" fn wickra_ease_of_movement_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ease_of_movement_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ease_of_movement_warmup_period( + handle: *mut EaseOfMovement, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ease_of_movement_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ease_of_movement_is_ready(handle: *mut EaseOfMovement) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16737,6 +22548,32 @@ pub unsafe extern "C" fn wickra_engulfing_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_engulfing_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_engulfing_warmup_period(handle: *mut Engulfing) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_engulfing_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_engulfing_is_ready(handle: *mut Engulfing) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16843,6 +22680,34 @@ pub unsafe extern "C" fn wickra_evening_doji_star_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_evening_doji_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_evening_doji_star_warmup_period( + handle: *mut EveningDojiStar, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_evening_doji_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_evening_doji_star_is_ready(handle: *mut EveningDojiStar) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -16952,6 +22817,32 @@ pub unsafe extern "C" fn wickra_evwma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_evwma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_evwma_warmup_period(handle: *mut Evwma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_evwma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_evwma_is_ready(handle: *mut Evwma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17058,6 +22949,36 @@ pub unsafe extern "C" fn wickra_falling_three_methods_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_falling_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_falling_three_methods_warmup_period( + handle: *mut FallingThreeMethods, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_falling_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_falling_three_methods_is_ready( + handle: *mut FallingThreeMethods, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17164,6 +23085,32 @@ pub unsafe extern "C" fn wickra_flag_pennant_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_flag_pennant_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_flag_pennant_warmup_period(handle: *mut FlagPennant) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_flag_pennant_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_flag_pennant_is_ready(handle: *mut FlagPennant) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17273,6 +23220,32 @@ pub unsafe extern "C" fn wickra_force_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_force_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_force_index_warmup_period(handle: *mut ForceIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_force_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_force_index_is_ready(handle: *mut ForceIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17382,6 +23355,32 @@ pub unsafe extern "C" fn wickra_fry_pan_bottom_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fry_pan_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fry_pan_bottom_warmup_period(handle: *mut FryPanBottom) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fry_pan_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fry_pan_bottom_is_ready(handle: *mut FryPanBottom) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17488,6 +23487,36 @@ pub unsafe extern "C" fn wickra_gap_side_by_side_white_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gap_side_by_side_white_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gap_side_by_side_white_warmup_period( + handle: *mut GapSideBySideWhite, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gap_side_by_side_white_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gap_side_by_side_white_is_ready( + handle: *mut GapSideBySideWhite, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17600,6 +23629,36 @@ pub unsafe extern "C" fn wickra_garman_klass_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_garman_klass_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_garman_klass_volatility_warmup_period( + handle: *mut GarmanKlassVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_garman_klass_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_garman_klass_volatility_is_ready( + handle: *mut GarmanKlassVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17706,6 +23765,32 @@ pub unsafe extern "C" fn wickra_gartley_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gartley_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gartley_warmup_period(handle: *mut Gartley) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gartley_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gartley_is_ready(handle: *mut Gartley) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17812,6 +23897,34 @@ pub unsafe extern "C" fn wickra_gravestone_doji_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gravestone_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gravestone_doji_warmup_period( + handle: *mut GravestoneDoji, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gravestone_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gravestone_doji_is_ready(handle: *mut GravestoneDoji) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -17918,6 +24031,32 @@ pub unsafe extern "C" fn wickra_hammer_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hammer_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hammer_warmup_period(handle: *mut Hammer) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hammer_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hammer_is_ready(handle: *mut Hammer) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18024,6 +24163,32 @@ pub unsafe extern "C" fn wickra_hanging_man_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hanging_man_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hanging_man_warmup_period(handle: *mut HangingMan) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hanging_man_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hanging_man_is_ready(handle: *mut HangingMan) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18130,6 +24295,32 @@ pub unsafe extern "C" fn wickra_harami_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_harami_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_harami_warmup_period(handle: *mut Harami) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_harami_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_harami_is_ready(handle: *mut Harami) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18236,6 +24427,32 @@ pub unsafe extern "C" fn wickra_harami_cross_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_harami_cross_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_harami_cross_warmup_period(handle: *mut HaramiCross) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_harami_cross_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_harami_cross_is_ready(handle: *mut HaramiCross) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18342,6 +24559,34 @@ pub unsafe extern "C" fn wickra_head_and_shoulders_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_head_and_shoulders_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_head_and_shoulders_warmup_period( + handle: *mut HeadAndShoulders, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_head_and_shoulders_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_head_and_shoulders_is_ready(handle: *mut HeadAndShoulders) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18451,6 +24696,36 @@ pub unsafe extern "C" fn wickra_heikin_ashi_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_heikin_ashi_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_heikin_ashi_oscillator_warmup_period( + handle: *mut HeikinAshiOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_heikin_ashi_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_heikin_ashi_oscillator_is_ready( + handle: *mut HeikinAshiOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18557,6 +24832,32 @@ pub unsafe extern "C" fn wickra_high_low_range_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_low_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_low_range_warmup_period(handle: *mut HighLowRange) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_low_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_low_range_is_ready(handle: *mut HighLowRange) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18663,6 +24964,32 @@ pub unsafe extern "C" fn wickra_high_wave_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_wave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_wave_warmup_period(handle: *mut HighWave) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_wave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_wave_is_ready(handle: *mut HighWave) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18769,6 +25096,32 @@ pub unsafe extern "C" fn wickra_hikkake_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hikkake_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hikkake_warmup_period(handle: *mut Hikkake) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hikkake_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hikkake_is_ready(handle: *mut Hikkake) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18875,6 +25228,34 @@ pub unsafe extern "C" fn wickra_hikkake_modified_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hikkake_modified_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hikkake_modified_warmup_period( + handle: *mut HikkakeModified, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hikkake_modified_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hikkake_modified_is_ready(handle: *mut HikkakeModified) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -18984,6 +25365,32 @@ pub unsafe extern "C" fn wickra_hi_lo_activator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hi_lo_activator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hi_lo_activator_warmup_period(handle: *mut HiLoActivator) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hi_lo_activator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hi_lo_activator_is_ready(handle: *mut HiLoActivator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19090,6 +25497,32 @@ pub unsafe extern "C" fn wickra_homing_pigeon_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_homing_pigeon_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_homing_pigeon_warmup_period(handle: *mut HomingPigeon) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_homing_pigeon_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_homing_pigeon_is_ready(handle: *mut HomingPigeon) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19196,6 +25629,36 @@ pub unsafe extern "C" fn wickra_identical_three_crows_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_identical_three_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_identical_three_crows_warmup_period( + handle: *mut IdenticalThreeCrows, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_identical_three_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_identical_three_crows_is_ready( + handle: *mut IdenticalThreeCrows, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19302,6 +25765,32 @@ pub unsafe extern "C" fn wickra_in_neck_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_in_neck_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_in_neck_warmup_period(handle: *mut InNeck) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_in_neck_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_in_neck_is_ready(handle: *mut InNeck) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19411,6 +25900,32 @@ pub unsafe extern "C" fn wickra_inertia_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_inertia_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_inertia_warmup_period(handle: *mut Inertia) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_inertia_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_inertia_is_ready(handle: *mut Inertia) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19517,6 +26032,36 @@ pub unsafe extern "C" fn wickra_intraday_intensity_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_intraday_intensity_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_intraday_intensity_warmup_period( + handle: *mut IntradayIntensity, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_intraday_intensity_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_intraday_intensity_is_ready( + handle: *mut IntradayIntensity, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19626,6 +26171,36 @@ pub unsafe extern "C" fn wickra_intraday_momentum_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_intraday_momentum_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_intraday_momentum_index_warmup_period( + handle: *mut IntradayMomentumIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_intraday_momentum_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_intraday_momentum_index_is_ready( + handle: *mut IntradayMomentumIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19732,6 +26307,34 @@ pub unsafe extern "C" fn wickra_inverted_hammer_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_inverted_hammer_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_inverted_hammer_warmup_period( + handle: *mut InvertedHammer, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_inverted_hammer_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_inverted_hammer_is_ready(handle: *mut InvertedHammer) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19838,6 +26441,32 @@ pub unsafe extern "C" fn wickra_kicking_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kicking_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kicking_warmup_period(handle: *mut Kicking) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kicking_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kicking_is_ready(handle: *mut Kicking) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -19944,6 +26573,34 @@ pub unsafe extern "C" fn wickra_kicking_by_length_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kicking_by_length_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kicking_by_length_warmup_period( + handle: *mut KickingByLength, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kicking_by_length_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kicking_by_length_is_ready(handle: *mut KickingByLength) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20053,6 +26710,32 @@ pub unsafe extern "C" fn wickra_kvo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kvo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kvo_warmup_period(handle: *mut Kvo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kvo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kvo_is_ready(handle: *mut Kvo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20159,6 +26842,32 @@ pub unsafe extern "C" fn wickra_ladder_bottom_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ladder_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ladder_bottom_warmup_period(handle: *mut LadderBottom) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ladder_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ladder_bottom_is_ready(handle: *mut LadderBottom) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20265,6 +26974,34 @@ pub unsafe extern "C" fn wickra_long_legged_doji_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_long_legged_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_long_legged_doji_warmup_period( + handle: *mut LongLeggedDoji, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_long_legged_doji_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_long_legged_doji_is_ready(handle: *mut LongLeggedDoji) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20371,6 +27108,32 @@ pub unsafe extern "C" fn wickra_long_line_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_long_line_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_long_line_warmup_period(handle: *mut LongLine) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_long_line_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_long_line_is_ready(handle: *mut LongLine) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20477,6 +27240,36 @@ pub unsafe extern "C" fn wickra_market_facilitation_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_market_facilitation_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_market_facilitation_index_warmup_period( + handle: *mut MarketFacilitationIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_market_facilitation_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_market_facilitation_index_is_ready( + handle: *mut MarketFacilitationIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20587,6 +27380,32 @@ pub unsafe extern "C" fn wickra_marubozu_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_marubozu_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_marubozu_warmup_period(handle: *mut Marubozu) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_marubozu_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_marubozu_is_ready(handle: *mut Marubozu) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20696,6 +27515,32 @@ pub unsafe extern "C" fn wickra_mass_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mass_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mass_index_warmup_period(handle: *mut MassIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mass_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mass_index_is_ready(handle: *mut MassIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20802,6 +27647,32 @@ pub unsafe extern "C" fn wickra_mat_hold_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mat_hold_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mat_hold_warmup_period(handle: *mut MatHold) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mat_hold_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mat_hold_is_ready(handle: *mut MatHold) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -20908,6 +27779,32 @@ pub unsafe extern "C" fn wickra_matching_low_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_matching_low_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_matching_low_warmup_period(handle: *mut MatchingLow) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_matching_low_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_matching_low_is_ready(handle: *mut MatchingLow) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21014,6 +27911,32 @@ pub unsafe extern "C" fn wickra_median_price_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_price_warmup_period(handle: *mut MedianPrice) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_price_is_ready(handle: *mut MedianPrice) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21123,6 +28046,32 @@ pub unsafe extern "C" fn wickra_mfi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mfi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mfi_warmup_period(handle: *mut Mfi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mfi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mfi_is_ready(handle: *mut Mfi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21232,6 +28181,32 @@ pub unsafe extern "C" fn wickra_mid_price_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mid_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mid_price_warmup_period(handle: *mut MidPrice) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mid_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mid_price_is_ready(handle: *mut MidPrice) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21341,6 +28316,32 @@ pub unsafe extern "C" fn wickra_minus_di_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_minus_di_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_minus_di_warmup_period(handle: *mut MinusDi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_minus_di_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_minus_di_is_ready(handle: *mut MinusDi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21450,6 +28451,32 @@ pub unsafe extern "C" fn wickra_minus_dm_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_minus_dm_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_minus_dm_warmup_period(handle: *mut MinusDm) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_minus_dm_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_minus_dm_is_ready(handle: *mut MinusDm) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21556,6 +28583,34 @@ pub unsafe extern "C" fn wickra_morning_doji_star_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_morning_doji_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_morning_doji_star_warmup_period( + handle: *mut MorningDojiStar, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_morning_doji_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_morning_doji_star_is_ready(handle: *mut MorningDojiStar) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21662,6 +28717,36 @@ pub unsafe extern "C" fn wickra_morning_evening_star_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_morning_evening_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_morning_evening_star_warmup_period( + handle: *mut MorningEveningStar, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_morning_evening_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_morning_evening_star_is_ready( + handle: *mut MorningEveningStar, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21771,6 +28856,32 @@ pub unsafe extern "C" fn wickra_naked_poc_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_naked_poc_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_naked_poc_warmup_period(handle: *mut NakedPoc) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_naked_poc_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_naked_poc_is_ready(handle: *mut NakedPoc) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21880,6 +28991,32 @@ pub unsafe extern "C" fn wickra_natr_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_natr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_natr_warmup_period(handle: *mut Natr) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_natr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_natr_is_ready(handle: *mut Natr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -21989,6 +29126,32 @@ pub unsafe extern "C" fn wickra_new_price_lines_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_new_price_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_new_price_lines_warmup_period(handle: *mut NewPriceLines) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_new_price_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_new_price_lines_is_ready(handle: *mut NewPriceLines) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22095,6 +29258,32 @@ pub unsafe extern "C" fn wickra_nvi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_nvi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_nvi_warmup_period(handle: *mut Nvi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_nvi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_nvi_is_ready(handle: *mut Nvi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22201,6 +29390,32 @@ pub unsafe extern "C" fn wickra_obv_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_obv_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_obv_warmup_period(handle: *mut Obv) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_obv_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_obv_is_ready(handle: *mut Obv) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22307,6 +29522,32 @@ pub unsafe extern "C" fn wickra_on_neck_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_on_neck_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_on_neck_warmup_period(handle: *mut OnNeck) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_on_neck_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_on_neck_is_ready(handle: *mut OnNeck) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22413,6 +29654,34 @@ pub unsafe extern "C" fn wickra_opening_marubozu_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_opening_marubozu_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_opening_marubozu_warmup_period( + handle: *mut OpeningMarubozu, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_opening_marubozu_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_opening_marubozu_is_ready(handle: *mut OpeningMarubozu) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22519,6 +29788,32 @@ pub unsafe extern "C" fn wickra_overnight_gap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_overnight_gap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_overnight_gap_warmup_period(handle: *mut OvernightGap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_overnight_gap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_overnight_gap_is_ready(handle: *mut OvernightGap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22631,6 +29926,36 @@ pub unsafe extern "C" fn wickra_parkinson_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_parkinson_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_parkinson_volatility_warmup_period( + handle: *mut ParkinsonVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_parkinson_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_parkinson_volatility_is_ready( + handle: *mut ParkinsonVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22740,6 +30065,32 @@ pub unsafe extern "C" fn wickra_pgo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pgo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pgo_warmup_period(handle: *mut Pgo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pgo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pgo_is_ready(handle: *mut Pgo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22846,6 +30197,36 @@ pub unsafe extern "C" fn wickra_piercing_dark_cloud_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_piercing_dark_cloud_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_piercing_dark_cloud_warmup_period( + handle: *mut PiercingDarkCloud, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_piercing_dark_cloud_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_piercing_dark_cloud_is_ready( + handle: *mut PiercingDarkCloud, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -22955,6 +30336,32 @@ pub unsafe extern "C" fn wickra_pivot_reversal_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pivot_reversal_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pivot_reversal_warmup_period(handle: *mut PivotReversal) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pivot_reversal_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pivot_reversal_is_ready(handle: *mut PivotReversal) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23064,6 +30471,32 @@ pub unsafe extern "C" fn wickra_plus_di_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_plus_di_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_plus_di_warmup_period(handle: *mut PlusDi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_plus_di_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_plus_di_is_ready(handle: *mut PlusDi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23173,6 +30606,32 @@ pub unsafe extern "C" fn wickra_plus_dm_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_plus_dm_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_plus_dm_warmup_period(handle: *mut PlusDm) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_plus_dm_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_plus_dm_is_ready(handle: *mut PlusDm) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23282,6 +30741,32 @@ pub unsafe extern "C" fn wickra_profile_shape_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_profile_shape_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_profile_shape_warmup_period(handle: *mut ProfileShape) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_profile_shape_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_profile_shape_is_ready(handle: *mut ProfileShape) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23391,6 +30876,36 @@ pub unsafe extern "C" fn wickra_projection_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_projection_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_projection_oscillator_warmup_period( + handle: *mut ProjectionOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_projection_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_projection_oscillator_is_ready( + handle: *mut ProjectionOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23500,6 +31015,32 @@ pub unsafe extern "C" fn wickra_psar_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_psar_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_psar_warmup_period(handle: *mut Psar) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_psar_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_psar_is_ready(handle: *mut Psar) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23606,6 +31147,32 @@ pub unsafe extern "C" fn wickra_pvi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pvi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pvi_warmup_period(handle: *mut Pvi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pvi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pvi_is_ready(handle: *mut Pvi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23715,6 +31282,32 @@ pub unsafe extern "C" fn wickra_qstick_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_qstick_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_qstick_warmup_period(handle: *mut Qstick) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_qstick_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_qstick_is_ready(handle: *mut Qstick) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23821,6 +31414,34 @@ pub unsafe extern "C" fn wickra_rectangle_range_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rectangle_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rectangle_range_warmup_period( + handle: *mut RectangleRange, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rectangle_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rectangle_range_is_ready(handle: *mut RectangleRange) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -23927,6 +31548,32 @@ pub unsafe extern "C" fn wickra_rickshaw_man_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rickshaw_man_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rickshaw_man_warmup_period(handle: *mut RickshawMan) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rickshaw_man_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rickshaw_man_is_ready(handle: *mut RickshawMan) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24033,6 +31680,36 @@ pub unsafe extern "C" fn wickra_rising_three_methods_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rising_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rising_three_methods_warmup_period( + handle: *mut RisingThreeMethods, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rising_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rising_three_methods_is_ready( + handle: *mut RisingThreeMethods, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24145,6 +31822,36 @@ pub unsafe extern "C" fn wickra_rogers_satchell_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rogers_satchell_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rogers_satchell_volatility_warmup_period( + handle: *mut RogersSatchellVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rogers_satchell_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rogers_satchell_volatility_is_ready( + handle: *mut RogersSatchellVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24258,6 +31965,32 @@ pub unsafe extern "C" fn wickra_rvi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rvi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rvi_warmup_period(handle: *mut Rvi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rvi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rvi_is_ready(handle: *mut Rvi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24385,6 +32118,32 @@ pub unsafe extern "C" fn wickra_sar_ext_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sar_ext_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sar_ext_warmup_period(handle: *mut SarExt) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_sar_ext_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_sar_ext_is_ready(handle: *mut SarExt) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24491,6 +32250,34 @@ pub unsafe extern "C" fn wickra_seasonal_z_score_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_seasonal_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_seasonal_z_score_warmup_period( + handle: *mut SeasonalZScore, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_seasonal_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_seasonal_z_score_is_ready(handle: *mut SeasonalZScore) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24597,6 +32384,34 @@ pub unsafe extern "C" fn wickra_separating_lines_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_separating_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_separating_lines_warmup_period( + handle: *mut SeparatingLines, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_separating_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_separating_lines_is_ready(handle: *mut SeparatingLines) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24703,6 +32518,32 @@ pub unsafe extern "C" fn wickra_session_vwap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_session_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_session_vwap_warmup_period(handle: *mut SessionVwap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_session_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_session_vwap_is_ready(handle: *mut SessionVwap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24809,6 +32650,32 @@ pub unsafe extern "C" fn wickra_shark_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_shark_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_shark_warmup_period(handle: *mut Shark) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_shark_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_shark_is_ready(handle: *mut Shark) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -24915,6 +32782,32 @@ pub unsafe extern "C" fn wickra_shooting_star_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_shooting_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_shooting_star_warmup_period(handle: *mut ShootingStar) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_shooting_star_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_shooting_star_is_ready(handle: *mut ShootingStar) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25021,6 +32914,32 @@ pub unsafe extern "C" fn wickra_short_line_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_short_line_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_short_line_warmup_period(handle: *mut ShortLine) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_short_line_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_short_line_is_ready(handle: *mut ShortLine) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25130,6 +33049,32 @@ pub unsafe extern "C" fn wickra_single_prints_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_single_prints_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_single_prints_warmup_period(handle: *mut SinglePrints) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_single_prints_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_single_prints_is_ready(handle: *mut SinglePrints) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25239,6 +33184,32 @@ pub unsafe extern "C" fn wickra_smi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_smi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_smi_warmup_period(handle: *mut Smi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_smi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_smi_is_ready(handle: *mut Smi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25345,6 +33316,32 @@ pub unsafe extern "C" fn wickra_spinning_top_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spinning_top_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spinning_top_warmup_period(handle: *mut SpinningTop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spinning_top_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spinning_top_is_ready(handle: *mut SpinningTop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25451,6 +33448,34 @@ pub unsafe extern "C" fn wickra_stalled_pattern_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stalled_pattern_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stalled_pattern_warmup_period( + handle: *mut StalledPattern, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stalled_pattern_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stalled_pattern_is_ready(handle: *mut StalledPattern) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25557,6 +33582,32 @@ pub unsafe extern "C" fn wickra_stick_sandwich_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stick_sandwich_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stick_sandwich_warmup_period(handle: *mut StickSandwich) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stick_sandwich_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stick_sandwich_is_ready(handle: *mut StickSandwich) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25666,6 +33717,32 @@ pub unsafe extern "C" fn wickra_stochastic_cci_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stochastic_cci_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stochastic_cci_warmup_period(handle: *mut StochasticCci) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stochastic_cci_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stochastic_cci_is_ready(handle: *mut StochasticCci) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25772,6 +33849,32 @@ pub unsafe extern "C" fn wickra_takuri_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_takuri_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_takuri_warmup_period(handle: *mut Takuri) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_takuri_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_takuri_is_ready(handle: *mut Takuri) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25878,6 +33981,32 @@ pub unsafe extern "C" fn wickra_tasuki_gap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tasuki_gap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tasuki_gap_warmup_period(handle: *mut TasukiGap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tasuki_gap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tasuki_gap_is_ready(handle: *mut TasukiGap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -25984,6 +34113,32 @@ pub unsafe extern "C" fn wickra_td_camouflage_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_camouflage_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_camouflage_warmup_period(handle: *mut TdCamouflage) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_camouflage_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_camouflage_is_ready(handle: *mut TdCamouflage) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26090,6 +34245,32 @@ pub unsafe extern "C" fn wickra_td_clop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_clop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_clop_warmup_period(handle: *mut TdClop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_clop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_clop_is_ready(handle: *mut TdClop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26196,6 +34377,32 @@ pub unsafe extern "C" fn wickra_td_clopwin_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_clopwin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_clopwin_warmup_period(handle: *mut TdClopwin) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_clopwin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_clopwin_is_ready(handle: *mut TdClopwin) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26315,6 +34522,32 @@ pub unsafe extern "C" fn wickra_td_combo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_combo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_combo_warmup_period(handle: *mut TdCombo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_combo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_combo_is_ready(handle: *mut TdCombo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26434,6 +34667,32 @@ pub unsafe extern "C" fn wickra_td_countdown_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_countdown_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_countdown_warmup_period(handle: *mut TdCountdown) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_countdown_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_countdown_is_ready(handle: *mut TdCountdown) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26543,6 +34802,32 @@ pub unsafe extern "C" fn wickra_td_de_marker_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_de_marker_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_de_marker_warmup_period(handle: *mut TdDeMarker) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_de_marker_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_de_marker_is_ready(handle: *mut TdDeMarker) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26649,6 +34934,34 @@ pub unsafe extern "C" fn wickra_td_differential_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_differential_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_differential_warmup_period( + handle: *mut TdDifferential, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_differential_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_differential_is_ready(handle: *mut TdDifferential) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26758,6 +35071,32 @@ pub unsafe extern "C" fn wickra_td_d_wave_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_d_wave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_d_wave_warmup_period(handle: *mut TdDWave) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_d_wave_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_d_wave_is_ready(handle: *mut TdDWave) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26864,6 +35203,32 @@ pub unsafe extern "C" fn wickra_td_open_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_open_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_open_warmup_period(handle: *mut TdOpen) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_open_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_open_is_ready(handle: *mut TdOpen) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -26973,6 +35338,32 @@ pub unsafe extern "C" fn wickra_td_pressure_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_pressure_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_pressure_warmup_period(handle: *mut TdPressure) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_pressure_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_pressure_is_ready(handle: *mut TdPressure) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27079,6 +35470,32 @@ pub unsafe extern "C" fn wickra_td_propulsion_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_propulsion_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_propulsion_warmup_period(handle: *mut TdPropulsion) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_propulsion_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_propulsion_is_ready(handle: *mut TdPropulsion) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27188,6 +35605,32 @@ pub unsafe extern "C" fn wickra_td_rei_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_rei_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_rei_warmup_period(handle: *mut TdRei) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_rei_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_rei_is_ready(handle: *mut TdRei) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27297,6 +35740,32 @@ pub unsafe extern "C" fn wickra_td_setup_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_setup_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_setup_warmup_period(handle: *mut TdSetup) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_setup_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_setup_is_ready(handle: *mut TdSetup) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27403,6 +35872,32 @@ pub unsafe extern "C" fn wickra_td_trap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_trap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_trap_warmup_period(handle: *mut TdTrap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_trap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_trap_is_ready(handle: *mut TdTrap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27509,6 +36004,32 @@ pub unsafe extern "C" fn wickra_three_drives_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_drives_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_drives_warmup_period(handle: *mut ThreeDrives) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_drives_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_drives_is_ready(handle: *mut ThreeDrives) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27615,6 +36136,32 @@ pub unsafe extern "C" fn wickra_three_inside_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_inside_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_inside_warmup_period(handle: *mut ThreeInside) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_inside_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_inside_is_ready(handle: *mut ThreeInside) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27724,6 +36271,34 @@ pub unsafe extern "C" fn wickra_three_line_break_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_line_break_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_line_break_warmup_period( + handle: *mut ThreeLineBreak, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_line_break_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_line_break_is_ready(handle: *mut ThreeLineBreak) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27830,6 +36405,34 @@ pub unsafe extern "C" fn wickra_three_line_strike_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_line_strike_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_line_strike_warmup_period( + handle: *mut ThreeLineStrike, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_line_strike_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_line_strike_is_ready(handle: *mut ThreeLineStrike) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -27936,6 +36539,32 @@ pub unsafe extern "C" fn wickra_three_outside_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_outside_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_outside_warmup_period(handle: *mut ThreeOutside) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_outside_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_outside_is_ready(handle: *mut ThreeOutside) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28042,6 +36671,36 @@ pub unsafe extern "C" fn wickra_three_soldiers_or_crows_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_soldiers_or_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_soldiers_or_crows_warmup_period( + handle: *mut ThreeSoldiersOrCrows, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_soldiers_or_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_soldiers_or_crows_is_ready( + handle: *mut ThreeSoldiersOrCrows, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28148,6 +36807,36 @@ pub unsafe extern "C" fn wickra_three_stars_in_south_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_stars_in_south_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_stars_in_south_warmup_period( + handle: *mut ThreeStarsInSouth, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_three_stars_in_south_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_three_stars_in_south_is_ready( + handle: *mut ThreeStarsInSouth, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28254,6 +36943,32 @@ pub unsafe extern "C" fn wickra_thrusting_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_thrusting_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_thrusting_warmup_period(handle: *mut Thrusting) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_thrusting_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_thrusting_is_ready(handle: *mut Thrusting) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28363,6 +37078,32 @@ pub unsafe extern "C" fn wickra_time_based_stop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_time_based_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_time_based_stop_warmup_period(handle: *mut TimeBasedStop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_time_based_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_time_based_stop_is_ready(handle: *mut TimeBasedStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28469,6 +37210,34 @@ pub unsafe extern "C" fn wickra_tower_top_bottom_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tower_top_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tower_top_bottom_warmup_period( + handle: *mut TowerTopBottom, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tower_top_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tower_top_bottom_is_ready(handle: *mut TowerTopBottom) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28578,6 +37347,34 @@ pub unsafe extern "C" fn wickra_trade_volume_index_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trade_volume_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trade_volume_index_warmup_period( + handle: *mut TradeVolumeIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trade_volume_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trade_volume_index_is_ready(handle: *mut TradeVolumeIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28684,6 +37481,32 @@ pub unsafe extern "C" fn wickra_triangle_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_triangle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_triangle_warmup_period(handle: *mut Triangle) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_triangle_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_triangle_is_ready(handle: *mut Triangle) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28790,6 +37613,34 @@ pub unsafe extern "C" fn wickra_triple_top_bottom_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_triple_top_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_triple_top_bottom_warmup_period( + handle: *mut TripleTopBottom, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_triple_top_bottom_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_triple_top_bottom_is_ready(handle: *mut TripleTopBottom) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -28896,6 +37747,32 @@ pub unsafe extern "C" fn wickra_tristar_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tristar_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tristar_warmup_period(handle: *mut Tristar) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tristar_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tristar_is_ready(handle: *mut Tristar) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29002,6 +37879,32 @@ pub unsafe extern "C" fn wickra_true_range_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_true_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_true_range_warmup_period(handle: *mut TrueRange) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_true_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_true_range_is_ready(handle: *mut TrueRange) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29111,6 +38014,32 @@ pub unsafe extern "C" fn wickra_tsv_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsv_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsv_warmup_period(handle: *mut Tsv) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tsv_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tsv_is_ready(handle: *mut Tsv) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29220,6 +38149,32 @@ pub unsafe extern "C" fn wickra_ttm_trend_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ttm_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ttm_trend_warmup_period(handle: *mut TtmTrend) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ttm_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ttm_trend_is_ready(handle: *mut TtmTrend) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29333,6 +38288,32 @@ pub unsafe extern "C" fn wickra_turn_of_month_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_turn_of_month_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_turn_of_month_warmup_period(handle: *mut TurnOfMonth) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_turn_of_month_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_turn_of_month_is_ready(handle: *mut TurnOfMonth) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29439,6 +38420,32 @@ pub unsafe extern "C" fn wickra_tweezer_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tweezer_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tweezer_warmup_period(handle: *mut Tweezer) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tweezer_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tweezer_is_ready(handle: *mut Tweezer) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29548,6 +38555,34 @@ pub unsafe extern "C" fn wickra_twiggs_money_flow_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_twiggs_money_flow_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_twiggs_money_flow_warmup_period( + handle: *mut TwiggsMoneyFlow, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_twiggs_money_flow_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_twiggs_money_flow_is_ready(handle: *mut TwiggsMoneyFlow) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29654,6 +38689,32 @@ pub unsafe extern "C" fn wickra_two_crows_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_two_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_two_crows_warmup_period(handle: *mut TwoCrows) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_two_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_two_crows_is_ready(handle: *mut TwoCrows) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29760,6 +38821,32 @@ pub unsafe extern "C" fn wickra_typical_price_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_typical_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_typical_price_warmup_period(handle: *mut TypicalPrice) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_typical_price_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_typical_price_is_ready(handle: *mut TypicalPrice) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29873,6 +38960,36 @@ pub unsafe extern "C" fn wickra_ultimate_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ultimate_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ultimate_oscillator_warmup_period( + handle: *mut UltimateOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ultimate_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ultimate_oscillator_is_ready( + handle: *mut UltimateOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -29979,6 +39096,34 @@ pub unsafe extern "C" fn wickra_unique_three_river_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_unique_three_river_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_unique_three_river_warmup_period( + handle: *mut UniqueThreeRiver, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_unique_three_river_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_unique_three_river_is_ready(handle: *mut UniqueThreeRiver) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30085,6 +39230,36 @@ pub unsafe extern "C" fn wickra_upside_gap_three_methods_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_upside_gap_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_upside_gap_three_methods_warmup_period( + handle: *mut UpsideGapThreeMethods, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_upside_gap_three_methods_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_upside_gap_three_methods_is_ready( + handle: *mut UpsideGapThreeMethods, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30191,6 +39366,36 @@ pub unsafe extern "C" fn wickra_upside_gap_two_crows_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_upside_gap_two_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_upside_gap_two_crows_warmup_period( + handle: *mut UpsideGapTwoCrows, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_upside_gap_two_crows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_upside_gap_two_crows_is_ready( + handle: *mut UpsideGapTwoCrows, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30300,6 +39505,34 @@ pub unsafe extern "C" fn wickra_volatility_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volatility_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volatility_ratio_warmup_period( + handle: *mut VolatilityRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volatility_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volatility_ratio_is_ready(handle: *mut VolatilityRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30409,6 +39642,32 @@ pub unsafe extern "C" fn wickra_volty_stop_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volty_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volty_stop_warmup_period(handle: *mut VoltyStop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volty_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volty_stop_is_ready(handle: *mut VoltyStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30518,6 +39777,34 @@ pub unsafe extern "C" fn wickra_volume_oscillator_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_oscillator_warmup_period( + handle: *mut VolumeOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_oscillator_is_ready(handle: *mut VolumeOscillator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30627,6 +39914,32 @@ pub unsafe extern "C" fn wickra_volume_rsi_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_rsi_warmup_period(handle: *mut VolumeRsi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_rsi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_rsi_is_ready(handle: *mut VolumeRsi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30733,6 +40046,34 @@ pub unsafe extern "C" fn wickra_volume_price_trend_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_price_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_price_trend_warmup_period( + handle: *mut VolumePriceTrend, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_price_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_price_trend_is_ready(handle: *mut VolumePriceTrend) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30839,6 +40180,32 @@ pub unsafe extern "C" fn wickra_vwap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vwap_warmup_period(handle: *mut Vwap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vwap_is_ready(handle: *mut Vwap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -30948,6 +40315,32 @@ pub unsafe extern "C" fn wickra_rolling_vwap_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_vwap_warmup_period(handle: *mut RollingVwap) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rolling_vwap_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rolling_vwap_is_ready(handle: *mut RollingVwap) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31057,6 +40450,32 @@ pub unsafe extern "C" fn wickra_vwma_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vwma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vwma_warmup_period(handle: *mut Vwma) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vwma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vwma_is_ready(handle: *mut Vwma) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31166,6 +40585,32 @@ pub unsafe extern "C" fn wickra_vzo_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vzo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vzo_warmup_period(handle: *mut Vzo) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vzo_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vzo_is_ready(handle: *mut Vzo) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31272,6 +40717,32 @@ pub unsafe extern "C" fn wickra_wad_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wad_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wad_warmup_period(handle: *mut Wad) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wad_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wad_is_ready(handle: *mut Wad) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31378,6 +40849,32 @@ pub unsafe extern "C" fn wickra_wedge_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wedge_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wedge_warmup_period(handle: *mut Wedge) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wedge_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wedge_is_ready(handle: *mut Wedge) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31484,6 +40981,32 @@ pub unsafe extern "C" fn wickra_weighted_close_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_weighted_close_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_weighted_close_warmup_period(handle: *mut WeightedClose) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_weighted_close_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_weighted_close_is_ready(handle: *mut WeightedClose) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31590,6 +41113,32 @@ pub unsafe extern "C" fn wickra_wick_ratio_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wick_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wick_ratio_warmup_period(handle: *mut WickRatio) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wick_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wick_ratio_is_ready(handle: *mut WickRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31699,6 +41248,32 @@ pub unsafe extern "C" fn wickra_williams_r_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_williams_r_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_williams_r_warmup_period(handle: *mut WilliamsR) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_williams_r_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_williams_r_is_ready(handle: *mut WilliamsR) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31811,6 +41386,36 @@ pub unsafe extern "C" fn wickra_yang_zhang_volatility_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_yang_zhang_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_yang_zhang_volatility_warmup_period( + handle: *mut YangZhangVolatility, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_yang_zhang_volatility_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_yang_zhang_volatility_is_ready( + handle: *mut YangZhangVolatility, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31920,6 +41525,32 @@ pub unsafe extern "C" fn wickra_yoyo_exit_batch( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_yoyo_exit_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_yoyo_exit_warmup_period(handle: *mut YoyoExit) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_yoyo_exit_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_yoyo_exit_is_ready(handle: *mut YoyoExit) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -31978,6 +41609,36 @@ pub unsafe extern "C" fn wickra_amihud_illiquidity_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_amihud_illiquidity_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_amihud_illiquidity_warmup_period( + handle: *mut AmihudIlliquidity, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_amihud_illiquidity_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_amihud_illiquidity_is_ready( + handle: *mut AmihudIlliquidity, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32031,6 +41692,36 @@ pub unsafe extern "C" fn wickra_cumulative_volume_delta_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cumulative_volume_delta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cumulative_volume_delta_warmup_period( + handle: *mut CumulativeVolumeDelta, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cumulative_volume_delta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cumulative_volume_delta_is_ready( + handle: *mut CumulativeVolumeDelta, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32087,6 +41778,32 @@ pub unsafe extern "C" fn wickra_pin_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pin_warmup_period(handle: *mut Pin) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_pin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_pin_is_ready(handle: *mut Pin) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32143,6 +41860,32 @@ pub unsafe extern "C" fn wickra_roll_measure_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_roll_measure_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_roll_measure_warmup_period(handle: *mut RollMeasure) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_roll_measure_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_roll_measure_is_ready(handle: *mut RollMeasure) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32196,6 +41939,32 @@ pub unsafe extern "C" fn wickra_signed_volume_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_signed_volume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_signed_volume_warmup_period(handle: *mut SignedVolume) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_signed_volume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_signed_volume_is_ready(handle: *mut SignedVolume) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32252,6 +42021,34 @@ pub unsafe extern "C" fn wickra_trade_imbalance_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trade_imbalance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trade_imbalance_warmup_period( + handle: *mut TradeImbalance, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trade_imbalance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trade_imbalance_is_ready(handle: *mut TradeImbalance) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32310,6 +42107,36 @@ pub unsafe extern "C" fn wickra_trade_sign_autocorrelation_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trade_sign_autocorrelation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trade_sign_autocorrelation_warmup_period( + handle: *mut TradeSignAutocorrelation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trade_sign_autocorrelation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trade_sign_autocorrelation_is_ready( + handle: *mut TradeSignAutocorrelation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32370,6 +42197,32 @@ pub unsafe extern "C" fn wickra_vpin_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vpin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vpin_warmup_period(handle: *mut Vpin) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vpin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vpin_is_ready(handle: *mut Vpin) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32429,6 +42282,34 @@ pub unsafe extern "C" fn wickra_effective_spread_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_effective_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_effective_spread_warmup_period( + handle: *mut EffectiveSpread, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_effective_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_effective_spread_is_ready(handle: *mut EffectiveSpread) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32489,6 +42370,32 @@ pub unsafe extern "C" fn wickra_kyles_lambda_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kyles_lambda_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kyles_lambda_warmup_period(handle: *mut KylesLambda) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kyles_lambda_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kyles_lambda_is_ready(handle: *mut KylesLambda) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32549,6 +42456,34 @@ pub unsafe extern "C" fn wickra_realized_spread_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_realized_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_realized_spread_warmup_period( + handle: *mut RealizedSpread, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_realized_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_realized_spread_is_ready(handle: *mut RealizedSpread) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32624,6 +42559,34 @@ pub unsafe extern "C" fn wickra_calendar_spread_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_calendar_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_calendar_spread_warmup_period( + handle: *mut CalendarSpread, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_calendar_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_calendar_spread_is_ready(handle: *mut CalendarSpread) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32697,6 +42660,36 @@ pub unsafe extern "C" fn wickra_estimated_leverage_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_estimated_leverage_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_estimated_leverage_ratio_warmup_period( + handle: *mut EstimatedLeverageRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_estimated_leverage_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_estimated_leverage_ratio_is_ready( + handle: *mut EstimatedLeverageRatio, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32772,6 +42765,32 @@ pub unsafe extern "C" fn wickra_funding_basis_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_basis_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_basis_warmup_period(handle: *mut FundingBasis) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_basis_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_basis_is_ready(handle: *mut FundingBasis) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32850,6 +42869,36 @@ pub unsafe extern "C" fn wickra_funding_implied_apr_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_implied_apr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_implied_apr_warmup_period( + handle: *mut FundingImpliedApr, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_implied_apr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_implied_apr_is_ready( + handle: *mut FundingImpliedApr, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32923,6 +42972,32 @@ pub unsafe extern "C" fn wickra_funding_rate_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_rate_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_rate_warmup_period(handle: *mut FundingRate) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_rate_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_rate_is_ready(handle: *mut FundingRate) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -32999,6 +43074,34 @@ pub unsafe extern "C" fn wickra_funding_rate_mean_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_rate_mean_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_rate_mean_warmup_period( + handle: *mut FundingRateMean, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_rate_mean_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_rate_mean_is_ready(handle: *mut FundingRateMean) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33075,6 +43178,36 @@ pub unsafe extern "C" fn wickra_funding_rate_z_score_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_rate_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_rate_z_score_warmup_period( + handle: *mut FundingRateZScore, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_funding_rate_z_score_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_funding_rate_z_score_is_ready( + handle: *mut FundingRateZScore, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33148,6 +43281,34 @@ pub unsafe extern "C" fn wickra_long_short_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_long_short_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_long_short_ratio_warmup_period( + handle: *mut LongShortRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_long_short_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_long_short_ratio_is_ready(handle: *mut LongShortRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33221,6 +43382,36 @@ pub unsafe extern "C" fn wickra_open_interest_delta_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_open_interest_delta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_open_interest_delta_warmup_period( + handle: *mut OpenInterestDelta, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_open_interest_delta_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_open_interest_delta_is_ready( + handle: *mut OpenInterestDelta, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33297,6 +43488,36 @@ pub unsafe extern "C" fn wickra_oi_price_divergence_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_oi_price_divergence_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_oi_price_divergence_warmup_period( + handle: *mut OIPriceDivergence, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_oi_price_divergence_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_oi_price_divergence_is_ready( + handle: *mut OIPriceDivergence, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33370,6 +43591,34 @@ pub unsafe extern "C" fn wickra_oi_to_volume_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_oi_to_volume_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_oi_to_volume_ratio_warmup_period( + handle: *mut OiToVolumeRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_oi_to_volume_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_oi_to_volume_ratio_is_ready(handle: *mut OiToVolumeRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33443,6 +43692,32 @@ pub unsafe extern "C" fn wickra_oi_weighted_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_oi_weighted_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_oi_weighted_warmup_period(handle: *mut OIWeighted) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_oi_weighted_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_oi_weighted_is_ready(handle: *mut OIWeighted) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33519,6 +43794,36 @@ pub unsafe extern "C" fn wickra_open_interest_momentum_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_open_interest_momentum_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_open_interest_momentum_warmup_period( + handle: *mut OpenInterestMomentum, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_open_interest_momentum_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_open_interest_momentum_is_ready( + handle: *mut OpenInterestMomentum, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33592,6 +43897,36 @@ pub unsafe extern "C" fn wickra_perpetual_premium_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_perpetual_premium_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_perpetual_premium_index_warmup_period( + handle: *mut PerpetualPremiumIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_perpetual_premium_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_perpetual_premium_index_is_ready( + handle: *mut PerpetualPremiumIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33665,6 +44000,36 @@ pub unsafe extern "C" fn wickra_taker_buy_sell_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_taker_buy_sell_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_taker_buy_sell_ratio_warmup_period( + handle: *mut TakerBuySellRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_taker_buy_sell_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_taker_buy_sell_ratio_is_ready( + handle: *mut TakerBuySellRatio, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33738,6 +44103,36 @@ pub unsafe extern "C" fn wickra_term_structure_basis_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_term_structure_basis_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_term_structure_basis_warmup_period( + handle: *mut TermStructureBasis, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_term_structure_basis_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_term_structure_basis_is_ready( + handle: *mut TermStructureBasis, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33816,6 +44211,32 @@ pub unsafe extern "C" fn wickra_depth_slope_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_depth_slope_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_depth_slope_warmup_period(handle: *mut DepthSlope) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_depth_slope_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_depth_slope_is_ready(handle: *mut DepthSlope) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33892,6 +44313,32 @@ pub unsafe extern "C" fn wickra_microprice_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_microprice_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_microprice_warmup_period(handle: *mut Microprice) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_microprice_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_microprice_is_ready(handle: *mut Microprice) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -33968,6 +44415,36 @@ pub unsafe extern "C" fn wickra_order_book_imbalance_full_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_book_imbalance_full_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_book_imbalance_full_warmup_period( + handle: *mut OrderBookImbalanceFull, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_book_imbalance_full_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_book_imbalance_full_is_ready( + handle: *mut OrderBookImbalanceFull, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34048,6 +44525,36 @@ pub unsafe extern "C" fn wickra_order_book_imbalance_top1_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_book_imbalance_top1_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_book_imbalance_top1_warmup_period( + handle: *mut OrderBookImbalanceTop1, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_book_imbalance_top1_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_book_imbalance_top1_is_ready( + handle: *mut OrderBookImbalanceTop1, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34133,6 +44640,36 @@ pub unsafe extern "C" fn wickra_order_book_imbalance_top_n_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_book_imbalance_top_n_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_book_imbalance_top_n_warmup_period( + handle: *mut OrderBookImbalanceTopN, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_book_imbalance_top_n_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_book_imbalance_top_n_is_ready( + handle: *mut OrderBookImbalanceTopN, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34216,6 +44753,36 @@ pub unsafe extern "C" fn wickra_order_flow_imbalance_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_flow_imbalance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_flow_imbalance_warmup_period( + handle: *mut OrderFlowImbalance, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_order_flow_imbalance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_order_flow_imbalance_is_ready( + handle: *mut OrderFlowImbalance, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34292,6 +44859,32 @@ pub unsafe extern "C" fn wickra_quoted_spread_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_quoted_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_quoted_spread_warmup_period(handle: *mut QuotedSpread) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_quoted_spread_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_quoted_spread_is_ready(handle: *mut QuotedSpread) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34374,6 +44967,36 @@ pub unsafe extern "C" fn wickra_absolute_breadth_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_absolute_breadth_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_absolute_breadth_index_warmup_period( + handle: *mut AbsoluteBreadthIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_absolute_breadth_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_absolute_breadth_index_is_ready( + handle: *mut AbsoluteBreadthIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34454,6 +45077,32 @@ pub unsafe extern "C" fn wickra_ad_volume_line_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ad_volume_line_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ad_volume_line_warmup_period(handle: *mut AdVolumeLine) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ad_volume_line_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ad_volume_line_is_ready(handle: *mut AdVolumeLine) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34534,6 +45183,34 @@ pub unsafe extern "C" fn wickra_advance_decline_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_advance_decline_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_advance_decline_warmup_period( + handle: *mut AdvanceDecline, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_advance_decline_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_advance_decline_is_ready(handle: *mut AdvanceDecline) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34614,6 +45291,36 @@ pub unsafe extern "C" fn wickra_advance_decline_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_advance_decline_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_advance_decline_ratio_warmup_period( + handle: *mut AdvanceDeclineRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_advance_decline_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_advance_decline_ratio_is_ready( + handle: *mut AdvanceDeclineRatio, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34697,6 +45404,32 @@ pub unsafe extern "C" fn wickra_breadth_thrust_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_breadth_thrust_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_breadth_thrust_warmup_period(handle: *mut BreadthThrust) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_breadth_thrust_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_breadth_thrust_is_ready(handle: *mut BreadthThrust) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34777,6 +45510,36 @@ pub unsafe extern "C" fn wickra_bullish_percent_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bullish_percent_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bullish_percent_index_warmup_period( + handle: *mut BullishPercentIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bullish_percent_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bullish_percent_index_is_ready( + handle: *mut BullishPercentIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34857,6 +45620,36 @@ pub unsafe extern "C" fn wickra_cumulative_volume_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cumulative_volume_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cumulative_volume_index_warmup_period( + handle: *mut CumulativeVolumeIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cumulative_volume_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cumulative_volume_index_is_ready( + handle: *mut CumulativeVolumeIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -34940,6 +45733,32 @@ pub unsafe extern "C" fn wickra_high_low_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_low_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_low_index_warmup_period(handle: *mut HighLowIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_low_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_low_index_is_ready(handle: *mut HighLowIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35020,6 +45839,36 @@ pub unsafe extern "C" fn wickra_mc_clellan_oscillator_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mc_clellan_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mc_clellan_oscillator_warmup_period( + handle: *mut McClellanOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mc_clellan_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mc_clellan_oscillator_is_ready( + handle: *mut McClellanOscillator, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35100,6 +45949,36 @@ pub unsafe extern "C" fn wickra_mc_clellan_summation_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mc_clellan_summation_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mc_clellan_summation_index_warmup_period( + handle: *mut McClellanSummationIndex, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mc_clellan_summation_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mc_clellan_summation_index_is_ready( + handle: *mut McClellanSummationIndex, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35184,6 +46063,34 @@ pub unsafe extern "C" fn wickra_new_highs_new_lows_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_new_highs_new_lows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_new_highs_new_lows_warmup_period( + handle: *mut NewHighsNewLows, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_new_highs_new_lows_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_new_highs_new_lows_is_ready(handle: *mut NewHighsNewLows) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35264,6 +46171,34 @@ pub unsafe extern "C" fn wickra_percent_above_ma_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_percent_above_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_percent_above_ma_warmup_period( + handle: *mut PercentAboveMa, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_percent_above_ma_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_percent_above_ma_is_ready(handle: *mut PercentAboveMa) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35344,6 +46279,32 @@ pub unsafe extern "C" fn wickra_tick_index_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tick_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tick_index_warmup_period(handle: *mut TickIndex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tick_index_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tick_index_is_ready(handle: *mut TickIndex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35424,6 +46385,32 @@ pub unsafe extern "C" fn wickra_trin_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trin_warmup_period(handle: *mut Trin) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_trin_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_trin_is_ready(handle: *mut Trin) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -35504,6 +46491,36 @@ pub unsafe extern "C" fn wickra_up_down_volume_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_up_down_volume_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_up_down_volume_ratio_warmup_period( + handle: *mut UpDownVolumeRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_up_down_volume_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_up_down_volume_ratio_is_ready( + handle: *mut UpDownVolumeRatio, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36398,6 +47415,36 @@ pub unsafe extern "C" fn wickra_acceleration_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_acceleration_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_acceleration_bands_warmup_period( + handle: *mut AccelerationBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_acceleration_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_acceleration_bands_is_ready( + handle: *mut AccelerationBands, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36469,6 +47516,32 @@ pub unsafe extern "C" fn wickra_adx_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adx_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adx_warmup_period(handle: *mut Adx) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_adx_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_adx_is_ready(handle: *mut Adx) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36544,6 +47617,32 @@ pub unsafe extern "C" fn wickra_alligator_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_alligator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_alligator_warmup_period(handle: *mut Alligator) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_alligator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_alligator_is_ready(handle: *mut Alligator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36615,6 +47714,34 @@ pub unsafe extern "C" fn wickra_andrews_pitchfork_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_andrews_pitchfork_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_andrews_pitchfork_warmup_period( + handle: *mut AndrewsPitchfork, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_andrews_pitchfork_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_andrews_pitchfork_is_ready(handle: *mut AndrewsPitchfork) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36685,6 +47812,32 @@ pub unsafe extern "C" fn wickra_aroon_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_aroon_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_aroon_warmup_period(handle: *mut Aroon) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_aroon_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_aroon_is_ready(handle: *mut Aroon) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36756,6 +47909,32 @@ pub unsafe extern "C" fn wickra_atr_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_bands_warmup_period(handle: *mut AtrBands) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_bands_is_ready(handle: *mut AtrBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36830,6 +48009,32 @@ pub unsafe extern "C" fn wickra_atr_ratchet_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_ratchet_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_ratchet_warmup_period(handle: *mut AtrRatchet) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_atr_ratchet_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_atr_ratchet_is_ready(handle: *mut AtrRatchet) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36902,6 +48107,32 @@ pub unsafe extern "C" fn wickra_auto_fib_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_auto_fib_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_auto_fib_warmup_period(handle: *mut AutoFib) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_auto_fib_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_auto_fib_is_ready(handle: *mut AutoFib) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -36969,6 +48200,34 @@ pub unsafe extern "C" fn wickra_bollinger_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bollinger_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bollinger_bands_warmup_period( + handle: *mut BollingerBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bollinger_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bollinger_bands_is_ready(handle: *mut BollingerBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37032,6 +48291,32 @@ pub unsafe extern "C" fn wickra_bomar_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bomar_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bomar_bands_warmup_period(handle: *mut BomarBands) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_bomar_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_bomar_bands_is_ready(handle: *mut BomarBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37106,6 +48391,32 @@ pub unsafe extern "C" fn wickra_camarilla_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_camarilla_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_camarilla_warmup_period(handle: *mut Camarilla) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_camarilla_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_camarilla_is_ready(handle: *mut Camarilla) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37176,6 +48487,32 @@ pub unsafe extern "C" fn wickra_candle_volume_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_candle_volume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_candle_volume_warmup_period(handle: *mut CandleVolume) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_candle_volume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_candle_volume_is_ready(handle: *mut CandleVolume) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37244,6 +48581,36 @@ pub unsafe extern "C" fn wickra_central_pivot_range_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_central_pivot_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_central_pivot_range_warmup_period( + handle: *mut CentralPivotRange, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_central_pivot_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_central_pivot_range_is_ready( + handle: *mut CentralPivotRange, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37318,6 +48685,34 @@ pub unsafe extern "C" fn wickra_chande_kroll_stop_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chande_kroll_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chande_kroll_stop_warmup_period( + handle: *mut ChandeKrollStop, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chande_kroll_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chande_kroll_stop_is_ready(handle: *mut ChandeKrollStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37391,6 +48786,34 @@ pub unsafe extern "C" fn wickra_chandelier_exit_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chandelier_exit_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chandelier_exit_warmup_period( + handle: *mut ChandelierExit, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_chandelier_exit_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_chandelier_exit_is_ready(handle: *mut ChandelierExit) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37463,6 +48886,32 @@ pub unsafe extern "C" fn wickra_classic_pivots_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_classic_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_classic_pivots_warmup_period(handle: *mut ClassicPivots) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_classic_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_classic_pivots_is_ready(handle: *mut ClassicPivots) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37527,6 +48976,32 @@ pub unsafe extern "C" fn wickra_cointegration_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cointegration_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cointegration_warmup_period(handle: *mut Cointegration) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_cointegration_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_cointegration_is_ready(handle: *mut Cointegration) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37602,6 +49077,34 @@ pub unsafe extern "C" fn wickra_composite_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_composite_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_composite_profile_warmup_period( + handle: *mut CompositeProfile, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_composite_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_composite_profile_is_ready(handle: *mut CompositeProfile) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37670,6 +49173,32 @@ pub unsafe extern "C" fn wickra_demark_pivots_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_demark_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_demark_pivots_warmup_period(handle: *mut DemarkPivots) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_demark_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_demark_pivots_is_ready(handle: *mut DemarkPivots) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37741,6 +49270,32 @@ pub unsafe extern "C" fn wickra_donchian_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_donchian_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_donchian_warmup_period(handle: *mut Donchian) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_donchian_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_donchian_is_ready(handle: *mut Donchian) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37811,6 +49366,32 @@ pub unsafe extern "C" fn wickra_donchian_stop_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_donchian_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_donchian_stop_warmup_period(handle: *mut DonchianStop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_donchian_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_donchian_stop_is_ready(handle: *mut DonchianStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37880,6 +49461,34 @@ pub unsafe extern "C" fn wickra_double_bollinger_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_double_bollinger_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_double_bollinger_warmup_period( + handle: *mut DoubleBollinger, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_double_bollinger_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_double_bollinger_is_ready(handle: *mut DoubleBollinger) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -37950,6 +49559,32 @@ pub unsafe extern "C" fn wickra_elder_ray_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_elder_ray_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_elder_ray_warmup_period(handle: *mut ElderRay) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_elder_ray_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_elder_ray_is_ready(handle: *mut ElderRay) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38020,6 +49655,32 @@ pub unsafe extern "C" fn wickra_elder_safe_zone_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_elder_safe_zone_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_elder_safe_zone_warmup_period(handle: *mut ElderSafeZone) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_elder_safe_zone_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_elder_safe_zone_is_ready(handle: *mut ElderSafeZone) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38090,6 +49751,32 @@ pub unsafe extern "C" fn wickra_equivolume_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_equivolume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_equivolume_warmup_period(handle: *mut Equivolume) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_equivolume_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_equivolume_is_ready(handle: *mut Equivolume) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38158,6 +49845,32 @@ pub unsafe extern "C" fn wickra_fib_arcs_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_arcs_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_arcs_warmup_period(handle: *mut FibArcs) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_arcs_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_arcs_is_ready(handle: *mut FibArcs) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38227,6 +49940,32 @@ pub unsafe extern "C" fn wickra_fib_channel_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_channel_warmup_period(handle: *mut FibChannel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_channel_is_ready(handle: *mut FibChannel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38294,6 +50033,32 @@ pub unsafe extern "C" fn wickra_fib_confluence_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_confluence_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_confluence_warmup_period(handle: *mut FibConfluence) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_confluence_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_confluence_is_ready(handle: *mut FibConfluence) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38364,6 +50129,32 @@ pub unsafe extern "C" fn wickra_fib_extension_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_extension_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_extension_warmup_period(handle: *mut FibExtension) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_extension_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_extension_is_ready(handle: *mut FibExtension) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38432,6 +50223,32 @@ pub unsafe extern "C" fn wickra_fib_fan_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_fan_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_fan_warmup_period(handle: *mut FibFan) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_fan_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_fan_is_ready(handle: *mut FibFan) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38501,6 +50318,32 @@ pub unsafe extern "C" fn wickra_fib_projection_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_projection_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_projection_warmup_period(handle: *mut FibProjection) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_projection_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_projection_is_ready(handle: *mut FibProjection) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38573,6 +50416,34 @@ pub unsafe extern "C" fn wickra_fib_retracement_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_retracement_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_retracement_warmup_period( + handle: *mut FibRetracement, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_retracement_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_retracement_is_ready(handle: *mut FibRetracement) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38640,6 +50511,32 @@ pub unsafe extern "C" fn wickra_fib_time_zones_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_time_zones_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_time_zones_warmup_period(handle: *mut FibTimeZones) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fib_time_zones_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fib_time_zones_is_ready(handle: *mut FibTimeZones) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38712,6 +50609,34 @@ pub unsafe extern "C" fn wickra_fibonacci_pivots_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fibonacci_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fibonacci_pivots_warmup_period( + handle: *mut FibonacciPivots, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fibonacci_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fibonacci_pivots_is_ready(handle: *mut FibonacciPivots) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38782,6 +50707,36 @@ pub unsafe extern "C" fn wickra_fractal_chaos_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fractal_chaos_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fractal_chaos_bands_warmup_period( + handle: *mut FractalChaosBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_fractal_chaos_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_fractal_chaos_bands_is_ready( + handle: *mut FractalChaosBands, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38856,6 +50811,34 @@ pub unsafe extern "C" fn wickra_gator_oscillator_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gator_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gator_oscillator_warmup_period( + handle: *mut GatorOscillator, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_gator_oscillator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_gator_oscillator_is_ready(handle: *mut GatorOscillator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38924,6 +50907,32 @@ pub unsafe extern "C" fn wickra_golden_pocket_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_golden_pocket_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_golden_pocket_warmup_period(handle: *mut GoldenPocket) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_golden_pocket_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_golden_pocket_is_ready(handle: *mut GoldenPocket) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -38993,6 +51002,32 @@ pub unsafe extern "C" fn wickra_heikin_ashi_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_heikin_ashi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_heikin_ashi_warmup_period(handle: *mut HeikinAshi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_heikin_ashi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_heikin_ashi_is_ready(handle: *mut HeikinAshi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39066,6 +51101,36 @@ pub unsafe extern "C" fn wickra_high_low_volume_nodes_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_low_volume_nodes_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_low_volume_nodes_warmup_period( + handle: *mut HighLowVolumeNodes, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_high_low_volume_nodes_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_high_low_volume_nodes_is_ready( + handle: *mut HighLowVolumeNodes, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39125,6 +51190,32 @@ pub unsafe extern "C" fn wickra_ht_phasor_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ht_phasor_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ht_phasor_warmup_period(handle: *mut HtPhasor) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ht_phasor_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ht_phasor_is_ready(handle: *mut HtPhasor) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39196,6 +51287,32 @@ pub unsafe extern "C" fn wickra_hurst_channel_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hurst_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hurst_channel_warmup_period(handle: *mut HurstChannel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_hurst_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_hurst_channel_is_ready(handle: *mut HurstChannel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39274,6 +51391,32 @@ pub unsafe extern "C" fn wickra_ichimoku_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ichimoku_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ichimoku_warmup_period(handle: *mut Ichimoku) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ichimoku_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ichimoku_is_ready(handle: *mut Ichimoku) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39344,6 +51487,34 @@ pub unsafe extern "C" fn wickra_initial_balance_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_initial_balance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_initial_balance_warmup_period( + handle: *mut InitialBalance, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_initial_balance_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_initial_balance_is_ready(handle: *mut InitialBalance) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39411,6 +51582,34 @@ pub unsafe extern "C" fn wickra_kalman_hedge_ratio_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kalman_hedge_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kalman_hedge_ratio_warmup_period( + handle: *mut KalmanHedgeRatio, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kalman_hedge_ratio_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kalman_hedge_ratio_is_ready(handle: *mut KalmanHedgeRatio) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39481,6 +51680,32 @@ pub unsafe extern "C" fn wickra_kase_dev_stop_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kase_dev_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kase_dev_stop_warmup_period(handle: *mut KaseDevStop) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kase_dev_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kase_dev_stop_is_ready(handle: *mut KaseDevStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39554,6 +51779,36 @@ pub unsafe extern "C" fn wickra_kase_permission_stochastic_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kase_permission_stochastic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kase_permission_stochastic_warmup_period( + handle: *mut KasePermissionStochastic, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kase_permission_stochastic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kase_permission_stochastic_is_ready( + handle: *mut KasePermissionStochastic, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39633,6 +51888,32 @@ pub unsafe extern "C" fn wickra_keltner_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_keltner_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_keltner_warmup_period(handle: *mut Keltner) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_keltner_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_keltner_is_ready(handle: *mut Keltner) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39705,6 +51986,32 @@ pub unsafe extern "C" fn wickra_kst_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kst_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kst_warmup_period(handle: *mut Kst) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_kst_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_kst_is_ready(handle: *mut Kst) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39771,6 +52078,36 @@ pub unsafe extern "C" fn wickra_lead_lag_cross_correlation_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lead_lag_cross_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lead_lag_cross_correlation_warmup_period( + handle: *mut LeadLagCrossCorrelation, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lead_lag_cross_correlation_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lead_lag_cross_correlation_is_ready( + handle: *mut LeadLagCrossCorrelation, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39838,6 +52175,32 @@ pub unsafe extern "C" fn wickra_lin_reg_channel_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_channel_warmup_period(handle: *mut LinRegChannel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_lin_reg_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_lin_reg_channel_is_ready(handle: *mut LinRegChannel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39927,6 +52290,36 @@ pub unsafe extern "C" fn wickra_liquidation_features_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_liquidation_features_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_liquidation_features_warmup_period( + handle: *mut LiquidationFeatures, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_liquidation_features_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_liquidation_features_is_ready( + handle: *mut LiquidationFeatures, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -39990,6 +52383,32 @@ pub unsafe extern "C" fn wickra_ma_envelope_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ma_envelope_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ma_envelope_warmup_period(handle: *mut MaEnvelope) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ma_envelope_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ma_envelope_is_ready(handle: *mut MaEnvelope) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40057,6 +52476,32 @@ pub unsafe extern "C" fn wickra_macd_indicator_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_indicator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_indicator_warmup_period(handle: *mut MacdIndicator) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_indicator_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_indicator_is_ready(handle: *mut MacdIndicator) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40120,6 +52565,32 @@ pub unsafe extern "C" fn wickra_macd_fix_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_fix_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_fix_warmup_period(handle: *mut MacdFix) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_fix_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_fix_is_ready(handle: *mut MacdFix) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40182,6 +52653,32 @@ pub unsafe extern "C" fn wickra_mama_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mama_warmup_period(handle: *mut Mama) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_mama_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_mama_is_ready(handle: *mut Mama) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40245,6 +52742,32 @@ pub unsafe extern "C" fn wickra_median_channel_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_channel_warmup_period(handle: *mut MedianChannel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_median_channel_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_median_channel_is_ready(handle: *mut MedianChannel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40315,6 +52838,34 @@ pub unsafe extern "C" fn wickra_modified_ma_stop_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_modified_ma_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_modified_ma_stop_warmup_period( + handle: *mut ModifiedMaStop, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_modified_ma_stop_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_modified_ma_stop_is_ready(handle: *mut ModifiedMaStop) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40392,6 +52943,34 @@ pub unsafe extern "C" fn wickra_murrey_math_lines_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_murrey_math_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_murrey_math_lines_warmup_period( + handle: *mut MurreyMathLines, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_murrey_math_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_murrey_math_lines_is_ready(handle: *mut MurreyMathLines) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40462,6 +53041,32 @@ pub unsafe extern "C" fn wickra_nrtr_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_nrtr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_nrtr_warmup_period(handle: *mut Nrtr) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_nrtr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_nrtr_is_ready(handle: *mut Nrtr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40533,6 +53138,32 @@ pub unsafe extern "C" fn wickra_opening_range_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_opening_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_opening_range_warmup_period(handle: *mut OpeningRange) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_opening_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_opening_range_is_ready(handle: *mut OpeningRange) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40602,6 +53233,36 @@ pub unsafe extern "C" fn wickra_overnight_intraday_return_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_overnight_intraday_return_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_overnight_intraday_return_warmup_period( + handle: *mut OvernightIntradayReturn, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_overnight_intraday_return_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_overnight_intraday_return_is_ready( + handle: *mut OvernightIntradayReturn, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40677,6 +53338,34 @@ pub unsafe extern "C" fn wickra_projection_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_projection_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_projection_bands_warmup_period( + handle: *mut ProjectionBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_projection_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_projection_bands_is_ready(handle: *mut ProjectionBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40739,6 +53428,32 @@ pub unsafe extern "C" fn wickra_qqe_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_qqe_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_qqe_warmup_period(handle: *mut Qqe) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_qqe_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_qqe_is_ready(handle: *mut Qqe) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40802,6 +53517,32 @@ pub unsafe extern "C" fn wickra_quartile_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_quartile_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_quartile_bands_warmup_period(handle: *mut QuartileBands) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_quartile_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_quartile_bands_is_ready(handle: *mut QuartileBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40869,6 +53610,36 @@ pub unsafe extern "C" fn wickra_relative_strength_ab_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_relative_strength_ab_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_relative_strength_ab_warmup_period( + handle: *mut RelativeStrengthAB, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_relative_strength_ab_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_relative_strength_ab_is_ready( + handle: *mut RelativeStrengthAB, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -40939,6 +53710,32 @@ pub unsafe extern "C" fn wickra_rwi_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rwi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rwi_warmup_period(handle: *mut Rwi) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_rwi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_rwi_is_ready(handle: *mut Rwi) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41006,6 +53803,34 @@ pub unsafe extern "C" fn wickra_session_high_low_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_session_high_low_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_session_high_low_warmup_period( + handle: *mut SessionHighLow, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_session_high_low_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_session_high_low_is_ready(handle: *mut SessionHighLow) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41074,6 +53899,32 @@ pub unsafe extern "C" fn wickra_session_range_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_session_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_session_range_warmup_period(handle: *mut SessionRange) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_session_range_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_session_range_is_ready(handle: *mut SessionRange) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41146,6 +53997,36 @@ pub unsafe extern "C" fn wickra_smoothed_heikin_ashi_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_smoothed_heikin_ashi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_smoothed_heikin_ashi_warmup_period( + handle: *mut SmoothedHeikinAshi, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_smoothed_heikin_ashi_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_smoothed_heikin_ashi_is_ready( + handle: *mut SmoothedHeikinAshi, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41214,6 +54095,36 @@ pub unsafe extern "C" fn wickra_spread_bollinger_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spread_bollinger_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spread_bollinger_bands_warmup_period( + handle: *mut SpreadBollingerBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_spread_bollinger_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_spread_bollinger_bands_is_ready( + handle: *mut SpreadBollingerBands, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41280,6 +54191,36 @@ pub unsafe extern "C" fn wickra_standard_error_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_standard_error_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_standard_error_bands_warmup_period( + handle: *mut StandardErrorBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_standard_error_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_standard_error_bands_is_ready( + handle: *mut StandardErrorBands, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41355,6 +54296,32 @@ pub unsafe extern "C" fn wickra_starc_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_starc_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_starc_bands_warmup_period(handle: *mut StarcBands) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_starc_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_starc_bands_is_ready(handle: *mut StarcBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41425,6 +54392,32 @@ pub unsafe extern "C" fn wickra_stochastic_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stochastic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stochastic_warmup_period(handle: *mut Stochastic) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_stochastic_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_stochastic_is_ready(handle: *mut Stochastic) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41495,6 +54488,32 @@ pub unsafe extern "C" fn wickra_super_trend_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_super_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_super_trend_warmup_period(handle: *mut SuperTrend) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_super_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_super_trend_is_ready(handle: *mut SuperTrend) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41565,6 +54584,32 @@ pub unsafe extern "C" fn wickra_td_lines_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_lines_warmup_period(handle: *mut TdLines) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_lines_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_lines_is_ready(handle: *mut TdLines) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41638,6 +54683,34 @@ pub unsafe extern "C" fn wickra_td_moving_average_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_moving_average_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_moving_average_warmup_period( + handle: *mut TdMovingAverage, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_moving_average_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_moving_average_is_ready(handle: *mut TdMovingAverage) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41705,6 +54778,36 @@ pub unsafe extern "C" fn wickra_td_range_projection_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_range_projection_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_range_projection_warmup_period( + handle: *mut TdRangeProjection, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_range_projection_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_range_projection_is_ready( + handle: *mut TdRangeProjection, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41775,6 +54878,32 @@ pub unsafe extern "C" fn wickra_td_risk_level_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_risk_level_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_risk_level_warmup_period(handle: *mut TdRiskLevel) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_risk_level_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_risk_level_is_ready(handle: *mut TdRiskLevel) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41856,6 +54985,32 @@ pub unsafe extern "C" fn wickra_td_sequential_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_sequential_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_sequential_warmup_period(handle: *mut TdSequential) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_td_sequential_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_td_sequential_is_ready(handle: *mut TdSequential) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -41930,6 +55085,32 @@ pub unsafe extern "C" fn wickra_ttm_squeeze_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ttm_squeeze_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ttm_squeeze_warmup_period(handle: *mut TtmSqueeze) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_ttm_squeeze_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_ttm_squeeze_is_ready(handle: *mut TtmSqueeze) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42005,6 +55186,32 @@ pub unsafe extern "C" fn wickra_value_area_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_value_area_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_value_area_warmup_period(handle: *mut ValueArea) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_value_area_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_value_area_is_ready(handle: *mut ValueArea) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42081,6 +55288,34 @@ pub unsafe extern "C" fn wickra_volatility_cone_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volatility_cone_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volatility_cone_warmup_period( + handle: *mut VolatilityCone, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volatility_cone_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volatility_cone_is_ready(handle: *mut VolatilityCone) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42156,6 +55391,36 @@ pub unsafe extern "C" fn wickra_volume_weighted_macd_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_weighted_macd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_weighted_macd_warmup_period( + handle: *mut VolumeWeightedMacd, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_weighted_macd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_weighted_macd_is_ready( + handle: *mut VolumeWeightedMacd, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42226,6 +55491,34 @@ pub unsafe extern "C" fn wickra_volume_weighted_sr_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_weighted_sr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_weighted_sr_warmup_period( + handle: *mut VolumeWeightedSr, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_weighted_sr_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_weighted_sr_is_ready(handle: *mut VolumeWeightedSr) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42296,6 +55589,32 @@ pub unsafe extern "C" fn wickra_vortex_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vortex_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vortex_warmup_period(handle: *mut Vortex) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vortex_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vortex_is_ready(handle: *mut Vortex) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42368,6 +55687,34 @@ pub unsafe extern "C" fn wickra_vwap_std_dev_bands_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vwap_std_dev_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vwap_std_dev_bands_warmup_period( + handle: *mut VwapStdDevBands, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_vwap_std_dev_bands_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_vwap_std_dev_bands_is_ready(handle: *mut VwapStdDevBands) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42442,6 +55789,32 @@ pub unsafe extern "C" fn wickra_wave_trend_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wave_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wave_trend_warmup_period(handle: *mut WaveTrend) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_wave_trend_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_wave_trend_is_ready(handle: *mut WaveTrend) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42509,6 +55882,34 @@ pub unsafe extern "C" fn wickra_williams_fractals_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_williams_fractals_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_williams_fractals_warmup_period( + handle: *mut WilliamsFractals, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_williams_fractals_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_williams_fractals_is_ready(handle: *mut WilliamsFractals) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42579,6 +55980,32 @@ pub unsafe extern "C" fn wickra_woodie_pivots_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_woodie_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_woodie_pivots_warmup_period(handle: *mut WoodiePivots) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_woodie_pivots_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_woodie_pivots_is_ready(handle: *mut WoodiePivots) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42646,6 +56073,32 @@ pub unsafe extern "C" fn wickra_zero_lag_macd_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_zero_lag_macd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_zero_lag_macd_warmup_period(handle: *mut ZeroLagMacd) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_zero_lag_macd_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_zero_lag_macd_is_ready(handle: *mut ZeroLagMacd) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42716,6 +56169,32 @@ pub unsafe extern "C" fn wickra_zig_zag_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_zig_zag_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_zig_zag_warmup_period(handle: *mut ZigZag) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_zig_zag_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_zig_zag_is_ready(handle: *mut ZigZag) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42804,6 +56283,36 @@ pub unsafe extern "C" fn wickra_day_of_week_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_day_of_week_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_day_of_week_profile_warmup_period( + handle: *mut DayOfWeekProfile, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_day_of_week_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_day_of_week_profile_is_ready( + handle: *mut DayOfWeekProfile, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42880,6 +56389,36 @@ pub unsafe extern "C" fn wickra_intraday_volatility_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_intraday_volatility_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_intraday_volatility_profile_warmup_period( + handle: *mut IntradayVolatilityProfile, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_intraday_volatility_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_intraday_volatility_profile_is_ready( + handle: *mut IntradayVolatilityProfile, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -42960,6 +56499,36 @@ pub unsafe extern "C" fn wickra_time_of_day_return_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_time_of_day_return_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_time_of_day_return_profile_warmup_period( + handle: *mut TimeOfDayReturnProfile, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_time_of_day_return_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_time_of_day_return_profile_is_ready( + handle: *mut TimeOfDayReturnProfile, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -43044,6 +56613,32 @@ pub unsafe extern "C" fn wickra_tpo_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tpo_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tpo_profile_warmup_period(handle: *mut TpoProfile) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_tpo_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_tpo_profile_is_ready(handle: *mut TpoProfile) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -43120,6 +56715,36 @@ pub unsafe extern "C" fn wickra_volume_by_time_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_by_time_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_by_time_profile_warmup_period( + handle: *mut VolumeByTimeProfile, +) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_by_time_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_by_time_profile_is_ready( + handle: *mut VolumeByTimeProfile, +) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -43200,6 +56825,32 @@ pub unsafe extern "C" fn wickra_volume_profile_update( } } +/// Number of updates the indicator needs before it produces a non-`NaN` output. +/// Returns `0` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_profile_warmup_period(handle: *mut VolumeProfile) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns +/// `false` if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_volume_profile_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_volume_profile_is_ready(handle: *mut VolumeProfile) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -44144,6 +57795,32 @@ pub unsafe extern "C" fn wickra_macd_ext_update( } } +/// Number of updates the indicator needs before it produces a value. Returns `0` +/// if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_ext_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_ext_warmup_period(handle: *mut MacdExt) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns `false` +/// if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_macd_ext_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_macd_ext_is_ready(handle: *mut MacdExt) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -44227,6 +57904,32 @@ pub unsafe extern "C" fn wickra_footprint_update( } } +/// Number of updates the indicator needs before it produces a value. Returns `0` +/// if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_footprint_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_footprint_warmup_period(handle: *mut Footprint) -> usize { + match handle.as_ref() { + Some(ind) => ind.warmup_period(), + None => 0, + } +} + +/// Whether the indicator has consumed enough input to emit a value. Returns `false` +/// if `handle` is `NULL`. +/// +/// # Safety +/// `handle` must be valid (from `wickra_footprint_new`, not freed), or `NULL`. +#[no_mangle] +pub unsafe extern "C" fn wickra_footprint_is_ready(handle: *mut Footprint) -> bool { + match handle.as_ref() { + Some(ind) => ind.is_ready(), + None => false, + } +} + /// Reset all internal state. No-op if `handle` is `NULL`. /// /// # Safety @@ -44263,11 +57966,16 @@ mod tests { let handle = wickra_sma_new(3); assert!(!handle.is_null()); unsafe { + assert_eq!(wickra_sma_warmup_period(handle), 3); + assert!(!wickra_sma_is_ready(handle)); assert!(wickra_sma_update(handle, 1.0).is_nan()); assert!(wickra_sma_update(handle, 2.0).is_nan()); + assert!(!wickra_sma_is_ready(handle)); assert!((wickra_sma_update(handle, 3.0) - 2.0).abs() < 1e-9); + assert!(wickra_sma_is_ready(handle)); wickra_sma_reset(handle); + assert!(!wickra_sma_is_ready(handle)); let input = [1.0_f64, 2.0, 3.0, 4.0, 5.0]; let mut out = [0.0_f64; 5]; wickra_sma_batch(handle, input.as_ptr(), out.as_mut_ptr(), 5); @@ -44283,6 +57991,8 @@ mod tests { fn null_handle_is_a_defined_noop() { unsafe { assert!(wickra_sma_update(ptr::null_mut(), 1.0).is_nan()); + assert_eq!(wickra_sma_warmup_period(ptr::null_mut()), 0); + assert!(!wickra_sma_is_ready(ptr::null_mut())); wickra_sma_reset(ptr::null_mut()); wickra_sma_free(ptr::null_mut()); } diff --git a/bindings/csharp/Wickra.Tests/ArchetypeTests.cs b/bindings/csharp/Wickra.Tests/ArchetypeTests.cs index 18bb7eb1..e6ff432f 100644 --- a/bindings/csharp/Wickra.Tests/ArchetypeTests.cs +++ b/bindings/csharp/Wickra.Tests/ArchetypeTests.cs @@ -34,6 +34,21 @@ public class ArchetypeTests Assert.InRange(last, 1.0, 10.0); } + [Fact] + public void Query_WarmupPeriodAndIsReady() + { + using var sma = new Sma(3); + Assert.Equal(3, sma.WarmupPeriod()); + Assert.False(sma.IsReady()); + sma.Update(1.0); + sma.Update(2.0); + Assert.False(sma.IsReady()); + sma.Update(3.0); + Assert.True(sma.IsReady()); + sma.Reset(); + Assert.False(sma.IsReady()); + } + [Fact] public void Candle_Atr_IsFinitePositive() { diff --git a/bindings/csharp/Wickra/Generated/Indicators.g.cs b/bindings/csharp/Wickra/Generated/Indicators.g.cs index 617dcbc0..ed1f0e30 100644 --- a/bindings/csharp/Wickra/Generated/Indicators.g.cs +++ b/bindings/csharp/Wickra/Generated/Indicators.g.cs @@ -173,6 +173,22 @@ public sealed class AbandonedBaby : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_abandoned_baby_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_abandoned_baby_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_abandoned_baby_reset(_handle.DangerousGetHandle()); @@ -247,6 +263,22 @@ public sealed class Abcd : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_abcd_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_abcd_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_abcd_reset(_handle.DangerousGetHandle()); @@ -312,6 +344,22 @@ public sealed class AbsoluteBreadthIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_absolute_breadth_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_absolute_breadth_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_absolute_breadth_index_reset(_handle.DangerousGetHandle()); @@ -350,6 +398,22 @@ public sealed class AccelerationBands : IDisposable return ok ? new AccelerationBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_acceleration_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_acceleration_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_acceleration_bands_reset(_handle.DangerousGetHandle()); @@ -427,6 +491,22 @@ public sealed class AcceleratorOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_accelerator_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_accelerator_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_accelerator_oscillator_reset(_handle.DangerousGetHandle()); @@ -501,6 +581,22 @@ public sealed class AdOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ad_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ad_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ad_oscillator_reset(_handle.DangerousGetHandle()); @@ -566,6 +662,22 @@ public sealed class AdVolumeLine : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ad_volume_line_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ad_volume_line_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ad_volume_line_reset(_handle.DangerousGetHandle()); @@ -641,6 +753,22 @@ public sealed class AdaptiveCci : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adaptive_cci_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adaptive_cci_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adaptive_cci_reset(_handle.DangerousGetHandle()); @@ -690,6 +818,22 @@ public sealed class AdaptiveCycle : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adaptive_cycle_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adaptive_cycle_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adaptive_cycle_reset(_handle.DangerousGetHandle()); @@ -740,6 +884,22 @@ public sealed class AdaptiveLaguerreFilter : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adaptive_laguerre_filter_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adaptive_laguerre_filter_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adaptive_laguerre_filter_reset(_handle.DangerousGetHandle()); @@ -790,6 +950,22 @@ public sealed class AdaptiveRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adaptive_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adaptive_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adaptive_rsi_reset(_handle.DangerousGetHandle()); @@ -864,6 +1040,22 @@ public sealed class Adl : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adl_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adl_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adl_reset(_handle.DangerousGetHandle()); @@ -938,6 +1130,22 @@ public sealed class AdvanceBlock : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_advance_block_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_advance_block_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_advance_block_reset(_handle.DangerousGetHandle()); @@ -1003,6 +1211,22 @@ public sealed class AdvanceDecline : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_advance_decline_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_advance_decline_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_advance_decline_reset(_handle.DangerousGetHandle()); @@ -1068,6 +1292,22 @@ public sealed class AdvanceDeclineRatio : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_advance_decline_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_advance_decline_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_advance_decline_ratio_reset(_handle.DangerousGetHandle()); @@ -1106,6 +1346,22 @@ public sealed class Adx : IDisposable return ok ? new AdxOutput(native.plus_di, native.minus_di, native.adx) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adx_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adx_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adx_reset(_handle.DangerousGetHandle()); @@ -1181,6 +1437,22 @@ public sealed class Adxr : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_adxr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_adxr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_adxr_reset(_handle.DangerousGetHandle()); @@ -1221,6 +1493,22 @@ public sealed class Alligator : IDisposable return ok ? new AlligatorOutput(native.jaw, native.teeth, native.lips) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_alligator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_alligator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_alligator_reset(_handle.DangerousGetHandle()); @@ -1271,6 +1559,22 @@ public sealed class Alma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_alma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_alma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_alma_reset(_handle.DangerousGetHandle()); @@ -1326,6 +1630,22 @@ public sealed class Alpha : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_alpha_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_alpha_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_alpha_reset(_handle.DangerousGetHandle()); @@ -1358,6 +1678,22 @@ public sealed class AmihudIlliquidity : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_amihud_illiquidity_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_amihud_illiquidity_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_amihud_illiquidity_reset(_handle.DangerousGetHandle()); @@ -1407,6 +1743,22 @@ public sealed class AnchoredRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_anchored_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_anchored_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_anchored_rsi_reset(_handle.DangerousGetHandle()); @@ -1481,6 +1833,22 @@ public sealed class AnchoredVwap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_anchored_vwap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_anchored_vwap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_anchored_vwap_reset(_handle.DangerousGetHandle()); @@ -1519,6 +1887,22 @@ public sealed class AndrewsPitchfork : IDisposable return ok ? new AndrewsPitchforkOutput(native.median, native.upper, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_andrews_pitchfork_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_andrews_pitchfork_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_andrews_pitchfork_reset(_handle.DangerousGetHandle()); @@ -1570,6 +1954,22 @@ public sealed class Apo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_apo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_apo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_apo_reset(_handle.DangerousGetHandle()); @@ -1608,6 +2008,22 @@ public sealed class Aroon : IDisposable return ok ? new AroonOutput(native.up, native.down) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_aroon_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_aroon_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_aroon_reset(_handle.DangerousGetHandle()); @@ -1683,6 +2099,22 @@ public sealed class AroonOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_aroon_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_aroon_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_aroon_oscillator_reset(_handle.DangerousGetHandle()); @@ -1758,6 +2190,22 @@ public sealed class Atr : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_atr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_atr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_atr_reset(_handle.DangerousGetHandle()); @@ -1796,6 +2244,22 @@ public sealed class AtrBands : IDisposable return ok ? new AtrBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_atr_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_atr_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_atr_bands_reset(_handle.DangerousGetHandle()); @@ -1834,6 +2298,22 @@ public sealed class AtrRatchet : IDisposable return ok ? new AtrRatchetOutput(native.@value, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_atr_ratchet_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_atr_ratchet_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_atr_ratchet_reset(_handle.DangerousGetHandle()); @@ -1909,6 +2389,22 @@ public sealed class AtrTrailingStop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_atr_trailing_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_atr_trailing_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_atr_trailing_stop_reset(_handle.DangerousGetHandle()); @@ -1946,6 +2442,22 @@ public sealed class AutoFib : IDisposable return ok ? new AutoFibOutput(native.level_0, native.level_236, native.level_382, native.level_500, native.level_618, native.level_786, native.level_1000) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_auto_fib_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_auto_fib_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_auto_fib_reset(_handle.DangerousGetHandle()); @@ -1997,6 +2509,22 @@ public sealed class Autocorrelation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_autocorrelation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_autocorrelation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_autocorrelation_reset(_handle.DangerousGetHandle()); @@ -2048,6 +2576,22 @@ public sealed class AutocorrelationPeriodogram : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_autocorrelation_periodogram_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_autocorrelation_periodogram_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_autocorrelation_periodogram_reset(_handle.DangerousGetHandle()); @@ -2123,6 +2667,22 @@ public sealed class AverageDailyRange : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_average_daily_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_average_daily_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_average_daily_range_reset(_handle.DangerousGetHandle()); @@ -2173,6 +2733,22 @@ public sealed class AverageDrawdown : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_average_drawdown_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_average_drawdown_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_average_drawdown_reset(_handle.DangerousGetHandle()); @@ -2247,6 +2823,22 @@ public sealed class AvgPrice : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_avg_price_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_avg_price_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_avg_price_reset(_handle.DangerousGetHandle()); @@ -2323,6 +2915,22 @@ public sealed class AwesomeOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_awesome_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_awesome_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_awesome_oscillator_reset(_handle.DangerousGetHandle()); @@ -2400,6 +3008,22 @@ public sealed class AwesomeOscillatorHistogram : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_awesome_oscillator_histogram_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_awesome_oscillator_histogram_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_awesome_oscillator_histogram_reset(_handle.DangerousGetHandle()); @@ -2474,6 +3098,22 @@ public sealed class BalanceOfPower : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_balance_of_power_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_balance_of_power_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_balance_of_power_reset(_handle.DangerousGetHandle()); @@ -2524,6 +3164,22 @@ public sealed class BandpassFilter : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bandpass_filter_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bandpass_filter_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bandpass_filter_reset(_handle.DangerousGetHandle()); @@ -2598,6 +3254,22 @@ public sealed class Bat : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bat_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bat_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bat_reset(_handle.DangerousGetHandle()); @@ -2672,6 +3344,22 @@ public sealed class BeltHold : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_belt_hold_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_belt_hold_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_belt_hold_reset(_handle.DangerousGetHandle()); @@ -2727,6 +3415,22 @@ public sealed class Beta : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_beta_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_beta_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_beta_reset(_handle.DangerousGetHandle()); @@ -2782,6 +3486,22 @@ public sealed class BetaNeutralSpread : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_beta_neutral_spread_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_beta_neutral_spread_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_beta_neutral_spread_reset(_handle.DangerousGetHandle()); @@ -2857,6 +3577,22 @@ public sealed class BetterVolume : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_better_volume_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_better_volume_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_better_volume_reset(_handle.DangerousGetHandle()); @@ -2907,6 +3643,22 @@ public sealed class BipowerVariation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bipower_variation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bipower_variation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bipower_variation_reset(_handle.DangerousGetHandle()); @@ -2981,6 +3733,22 @@ public sealed class BodySizePct : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_body_size_pct_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_body_size_pct_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_body_size_pct_reset(_handle.DangerousGetHandle()); @@ -3019,6 +3787,22 @@ public sealed class BollingerBands : IDisposable return ok ? new BollingerOutput(native.upper, native.middle, native.lower, native.stddev) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bollinger_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bollinger_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bollinger_bands_reset(_handle.DangerousGetHandle()); @@ -3069,6 +3853,22 @@ public sealed class BollingerBandwidth : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bollinger_bandwidth_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bollinger_bandwidth_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bollinger_bandwidth_reset(_handle.DangerousGetHandle()); @@ -3107,6 +3907,22 @@ public sealed class BomarBands : IDisposable return ok ? new BomarBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bomar_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bomar_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bomar_bands_reset(_handle.DangerousGetHandle()); @@ -3173,6 +3989,22 @@ public sealed class BreadthThrust : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_breadth_thrust_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_breadth_thrust_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_breadth_thrust_reset(_handle.DangerousGetHandle()); @@ -3247,6 +4079,22 @@ public sealed class Breakaway : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_breakaway_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_breakaway_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_breakaway_reset(_handle.DangerousGetHandle()); @@ -3312,6 +4160,22 @@ public sealed class BullishPercentIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_bullish_percent_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_bullish_percent_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_bullish_percent_index_reset(_handle.DangerousGetHandle()); @@ -3362,6 +4226,22 @@ public sealed class BurkeRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_burke_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_burke_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_burke_ratio_reset(_handle.DangerousGetHandle()); @@ -3436,6 +4316,22 @@ public sealed class Butterfly : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_butterfly_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_butterfly_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_butterfly_reset(_handle.DangerousGetHandle()); @@ -3467,6 +4363,22 @@ public sealed class CalendarSpread : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_calendar_spread_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_calendar_spread_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_calendar_spread_reset(_handle.DangerousGetHandle()); @@ -3517,6 +4429,22 @@ public sealed class CalmarRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_calmar_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_calmar_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_calmar_ratio_reset(_handle.DangerousGetHandle()); @@ -3554,6 +4482,22 @@ public sealed class Camarilla : IDisposable return ok ? new CamarillaPivotsOutput(native.pp, native.r1, native.r2, native.r3, native.r4, native.s1, native.s2, native.s3, native.s4) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_camarilla_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_camarilla_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_camarilla_reset(_handle.DangerousGetHandle()); @@ -3592,6 +4536,22 @@ public sealed class CandleVolume : IDisposable return ok ? new CandleVolumeOutput(native.body, native.width) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_candle_volume_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_candle_volume_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_candle_volume_reset(_handle.DangerousGetHandle()); @@ -3667,6 +4627,22 @@ public sealed class Cci : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cci_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cci_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cci_reset(_handle.DangerousGetHandle()); @@ -3717,6 +4693,22 @@ public sealed class CenterOfGravity : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_center_of_gravity_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_center_of_gravity_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_center_of_gravity_reset(_handle.DangerousGetHandle()); @@ -3754,6 +4746,22 @@ public sealed class CentralPivotRange : IDisposable return ok ? new CentralPivotRangeOutput(native.pivot, native.tc, native.bc) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_central_pivot_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_central_pivot_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_central_pivot_range_reset(_handle.DangerousGetHandle()); @@ -3804,6 +4812,22 @@ public sealed class Cfo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cfo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cfo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cfo_reset(_handle.DangerousGetHandle()); @@ -3879,6 +4903,22 @@ public sealed class ChaikinMoneyFlow : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_chaikin_money_flow_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_chaikin_money_flow_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_chaikin_money_flow_reset(_handle.DangerousGetHandle()); @@ -3955,6 +4995,22 @@ public sealed class ChaikinOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_chaikin_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_chaikin_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_chaikin_oscillator_reset(_handle.DangerousGetHandle()); @@ -4031,6 +5087,22 @@ public sealed class ChaikinVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_chaikin_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_chaikin_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_chaikin_volatility_reset(_handle.DangerousGetHandle()); @@ -4070,6 +5142,22 @@ public sealed class ChandeKrollStop : IDisposable return ok ? new ChandeKrollStopOutput(native.stop_long, native.stop_short) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_chande_kroll_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_chande_kroll_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_chande_kroll_stop_reset(_handle.DangerousGetHandle()); @@ -4108,6 +5196,22 @@ public sealed class ChandelierExit : IDisposable return ok ? new ChandelierExitOutput(native.long_stop, native.short_stop) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_chandelier_exit_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_chandelier_exit_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_chandelier_exit_reset(_handle.DangerousGetHandle()); @@ -4183,6 +5287,22 @@ public sealed class ChoppinessIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_choppiness_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_choppiness_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_choppiness_index_reset(_handle.DangerousGetHandle()); @@ -4220,6 +5340,22 @@ public sealed class ClassicPivots : IDisposable return ok ? new ClassicPivotsOutput(native.pp, native.r1, native.r2, native.r3, native.s1, native.s2, native.s3) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_classic_pivots_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_classic_pivots_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_classic_pivots_reset(_handle.DangerousGetHandle()); @@ -4294,6 +5430,22 @@ public sealed class CloseVsOpen : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_close_vs_open_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_close_vs_open_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_close_vs_open_reset(_handle.DangerousGetHandle()); @@ -4368,6 +5520,22 @@ public sealed class ClosingMarubozu : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_closing_marubozu_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_closing_marubozu_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_closing_marubozu_reset(_handle.DangerousGetHandle()); @@ -4418,6 +5586,22 @@ public sealed class Cmo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cmo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cmo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cmo_reset(_handle.DangerousGetHandle()); @@ -4468,6 +5652,22 @@ public sealed class CoefficientOfVariation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_coefficient_of_variation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_coefficient_of_variation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_coefficient_of_variation_reset(_handle.DangerousGetHandle()); @@ -4507,6 +5707,22 @@ public sealed class Cointegration : IDisposable return ok ? new CointegrationOutput(native.hedge_ratio, native.spread, native.adf_stat) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cointegration_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cointegration_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cointegration_reset(_handle.DangerousGetHandle()); @@ -4557,6 +5773,22 @@ public sealed class CommonSenseRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_common_sense_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_common_sense_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_common_sense_ratio_reset(_handle.DangerousGetHandle()); @@ -4596,6 +5828,22 @@ public sealed class CompositeProfile : IDisposable return ok ? new CompositeProfileOutput(native.poc, native.vah, native.val) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_composite_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_composite_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_composite_profile_reset(_handle.DangerousGetHandle()); @@ -4670,6 +5918,22 @@ public sealed class ConcealingBabySwallow : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_concealing_baby_swallow_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_concealing_baby_swallow_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_concealing_baby_swallow_reset(_handle.DangerousGetHandle()); @@ -4720,6 +5984,22 @@ public sealed class ConditionalValueAtRisk : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_conditional_value_at_risk_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_conditional_value_at_risk_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_conditional_value_at_risk_reset(_handle.DangerousGetHandle()); @@ -4772,6 +6052,22 @@ public sealed class ConnorsRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_connors_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_connors_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_connors_rsi_reset(_handle.DangerousGetHandle()); @@ -4824,6 +6120,22 @@ public sealed class Coppock : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_coppock_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_coppock_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_coppock_reset(_handle.DangerousGetHandle()); @@ -4874,6 +6186,22 @@ public sealed class CorrelationTrendIndicator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_correlation_trend_indicator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_correlation_trend_indicator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_correlation_trend_indicator_reset(_handle.DangerousGetHandle()); @@ -4948,6 +6276,22 @@ public sealed class Counterattack : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_counterattack_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_counterattack_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_counterattack_reset(_handle.DangerousGetHandle()); @@ -5022,6 +6366,22 @@ public sealed class Crab : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_crab_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_crab_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_crab_reset(_handle.DangerousGetHandle()); @@ -5053,6 +6413,22 @@ public sealed class CumulativeVolumeDelta : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cumulative_volume_delta_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cumulative_volume_delta_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cumulative_volume_delta_reset(_handle.DangerousGetHandle()); @@ -5118,6 +6494,22 @@ public sealed class CumulativeVolumeIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cumulative_volume_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cumulative_volume_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cumulative_volume_index_reset(_handle.DangerousGetHandle()); @@ -5192,6 +6584,22 @@ public sealed class CupAndHandle : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cup_and_handle_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cup_and_handle_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cup_and_handle_reset(_handle.DangerousGetHandle()); @@ -5242,6 +6650,22 @@ public sealed class CyberneticCycle : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cybernetic_cycle_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cybernetic_cycle_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cybernetic_cycle_reset(_handle.DangerousGetHandle()); @@ -5316,6 +6740,22 @@ public sealed class Cypher : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_cypher_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_cypher_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_cypher_reset(_handle.DangerousGetHandle()); @@ -5368,6 +6808,22 @@ public sealed class DayOfWeekProfile : IDisposable return values; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_day_of_week_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_day_of_week_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_day_of_week_profile_reset(_handle.DangerousGetHandle()); @@ -5418,6 +6874,22 @@ public sealed class Decycler : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_decycler_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_decycler_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_decycler_reset(_handle.DangerousGetHandle()); @@ -5469,6 +6941,22 @@ public sealed class DecyclerOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_decycler_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_decycler_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_decycler_oscillator_reset(_handle.DangerousGetHandle()); @@ -5519,6 +7007,22 @@ public sealed class Dema : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_dema_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_dema_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_dema_reset(_handle.DangerousGetHandle()); @@ -5594,6 +7098,22 @@ public sealed class DemandIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_demand_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_demand_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_demand_index_reset(_handle.DangerousGetHandle()); @@ -5631,6 +7151,22 @@ public sealed class DemarkPivots : IDisposable return ok ? new DemarkPivotsOutput(native.pp, native.r1, native.s1) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_demark_pivots_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_demark_pivots_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_demark_pivots_reset(_handle.DangerousGetHandle()); @@ -5682,6 +7218,22 @@ public sealed class DepthSlope : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_depth_slope_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_depth_slope_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_depth_slope_reset(_handle.DangerousGetHandle()); @@ -5735,6 +7287,22 @@ public sealed class DerivativeOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_derivative_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_derivative_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_derivative_oscillator_reset(_handle.DangerousGetHandle()); @@ -5785,6 +7353,22 @@ public sealed class DetrendedStdDev : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_detrended_std_dev_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_detrended_std_dev_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_detrended_std_dev_reset(_handle.DangerousGetHandle()); @@ -5835,6 +7419,22 @@ public sealed class DisparityIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_disparity_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_disparity_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_disparity_index_reset(_handle.DangerousGetHandle()); @@ -5890,6 +7490,22 @@ public sealed class DistanceSsd : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_distance_ssd_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_distance_ssd_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_distance_ssd_reset(_handle.DangerousGetHandle()); @@ -5964,6 +7580,22 @@ public sealed class Doji : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_doji_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_doji_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_doji_reset(_handle.DangerousGetHandle()); @@ -6038,6 +7670,22 @@ public sealed class DojiStar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_doji_star_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_doji_star_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_doji_star_reset(_handle.DangerousGetHandle()); @@ -6128,6 +7776,22 @@ public sealed class Donchian : IDisposable return ok ? new DonchianOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_donchian_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_donchian_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_donchian_reset(_handle.DangerousGetHandle()); @@ -6166,6 +7830,22 @@ public sealed class DonchianStop : IDisposable return ok ? new DonchianStopOutput(native.stop_long, native.stop_short) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_donchian_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_donchian_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_donchian_stop_reset(_handle.DangerousGetHandle()); @@ -6204,6 +7884,22 @@ public sealed class DoubleBollinger : IDisposable return ok ? new DoubleBollingerOutput(native.upper_outer, native.upper_inner, native.middle, native.lower_inner, native.lower_outer) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_double_bollinger_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_double_bollinger_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_double_bollinger_reset(_handle.DangerousGetHandle()); @@ -6278,6 +7974,22 @@ public sealed class DoubleTopBottom : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_double_top_bottom_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_double_top_bottom_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_double_top_bottom_reset(_handle.DangerousGetHandle()); @@ -6352,6 +8064,22 @@ public sealed class DownsideGapThreeMethods : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_downside_gap_three_methods_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_downside_gap_three_methods_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_downside_gap_three_methods_reset(_handle.DangerousGetHandle()); @@ -6402,6 +8130,22 @@ public sealed class Dpo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_dpo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_dpo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_dpo_reset(_handle.DangerousGetHandle()); @@ -6476,6 +8220,22 @@ public sealed class DragonflyDoji : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_dragonfly_doji_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_dragonfly_doji_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_dragonfly_doji_reset(_handle.DangerousGetHandle()); @@ -6525,6 +8285,22 @@ public sealed class DrawdownDuration : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_drawdown_duration_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_drawdown_duration_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_drawdown_duration_reset(_handle.DangerousGetHandle()); @@ -6600,6 +8376,22 @@ public sealed class DumplingTop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_dumpling_top_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_dumpling_top_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_dumpling_top_reset(_handle.DangerousGetHandle()); @@ -6675,6 +8467,22 @@ public sealed class Dx : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_dx_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_dx_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_dx_reset(_handle.DangerousGetHandle()); @@ -6725,6 +8533,22 @@ public sealed class DynamicMomentumIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_dynamic_momentum_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_dynamic_momentum_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_dynamic_momentum_index_reset(_handle.DangerousGetHandle()); @@ -6800,6 +8624,22 @@ public sealed class EaseOfMovement : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ease_of_movement_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ease_of_movement_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ease_of_movement_reset(_handle.DangerousGetHandle()); @@ -6831,6 +8671,22 @@ public sealed class EffectiveSpread : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_effective_spread_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_effective_spread_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_effective_spread_reset(_handle.DangerousGetHandle()); @@ -6881,6 +8737,22 @@ public sealed class EhlersStochastic : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ehlers_stochastic_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ehlers_stochastic_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ehlers_stochastic_reset(_handle.DangerousGetHandle()); @@ -6931,6 +8803,22 @@ public sealed class Ehma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ehma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ehma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ehma_reset(_handle.DangerousGetHandle()); @@ -6984,6 +8872,22 @@ public sealed class ElderImpulse : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_elder_impulse_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_elder_impulse_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_elder_impulse_reset(_handle.DangerousGetHandle()); @@ -7022,6 +8926,22 @@ public sealed class ElderRay : IDisposable return ok ? new ElderRayOutput(native.bull_power, native.bear_power) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_elder_ray_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_elder_ray_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_elder_ray_reset(_handle.DangerousGetHandle()); @@ -7060,6 +8980,22 @@ public sealed class ElderSafeZone : IDisposable return ok ? new ElderSafeZoneOutput(native.@value, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_elder_safe_zone_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_elder_safe_zone_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_elder_safe_zone_reset(_handle.DangerousGetHandle()); @@ -7110,6 +9046,22 @@ public sealed class Ema : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ema_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ema_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ema_reset(_handle.DangerousGetHandle()); @@ -7160,6 +9112,22 @@ public sealed class EmpiricalModeDecomposition : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_empirical_mode_decomposition_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_empirical_mode_decomposition_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_empirical_mode_decomposition_reset(_handle.DangerousGetHandle()); @@ -7234,6 +9202,22 @@ public sealed class Engulfing : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_engulfing_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_engulfing_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_engulfing_reset(_handle.DangerousGetHandle()); @@ -7272,6 +9256,22 @@ public sealed class Equivolume : IDisposable return ok ? new EquivolumeOutput(native.height, native.width) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_equivolume_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_equivolume_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_equivolume_reset(_handle.DangerousGetHandle()); @@ -7303,6 +9303,22 @@ public sealed class EstimatedLeverageRatio : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_estimated_leverage_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_estimated_leverage_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_estimated_leverage_ratio_reset(_handle.DangerousGetHandle()); @@ -7354,6 +9370,22 @@ public sealed class EvenBetterSinewave : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_even_better_sinewave_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_even_better_sinewave_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_even_better_sinewave_reset(_handle.DangerousGetHandle()); @@ -7428,6 +9460,22 @@ public sealed class EveningDojiStar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_evening_doji_star_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_evening_doji_star_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_evening_doji_star_reset(_handle.DangerousGetHandle()); @@ -7503,6 +9551,22 @@ public sealed class Evwma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_evwma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_evwma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_evwma_reset(_handle.DangerousGetHandle()); @@ -7552,6 +9616,22 @@ public sealed class EwmaVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ewma_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ewma_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ewma_volatility_reset(_handle.DangerousGetHandle()); @@ -7602,6 +9682,22 @@ public sealed class Expectancy : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_expectancy_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_expectancy_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_expectancy_reset(_handle.DangerousGetHandle()); @@ -7676,6 +9772,22 @@ public sealed class FallingThreeMethods : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_falling_three_methods_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_falling_three_methods_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_falling_three_methods_reset(_handle.DangerousGetHandle()); @@ -7725,6 +9837,22 @@ public sealed class Fama : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fama_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fama_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fama_reset(_handle.DangerousGetHandle()); @@ -7762,6 +9890,22 @@ public sealed class FibArcs : IDisposable return ok ? new FibArcsOutput(native.arc_382, native.arc_500, native.arc_618) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_arcs_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_arcs_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_arcs_reset(_handle.DangerousGetHandle()); @@ -7799,6 +9943,22 @@ public sealed class FibChannel : IDisposable return ok ? new FibChannelOutput(native.@base, native.level_618, native.level_1000, native.level_1618) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_channel_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_channel_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_channel_reset(_handle.DangerousGetHandle()); @@ -7836,6 +9996,22 @@ public sealed class FibConfluence : IDisposable return ok ? new FibConfluenceOutput(native.price, native.strength) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_confluence_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_confluence_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_confluence_reset(_handle.DangerousGetHandle()); @@ -7873,6 +10049,22 @@ public sealed class FibExtension : IDisposable return ok ? new FibExtensionOutput(native.level_1272, native.level_1414, native.level_1618, native.level_2000, native.level_2618) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_extension_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_extension_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_extension_reset(_handle.DangerousGetHandle()); @@ -7910,6 +10102,22 @@ public sealed class FibFan : IDisposable return ok ? new FibFanOutput(native.fan_382, native.fan_500, native.fan_618) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_fan_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_fan_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_fan_reset(_handle.DangerousGetHandle()); @@ -7947,6 +10155,22 @@ public sealed class FibProjection : IDisposable return ok ? new FibProjectionOutput(native.level_618, native.level_1000, native.level_1618, native.level_2618) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_projection_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_projection_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_projection_reset(_handle.DangerousGetHandle()); @@ -7984,6 +10208,22 @@ public sealed class FibRetracement : IDisposable return ok ? new FibRetracementOutput(native.level_0, native.level_236, native.level_382, native.level_500, native.level_618, native.level_786, native.level_1000) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_retracement_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_retracement_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_retracement_reset(_handle.DangerousGetHandle()); @@ -8021,6 +10261,22 @@ public sealed class FibTimeZones : IDisposable return ok ? new FibTimeZonesOutput(native.on_zone, native.bars_to_next) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fib_time_zones_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fib_time_zones_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fib_time_zones_reset(_handle.DangerousGetHandle()); @@ -8058,6 +10314,22 @@ public sealed class FibonacciPivots : IDisposable return ok ? new FibonacciPivotsOutput(native.pp, native.r1, native.r2, native.r3, native.s1, native.s2, native.s3) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fibonacci_pivots_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fibonacci_pivots_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fibonacci_pivots_reset(_handle.DangerousGetHandle()); @@ -8108,6 +10380,22 @@ public sealed class FisherRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fisher_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fisher_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fisher_rsi_reset(_handle.DangerousGetHandle()); @@ -8158,6 +10446,22 @@ public sealed class FisherTransform : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fisher_transform_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fisher_transform_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fisher_transform_reset(_handle.DangerousGetHandle()); @@ -8232,6 +10536,22 @@ public sealed class FlagPennant : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_flag_pennant_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_flag_pennant_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_flag_pennant_reset(_handle.DangerousGetHandle()); @@ -8284,6 +10604,22 @@ public sealed class Footprint : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_footprint_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_footprint_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_footprint_reset(_handle.DangerousGetHandle()); @@ -8359,6 +10695,22 @@ public sealed class ForceIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_force_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_force_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_force_index_reset(_handle.DangerousGetHandle()); @@ -8397,6 +10749,22 @@ public sealed class FractalChaosBands : IDisposable return ok ? new FractalChaosBandsOutput(native.upper, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fractal_chaos_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fractal_chaos_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fractal_chaos_bands_reset(_handle.DangerousGetHandle()); @@ -8447,6 +10815,22 @@ public sealed class Frama : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_frama_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_frama_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_frama_reset(_handle.DangerousGetHandle()); @@ -8522,6 +10906,22 @@ public sealed class FryPanBottom : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_fry_pan_bottom_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_fry_pan_bottom_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_fry_pan_bottom_reset(_handle.DangerousGetHandle()); @@ -8553,6 +10953,22 @@ public sealed class FundingBasis : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_funding_basis_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_funding_basis_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_funding_basis_reset(_handle.DangerousGetHandle()); @@ -8584,6 +11000,22 @@ public sealed class FundingImpliedApr : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_funding_implied_apr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_funding_implied_apr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_funding_implied_apr_reset(_handle.DangerousGetHandle()); @@ -8615,6 +11047,22 @@ public sealed class FundingRate : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_funding_rate_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_funding_rate_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_funding_rate_reset(_handle.DangerousGetHandle()); @@ -8647,6 +11095,22 @@ public sealed class FundingRateMean : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_funding_rate_mean_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_funding_rate_mean_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_funding_rate_mean_reset(_handle.DangerousGetHandle()); @@ -8679,6 +11143,22 @@ public sealed class FundingRateZScore : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_funding_rate_z_score_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_funding_rate_z_score_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_funding_rate_z_score_reset(_handle.DangerousGetHandle()); @@ -8729,6 +11209,22 @@ public sealed class GainLossRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_gain_loss_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_gain_loss_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_gain_loss_ratio_reset(_handle.DangerousGetHandle()); @@ -8779,6 +11275,22 @@ public sealed class GainToPainRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_gain_to_pain_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_gain_to_pain_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_gain_to_pain_ratio_reset(_handle.DangerousGetHandle()); @@ -8853,6 +11365,22 @@ public sealed class GapSideBySideWhite : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_gap_side_by_side_white_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_gap_side_by_side_white_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_gap_side_by_side_white_reset(_handle.DangerousGetHandle()); @@ -8902,6 +11430,22 @@ public sealed class Garch11 : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_garch11_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_garch11_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_garch11_reset(_handle.DangerousGetHandle()); @@ -8978,6 +11522,22 @@ public sealed class GarmanKlassVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_garman_klass_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_garman_klass_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_garman_klass_volatility_reset(_handle.DangerousGetHandle()); @@ -9052,6 +11612,22 @@ public sealed class Gartley : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_gartley_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_gartley_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_gartley_reset(_handle.DangerousGetHandle()); @@ -9092,6 +11668,22 @@ public sealed class GatorOscillator : IDisposable return ok ? new GatorOscillatorOutput(native.upper, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_gator_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_gator_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_gator_oscillator_reset(_handle.DangerousGetHandle()); @@ -9142,6 +11734,22 @@ public sealed class GeneralizedDema : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_generalized_dema_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_generalized_dema_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_generalized_dema_reset(_handle.DangerousGetHandle()); @@ -9192,6 +11800,22 @@ public sealed class GeometricMa : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_geometric_ma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_geometric_ma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_geometric_ma_reset(_handle.DangerousGetHandle()); @@ -9229,6 +11853,22 @@ public sealed class GoldenPocket : IDisposable return ok ? new GoldenPocketOutput(native.low, native.mid, native.high) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_golden_pocket_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_golden_pocket_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_golden_pocket_reset(_handle.DangerousGetHandle()); @@ -9285,6 +11925,22 @@ public sealed class GrangerCausality : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_granger_causality_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_granger_causality_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_granger_causality_reset(_handle.DangerousGetHandle()); @@ -9359,6 +12015,22 @@ public sealed class GravestoneDoji : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_gravestone_doji_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_gravestone_doji_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_gravestone_doji_reset(_handle.DangerousGetHandle()); @@ -9433,6 +12105,22 @@ public sealed class Hammer : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hammer_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hammer_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hammer_reset(_handle.DangerousGetHandle()); @@ -9507,6 +12195,22 @@ public sealed class HangingMan : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hanging_man_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hanging_man_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hanging_man_reset(_handle.DangerousGetHandle()); @@ -9581,6 +12285,22 @@ public sealed class Harami : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_harami_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_harami_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_harami_reset(_handle.DangerousGetHandle()); @@ -9655,6 +12375,22 @@ public sealed class HaramiCross : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_harami_cross_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_harami_cross_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_harami_cross_reset(_handle.DangerousGetHandle()); @@ -9710,6 +12446,22 @@ public sealed class HasbrouckInformationShare : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hasbrouck_information_share_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hasbrouck_information_share_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hasbrouck_information_share_reset(_handle.DangerousGetHandle()); @@ -9784,6 +12536,22 @@ public sealed class HeadAndShoulders : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_head_and_shoulders_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_head_and_shoulders_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_head_and_shoulders_reset(_handle.DangerousGetHandle()); @@ -9821,6 +12589,22 @@ public sealed class HeikinAshi : IDisposable return ok ? new HeikinAshiOutput(native.open, native.high, native.low, native.close) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_heikin_ashi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_heikin_ashi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_heikin_ashi_reset(_handle.DangerousGetHandle()); @@ -9896,6 +12680,22 @@ public sealed class HeikinAshiOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_heikin_ashi_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_heikin_ashi_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_heikin_ashi_oscillator_reset(_handle.DangerousGetHandle()); @@ -9971,6 +12771,22 @@ public sealed class HiLoActivator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hi_lo_activator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hi_lo_activator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hi_lo_activator_reset(_handle.DangerousGetHandle()); @@ -10037,6 +12853,22 @@ public sealed class HighLowIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_high_low_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_high_low_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_high_low_index_reset(_handle.DangerousGetHandle()); @@ -10111,6 +12943,22 @@ public sealed class HighLowRange : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_high_low_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_high_low_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_high_low_range_reset(_handle.DangerousGetHandle()); @@ -10150,6 +12998,22 @@ public sealed class HighLowVolumeNodes : IDisposable return ok ? new HighLowVolumeNodesOutput(native.hvn, native.lvn) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_high_low_volume_nodes_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_high_low_volume_nodes_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_high_low_volume_nodes_reset(_handle.DangerousGetHandle()); @@ -10224,6 +13088,22 @@ public sealed class HighWave : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_high_wave_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_high_wave_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_high_wave_reset(_handle.DangerousGetHandle()); @@ -10274,6 +13154,22 @@ public sealed class HighpassFilter : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_highpass_filter_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_highpass_filter_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_highpass_filter_reset(_handle.DangerousGetHandle()); @@ -10348,6 +13244,22 @@ public sealed class Hikkake : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hikkake_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hikkake_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hikkake_reset(_handle.DangerousGetHandle()); @@ -10422,6 +13334,22 @@ public sealed class HikkakeModified : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hikkake_modified_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hikkake_modified_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hikkake_modified_reset(_handle.DangerousGetHandle()); @@ -10471,6 +13399,22 @@ public sealed class HilbertDominantCycle : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hilbert_dominant_cycle_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hilbert_dominant_cycle_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hilbert_dominant_cycle_reset(_handle.DangerousGetHandle()); @@ -10522,6 +13466,22 @@ public sealed class HistoricalVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_historical_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_historical_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_historical_volatility_reset(_handle.DangerousGetHandle()); @@ -10572,6 +13532,22 @@ public sealed class Hma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hma_reset(_handle.DangerousGetHandle()); @@ -10621,6 +13597,22 @@ public sealed class HoltWinters : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_holt_winters_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_holt_winters_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_holt_winters_reset(_handle.DangerousGetHandle()); @@ -10695,6 +13687,22 @@ public sealed class HomingPigeon : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_homing_pigeon_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_homing_pigeon_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_homing_pigeon_reset(_handle.DangerousGetHandle()); @@ -10744,6 +13752,22 @@ public sealed class HtDcPhase : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ht_dc_phase_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ht_dc_phase_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ht_dc_phase_reset(_handle.DangerousGetHandle()); @@ -10781,6 +13805,22 @@ public sealed class HtPhasor : IDisposable return ok ? new HtPhasorOutput(native.inphase, native.quadrature) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ht_phasor_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ht_phasor_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ht_phasor_reset(_handle.DangerousGetHandle()); @@ -10830,6 +13870,22 @@ public sealed class HtTrendMode : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ht_trend_mode_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ht_trend_mode_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ht_trend_mode_reset(_handle.DangerousGetHandle()); @@ -10868,6 +13924,22 @@ public sealed class HurstChannel : IDisposable return ok ? new HurstChannelOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hurst_channel_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hurst_channel_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hurst_channel_reset(_handle.DangerousGetHandle()); @@ -10919,6 +13991,22 @@ public sealed class HurstExponent : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_hurst_exponent_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_hurst_exponent_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_hurst_exponent_reset(_handle.DangerousGetHandle()); @@ -10960,6 +14048,22 @@ public sealed class Ichimoku : IDisposable return ok ? new IchimokuOutput(native.tenkan, native.kijun, native.senkou_a, native.senkou_b, native.chikou) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ichimoku_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ichimoku_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ichimoku_reset(_handle.DangerousGetHandle()); @@ -11034,6 +14138,22 @@ public sealed class IdenticalThreeCrows : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_identical_three_crows_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_identical_three_crows_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_identical_three_crows_reset(_handle.DangerousGetHandle()); @@ -11160,6 +14280,22 @@ public sealed class InNeck : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_in_neck_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_in_neck_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_in_neck_reset(_handle.DangerousGetHandle()); @@ -11236,6 +14372,22 @@ public sealed class Inertia : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_inertia_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_inertia_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_inertia_reset(_handle.DangerousGetHandle()); @@ -11291,6 +14443,22 @@ public sealed class InformationRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_information_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_information_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_information_ratio_reset(_handle.DangerousGetHandle()); @@ -11329,6 +14497,22 @@ public sealed class InitialBalance : IDisposable return ok ? new InitialBalanceOutput(native.high, native.low) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_initial_balance_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_initial_balance_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_initial_balance_reset(_handle.DangerousGetHandle()); @@ -11379,6 +14563,22 @@ public sealed class InstantaneousTrendline : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_instantaneous_trendline_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_instantaneous_trendline_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_instantaneous_trendline_reset(_handle.DangerousGetHandle()); @@ -11453,6 +14653,22 @@ public sealed class IntradayIntensity : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_intraday_intensity_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_intraday_intensity_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_intraday_intensity_reset(_handle.DangerousGetHandle()); @@ -11528,6 +14744,22 @@ public sealed class IntradayMomentumIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_intraday_momentum_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_intraday_momentum_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_intraday_momentum_index_reset(_handle.DangerousGetHandle()); @@ -11581,6 +14813,22 @@ public sealed class IntradayVolatilityProfile : IDisposable return values; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_intraday_volatility_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_intraday_volatility_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_intraday_volatility_profile_reset(_handle.DangerousGetHandle()); @@ -11630,6 +14878,22 @@ public sealed class InverseFisherTransform : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_inverse_fisher_transform_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_inverse_fisher_transform_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_inverse_fisher_transform_reset(_handle.DangerousGetHandle()); @@ -11704,6 +14968,22 @@ public sealed class InvertedHammer : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_inverted_hammer_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_inverted_hammer_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_inverted_hammer_reset(_handle.DangerousGetHandle()); @@ -11754,6 +15034,22 @@ public sealed class JarqueBera : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_jarque_bera_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_jarque_bera_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_jarque_bera_reset(_handle.DangerousGetHandle()); @@ -11804,6 +15100,22 @@ public sealed class Jma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_jma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_jma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_jma_reset(_handle.DangerousGetHandle()); @@ -11854,6 +15166,22 @@ public sealed class JumpIndicator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_jump_indicator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_jump_indicator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_jump_indicator_reset(_handle.DangerousGetHandle()); @@ -11904,6 +15232,22 @@ public sealed class KRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_k_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_k_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_k_ratio_reset(_handle.DangerousGetHandle()); @@ -11993,6 +15337,22 @@ public sealed class KalmanHedgeRatio : IDisposable return ok ? new KalmanHedgeRatioOutput(native.hedge_ratio, native.intercept, native.spread) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kalman_hedge_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kalman_hedge_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kalman_hedge_ratio_reset(_handle.DangerousGetHandle()); @@ -12045,6 +15405,22 @@ public sealed class Kama : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kama_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kama_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kama_reset(_handle.DangerousGetHandle()); @@ -12083,6 +15459,22 @@ public sealed class KaseDevStop : IDisposable return ok ? new KaseDevStopOutput(native.@value, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kase_dev_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kase_dev_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kase_dev_stop_reset(_handle.DangerousGetHandle()); @@ -12122,6 +15514,22 @@ public sealed class KasePermissionStochastic : IDisposable return ok ? new KasePermissionStochasticOutput(native.fast, native.slow) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kase_permission_stochastic_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kase_permission_stochastic_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kase_permission_stochastic_reset(_handle.DangerousGetHandle()); @@ -12172,6 +15580,22 @@ public sealed class KellyCriterion : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kelly_criterion_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kelly_criterion_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kelly_criterion_reset(_handle.DangerousGetHandle()); @@ -12211,6 +15635,22 @@ public sealed class Keltner : IDisposable return ok ? new KeltnerOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_keltner_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_keltner_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_keltner_reset(_handle.DangerousGetHandle()); @@ -12266,6 +15706,22 @@ public sealed class KendallTau : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kendall_tau_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kendall_tau_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kendall_tau_reset(_handle.DangerousGetHandle()); @@ -12340,6 +15796,22 @@ public sealed class Kicking : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kicking_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kicking_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kicking_reset(_handle.DangerousGetHandle()); @@ -12414,6 +15886,22 @@ public sealed class KickingByLength : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kicking_by_length_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kicking_by_length_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kicking_by_length_reset(_handle.DangerousGetHandle()); @@ -12460,6 +15948,22 @@ public sealed class Kst : IDisposable return ok ? new KstOutput(native.kst, native.signal) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kst_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kst_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kst_reset(_handle.DangerousGetHandle()); @@ -12510,6 +16014,22 @@ public sealed class Kurtosis : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kurtosis_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kurtosis_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kurtosis_reset(_handle.DangerousGetHandle()); @@ -12586,6 +16106,22 @@ public sealed class Kvo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kvo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kvo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kvo_reset(_handle.DangerousGetHandle()); @@ -12618,6 +16154,22 @@ public sealed class KylesLambda : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_kyles_lambda_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_kyles_lambda_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_kyles_lambda_reset(_handle.DangerousGetHandle()); @@ -12692,6 +16244,22 @@ public sealed class LadderBottom : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ladder_bottom_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ladder_bottom_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ladder_bottom_reset(_handle.DangerousGetHandle()); @@ -12741,6 +16309,22 @@ public sealed class LaguerreRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_laguerre_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_laguerre_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_laguerre_rsi_reset(_handle.DangerousGetHandle()); @@ -12780,6 +16364,22 @@ public sealed class LeadLagCrossCorrelation : IDisposable return ok ? new LeadLagCrossCorrelationOutput(native.lag, native.correlation) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_lead_lag_cross_correlation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_lead_lag_cross_correlation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_lead_lag_cross_correlation_reset(_handle.DangerousGetHandle()); @@ -12830,6 +16430,22 @@ public sealed class LinRegAngle : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_lin_reg_angle_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_lin_reg_angle_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_lin_reg_angle_reset(_handle.DangerousGetHandle()); @@ -12868,6 +16484,22 @@ public sealed class LinRegChannel : IDisposable return ok ? new LinRegChannelOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_lin_reg_channel_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_lin_reg_channel_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_lin_reg_channel_reset(_handle.DangerousGetHandle()); @@ -12918,6 +16550,22 @@ public sealed class LinRegIntercept : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_lin_reg_intercept_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_lin_reg_intercept_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_lin_reg_intercept_reset(_handle.DangerousGetHandle()); @@ -12968,6 +16616,22 @@ public sealed class LinRegSlope : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_lin_reg_slope_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_lin_reg_slope_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_lin_reg_slope_reset(_handle.DangerousGetHandle()); @@ -13018,6 +16682,22 @@ public sealed class LinearRegression : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_linear_regression_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_linear_regression_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_linear_regression_reset(_handle.DangerousGetHandle()); @@ -13055,6 +16735,22 @@ public sealed class LiquidationFeatures : IDisposable return ok ? new LiquidationFeaturesOutput(native.long_, native.short_, native.net, native.total, native.imbalance) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_liquidation_features_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_liquidation_features_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_liquidation_features_reset(_handle.DangerousGetHandle()); @@ -13105,6 +16801,22 @@ public sealed class LogReturn : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_log_return_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_log_return_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_log_return_reset(_handle.DangerousGetHandle()); @@ -13179,6 +16891,22 @@ public sealed class LongLeggedDoji : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_long_legged_doji_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_long_legged_doji_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_long_legged_doji_reset(_handle.DangerousGetHandle()); @@ -13253,6 +16981,22 @@ public sealed class LongLine : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_long_line_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_long_line_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_long_line_reset(_handle.DangerousGetHandle()); @@ -13284,6 +17028,22 @@ public sealed class LongShortRatio : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_long_short_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_long_short_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_long_short_ratio_reset(_handle.DangerousGetHandle()); @@ -13334,6 +17094,22 @@ public sealed class M2Measure : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_m2_measure_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_m2_measure_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_m2_measure_reset(_handle.DangerousGetHandle()); @@ -13372,6 +17148,22 @@ public sealed class MaEnvelope : IDisposable return ok ? new MaEnvelopeOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ma_envelope_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ma_envelope_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ma_envelope_reset(_handle.DangerousGetHandle()); @@ -13412,6 +17204,22 @@ public sealed class MacdExt : IDisposable return ok ? new MacdOutput(native.macd, native.signal, native.histogram) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_macd_ext_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_macd_ext_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_macd_ext_reset(_handle.DangerousGetHandle()); @@ -13450,6 +17258,22 @@ public sealed class MacdFix : IDisposable return ok ? new MacdOutput(native.macd, native.signal, native.histogram) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_macd_fix_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_macd_fix_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_macd_fix_reset(_handle.DangerousGetHandle()); @@ -13502,6 +17326,22 @@ public sealed class MacdHistogram : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_macd_histogram_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_macd_histogram_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_macd_histogram_reset(_handle.DangerousGetHandle()); @@ -13542,6 +17382,22 @@ public sealed class MacdIndicator : IDisposable return ok ? new MacdOutput(native.macd, native.signal, native.histogram) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_macd_indicator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_macd_indicator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_macd_indicator_reset(_handle.DangerousGetHandle()); @@ -13579,6 +17435,22 @@ public sealed class Mama : IDisposable return ok ? new MamaOutput(native.mama, native.fama) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mama_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mama_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mama_reset(_handle.DangerousGetHandle()); @@ -13653,6 +17525,22 @@ public sealed class MarketFacilitationIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_market_facilitation_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_market_facilitation_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_market_facilitation_index_reset(_handle.DangerousGetHandle()); @@ -13703,6 +17591,22 @@ public sealed class MartinRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_martin_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_martin_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_martin_ratio_reset(_handle.DangerousGetHandle()); @@ -13777,6 +17681,22 @@ public sealed class Marubozu : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_marubozu_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_marubozu_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_marubozu_reset(_handle.DangerousGetHandle()); @@ -13853,6 +17773,22 @@ public sealed class MassIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mass_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mass_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mass_index_reset(_handle.DangerousGetHandle()); @@ -13927,6 +17863,22 @@ public sealed class MatHold : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mat_hold_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mat_hold_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mat_hold_reset(_handle.DangerousGetHandle()); @@ -14001,6 +17953,22 @@ public sealed class MatchingLow : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_matching_low_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_matching_low_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_matching_low_reset(_handle.DangerousGetHandle()); @@ -14051,6 +18019,22 @@ public sealed class MaxDrawdown : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_max_drawdown_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_max_drawdown_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_max_drawdown_reset(_handle.DangerousGetHandle()); @@ -14116,6 +18100,22 @@ public sealed class McClellanOscillator : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mc_clellan_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mc_clellan_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mc_clellan_oscillator_reset(_handle.DangerousGetHandle()); @@ -14181,6 +18181,22 @@ public sealed class McClellanSummationIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mc_clellan_summation_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mc_clellan_summation_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mc_clellan_summation_index_reset(_handle.DangerousGetHandle()); @@ -14231,6 +18247,22 @@ public sealed class McGinleyDynamic : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mc_ginley_dynamic_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mc_ginley_dynamic_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mc_ginley_dynamic_reset(_handle.DangerousGetHandle()); @@ -14281,6 +18313,22 @@ public sealed class MedianAbsoluteDeviation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_median_absolute_deviation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_median_absolute_deviation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_median_absolute_deviation_reset(_handle.DangerousGetHandle()); @@ -14319,6 +18367,22 @@ public sealed class MedianChannel : IDisposable return ok ? new MedianChannelOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_median_channel_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_median_channel_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_median_channel_reset(_handle.DangerousGetHandle()); @@ -14369,6 +18433,22 @@ public sealed class MedianMa : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_median_ma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_median_ma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_median_ma_reset(_handle.DangerousGetHandle()); @@ -14443,6 +18523,22 @@ public sealed class MedianPrice : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_median_price_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_median_price_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_median_price_reset(_handle.DangerousGetHandle()); @@ -14518,6 +18614,22 @@ public sealed class Mfi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mfi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mfi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mfi_reset(_handle.DangerousGetHandle()); @@ -14569,6 +18681,22 @@ public sealed class Microprice : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_microprice_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_microprice_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_microprice_reset(_handle.DangerousGetHandle()); @@ -14619,6 +18747,22 @@ public sealed class MidPoint : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mid_point_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mid_point_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mid_point_reset(_handle.DangerousGetHandle()); @@ -14694,6 +18838,22 @@ public sealed class MidPrice : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mid_price_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mid_price_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mid_price_reset(_handle.DangerousGetHandle()); @@ -14769,6 +18929,22 @@ public sealed class MinusDi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_minus_di_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_minus_di_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_minus_di_reset(_handle.DangerousGetHandle()); @@ -14844,6 +19020,22 @@ public sealed class MinusDm : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_minus_dm_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_minus_dm_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_minus_dm_reset(_handle.DangerousGetHandle()); @@ -14882,6 +19074,22 @@ public sealed class ModifiedMaStop : IDisposable return ok ? new ModifiedMaStopOutput(native.@value, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_modified_ma_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_modified_ma_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_modified_ma_stop_reset(_handle.DangerousGetHandle()); @@ -14932,6 +19140,22 @@ public sealed class Mom : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_mom_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_mom_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_mom_reset(_handle.DangerousGetHandle()); @@ -15006,6 +19230,22 @@ public sealed class MorningDojiStar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_morning_doji_star_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_morning_doji_star_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_morning_doji_star_reset(_handle.DangerousGetHandle()); @@ -15080,6 +19320,22 @@ public sealed class MorningEveningStar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_morning_evening_star_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_morning_evening_star_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_morning_evening_star_reset(_handle.DangerousGetHandle()); @@ -15118,6 +19374,22 @@ public sealed class MurreyMathLines : IDisposable return ok ? new MurreyMathLinesOutput(native.mm8_8, native.mm7_8, native.mm6_8, native.mm5_8, native.mm4_8, native.mm3_8, native.mm2_8, native.mm1_8, native.mm0_8) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_murrey_math_lines_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_murrey_math_lines_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_murrey_math_lines_reset(_handle.DangerousGetHandle()); @@ -15194,6 +19466,22 @@ public sealed class NakedPoc : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_naked_poc_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_naked_poc_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_naked_poc_reset(_handle.DangerousGetHandle()); @@ -15269,6 +19557,22 @@ public sealed class Natr : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_natr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_natr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_natr_reset(_handle.DangerousGetHandle()); @@ -15334,6 +19638,22 @@ public sealed class NewHighsNewLows : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_new_highs_new_lows_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_new_highs_new_lows_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_new_highs_new_lows_reset(_handle.DangerousGetHandle()); @@ -15409,6 +19729,22 @@ public sealed class NewPriceLines : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_new_price_lines_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_new_price_lines_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_new_price_lines_reset(_handle.DangerousGetHandle()); @@ -15446,6 +19782,22 @@ public sealed class Nrtr : IDisposable return ok ? new NrtrOutput(native.@value, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_nrtr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_nrtr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_nrtr_reset(_handle.DangerousGetHandle()); @@ -15520,6 +19872,22 @@ public sealed class Nvi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_nvi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_nvi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_nvi_reset(_handle.DangerousGetHandle()); @@ -15594,6 +19962,22 @@ public sealed class Obv : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_obv_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_obv_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_obv_reset(_handle.DangerousGetHandle()); @@ -15626,6 +20010,22 @@ public sealed class OIPriceDivergence : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_oi_price_divergence_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_oi_price_divergence_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_oi_price_divergence_reset(_handle.DangerousGetHandle()); @@ -15657,6 +20057,22 @@ public sealed class OiToVolumeRatio : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_oi_to_volume_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_oi_to_volume_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_oi_to_volume_ratio_reset(_handle.DangerousGetHandle()); @@ -15688,6 +20104,22 @@ public sealed class OIWeighted : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_oi_weighted_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_oi_weighted_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_oi_weighted_reset(_handle.DangerousGetHandle()); @@ -15738,6 +20170,22 @@ public sealed class OmegaRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_omega_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_omega_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_omega_ratio_reset(_handle.DangerousGetHandle()); @@ -15812,6 +20260,22 @@ public sealed class OnNeck : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_on_neck_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_on_neck_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_on_neck_reset(_handle.DangerousGetHandle()); @@ -15843,6 +20307,22 @@ public sealed class OpenInterestDelta : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_open_interest_delta_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_open_interest_delta_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_open_interest_delta_reset(_handle.DangerousGetHandle()); @@ -15875,6 +20355,22 @@ public sealed class OpenInterestMomentum : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_open_interest_momentum_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_open_interest_momentum_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_open_interest_momentum_reset(_handle.DangerousGetHandle()); @@ -15949,6 +20445,22 @@ public sealed class OpeningMarubozu : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_opening_marubozu_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_opening_marubozu_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_opening_marubozu_reset(_handle.DangerousGetHandle()); @@ -15987,6 +20499,22 @@ public sealed class OpeningRange : IDisposable return ok ? new OpeningRangeOutput(native.high, native.low, native.breakout_distance) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_opening_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_opening_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_opening_range_reset(_handle.DangerousGetHandle()); @@ -16038,6 +20566,22 @@ public sealed class OrderBookImbalanceFull : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_order_book_imbalance_full_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_order_book_imbalance_full_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_order_book_imbalance_full_reset(_handle.DangerousGetHandle()); @@ -16089,6 +20633,22 @@ public sealed class OrderBookImbalanceTop1 : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_order_book_imbalance_top1_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_order_book_imbalance_top1_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_order_book_imbalance_top1_reset(_handle.DangerousGetHandle()); @@ -16141,6 +20701,22 @@ public sealed class OrderBookImbalanceTopN : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_order_book_imbalance_top_n_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_order_book_imbalance_top_n_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_order_book_imbalance_top_n_reset(_handle.DangerousGetHandle()); @@ -16193,6 +20769,22 @@ public sealed class OrderFlowImbalance : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_order_flow_imbalance_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_order_flow_imbalance_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_order_flow_imbalance_reset(_handle.DangerousGetHandle()); @@ -16248,6 +20840,22 @@ public sealed class OuHalfLife : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ou_half_life_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ou_half_life_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ou_half_life_reset(_handle.DangerousGetHandle()); @@ -16322,6 +20930,22 @@ public sealed class OvernightGap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_overnight_gap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_overnight_gap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_overnight_gap_reset(_handle.DangerousGetHandle()); @@ -16359,6 +20983,22 @@ public sealed class OvernightIntradayReturn : IDisposable return ok ? new OvernightIntradayReturnOutput(native.overnight, native.intraday) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_overnight_intraday_return_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_overnight_intraday_return_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_overnight_intraday_return_reset(_handle.DangerousGetHandle()); @@ -16409,6 +21049,22 @@ public sealed class PainIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pain_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pain_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pain_index_reset(_handle.DangerousGetHandle()); @@ -16465,6 +21121,22 @@ public sealed class PairSpreadZScore : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pair_spread_z_score_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pair_spread_z_score_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pair_spread_z_score_reset(_handle.DangerousGetHandle()); @@ -16520,6 +21192,22 @@ public sealed class PairwiseBeta : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pairwise_beta_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pairwise_beta_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pairwise_beta_reset(_handle.DangerousGetHandle()); @@ -16596,6 +21284,22 @@ public sealed class ParkinsonVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_parkinson_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_parkinson_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_parkinson_volatility_reset(_handle.DangerousGetHandle()); @@ -16651,6 +21355,22 @@ public sealed class PearsonCorrelation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pearson_correlation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pearson_correlation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pearson_correlation_reset(_handle.DangerousGetHandle()); @@ -16716,6 +21436,22 @@ public sealed class PercentAboveMa : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_percent_above_ma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_percent_above_ma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_percent_above_ma_reset(_handle.DangerousGetHandle()); @@ -16766,6 +21502,22 @@ public sealed class PercentB : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_percent_b_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_percent_b_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_percent_b_reset(_handle.DangerousGetHandle()); @@ -16815,6 +21567,22 @@ public sealed class PercentageTrailingStop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_percentage_trailing_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_percentage_trailing_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_percentage_trailing_stop_reset(_handle.DangerousGetHandle()); @@ -16846,6 +21614,22 @@ public sealed class PerpetualPremiumIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_perpetual_premium_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_perpetual_premium_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_perpetual_premium_index_reset(_handle.DangerousGetHandle()); @@ -16921,6 +21705,22 @@ public sealed class Pgo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pgo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pgo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pgo_reset(_handle.DangerousGetHandle()); @@ -16995,6 +21795,22 @@ public sealed class PiercingDarkCloud : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_piercing_dark_cloud_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_piercing_dark_cloud_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_piercing_dark_cloud_reset(_handle.DangerousGetHandle()); @@ -17027,6 +21843,22 @@ public sealed class Pin : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pin_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pin_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pin_reset(_handle.DangerousGetHandle()); @@ -17103,6 +21935,22 @@ public sealed class PivotReversal : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pivot_reversal_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pivot_reversal_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pivot_reversal_reset(_handle.DangerousGetHandle()); @@ -17178,6 +22026,22 @@ public sealed class PlusDi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_plus_di_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_plus_di_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_plus_di_reset(_handle.DangerousGetHandle()); @@ -17253,6 +22117,22 @@ public sealed class PlusDm : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_plus_dm_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_plus_dm_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_plus_dm_reset(_handle.DangerousGetHandle()); @@ -17304,6 +22184,22 @@ public sealed class Pmo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pmo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pmo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pmo_reset(_handle.DangerousGetHandle()); @@ -17408,6 +22304,22 @@ public sealed class PolarizedFractalEfficiency : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_polarized_fractal_efficiency_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_polarized_fractal_efficiency_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_polarized_fractal_efficiency_reset(_handle.DangerousGetHandle()); @@ -17459,6 +22371,22 @@ public sealed class Ppo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ppo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ppo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ppo_reset(_handle.DangerousGetHandle()); @@ -17511,6 +22439,22 @@ public sealed class PpoHistogram : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ppo_histogram_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ppo_histogram_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ppo_histogram_reset(_handle.DangerousGetHandle()); @@ -17587,6 +22531,22 @@ public sealed class ProfileShape : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_profile_shape_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_profile_shape_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_profile_shape_reset(_handle.DangerousGetHandle()); @@ -17637,6 +22597,22 @@ public sealed class ProfitFactor : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_profit_factor_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_profit_factor_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_profit_factor_reset(_handle.DangerousGetHandle()); @@ -17675,6 +22651,22 @@ public sealed class ProjectionBands : IDisposable return ok ? new ProjectionBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_projection_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_projection_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_projection_bands_reset(_handle.DangerousGetHandle()); @@ -17750,6 +22742,22 @@ public sealed class ProjectionOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_projection_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_projection_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_projection_oscillator_reset(_handle.DangerousGetHandle()); @@ -17824,6 +22832,22 @@ public sealed class Psar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_psar_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_psar_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_psar_reset(_handle.DangerousGetHandle()); @@ -17898,6 +22922,22 @@ public sealed class Pvi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_pvi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_pvi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_pvi_reset(_handle.DangerousGetHandle()); @@ -17937,6 +22977,22 @@ public sealed class Qqe : IDisposable return ok ? new QqeOutput(native.rsi_ma, native.trailing_line) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_qqe_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_qqe_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_qqe_reset(_handle.DangerousGetHandle()); @@ -18012,6 +23068,22 @@ public sealed class Qstick : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_qstick_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_qstick_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_qstick_reset(_handle.DangerousGetHandle()); @@ -18050,6 +23122,22 @@ public sealed class QuartileBands : IDisposable return ok ? new QuartileBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_quartile_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_quartile_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_quartile_bands_reset(_handle.DangerousGetHandle()); @@ -18101,6 +23189,22 @@ public sealed class QuotedSpread : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_quoted_spread_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_quoted_spread_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_quoted_spread_reset(_handle.DangerousGetHandle()); @@ -18151,6 +23255,22 @@ public sealed class RSquared : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_r_squared_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_r_squared_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_r_squared_reset(_handle.DangerousGetHandle()); @@ -18235,6 +23355,22 @@ public sealed class RealizedSpread : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_realized_spread_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_realized_spread_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_realized_spread_reset(_handle.DangerousGetHandle()); @@ -18285,6 +23421,22 @@ public sealed class RealizedVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_realized_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_realized_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_realized_volatility_reset(_handle.DangerousGetHandle()); @@ -18334,6 +23486,22 @@ public sealed class RecoveryFactor : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_recovery_factor_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_recovery_factor_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_recovery_factor_reset(_handle.DangerousGetHandle()); @@ -18408,6 +23576,22 @@ public sealed class RectangleRange : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rectangle_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rectangle_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rectangle_range_reset(_handle.DangerousGetHandle()); @@ -18458,6 +23642,22 @@ public sealed class Reflex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_reflex_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_reflex_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_reflex_reset(_handle.DangerousGetHandle()); @@ -18509,6 +23709,22 @@ public sealed class RegimeLabel : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_regime_label_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_regime_label_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_regime_label_reset(_handle.DangerousGetHandle()); @@ -18548,6 +23764,22 @@ public sealed class RelativeStrengthAB : IDisposable return ok ? new RelativeStrengthOutput(native.ratio, native.ratio_ma, native.ratio_rsi) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_relative_strength_ab_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_relative_strength_ab_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_relative_strength_ab_reset(_handle.DangerousGetHandle()); @@ -18649,6 +23881,22 @@ public sealed class RenkoTrailingStop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_renko_trailing_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_renko_trailing_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_renko_trailing_stop_reset(_handle.DangerousGetHandle()); @@ -18723,6 +23971,22 @@ public sealed class RickshawMan : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rickshaw_man_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rickshaw_man_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rickshaw_man_reset(_handle.DangerousGetHandle()); @@ -18797,6 +24061,22 @@ public sealed class RisingThreeMethods : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rising_three_methods_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rising_three_methods_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rising_three_methods_reset(_handle.DangerousGetHandle()); @@ -18848,6 +24128,22 @@ public sealed class Rmi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rmi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rmi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rmi_reset(_handle.DangerousGetHandle()); @@ -18898,6 +24194,22 @@ public sealed class Roc : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_roc_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_roc_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_roc_reset(_handle.DangerousGetHandle()); @@ -18948,6 +24260,22 @@ public sealed class Rocp : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rocp_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rocp_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rocp_reset(_handle.DangerousGetHandle()); @@ -18998,6 +24326,22 @@ public sealed class Rocr : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rocr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rocr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rocr_reset(_handle.DangerousGetHandle()); @@ -19048,6 +24392,22 @@ public sealed class Rocr100 : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rocr100_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rocr100_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rocr100_reset(_handle.DangerousGetHandle()); @@ -19124,6 +24484,22 @@ public sealed class RogersSatchellVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rogers_satchell_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rogers_satchell_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rogers_satchell_volatility_reset(_handle.DangerousGetHandle()); @@ -19156,6 +24532,22 @@ public sealed class RollMeasure : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_roll_measure_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_roll_measure_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_roll_measure_reset(_handle.DangerousGetHandle()); @@ -19211,6 +24603,22 @@ public sealed class RollingCorrelation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_correlation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_correlation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_correlation_reset(_handle.DangerousGetHandle()); @@ -19266,6 +24674,22 @@ public sealed class RollingCovariance : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_covariance_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_covariance_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_covariance_reset(_handle.DangerousGetHandle()); @@ -19316,6 +24740,22 @@ public sealed class RollingIqr : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_iqr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_iqr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_iqr_reset(_handle.DangerousGetHandle()); @@ -19366,6 +24806,22 @@ public sealed class RollingMinMaxScaler : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_min_max_scaler_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_min_max_scaler_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_min_max_scaler_reset(_handle.DangerousGetHandle()); @@ -19416,6 +24872,22 @@ public sealed class RollingPercentileRank : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_percentile_rank_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_percentile_rank_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_percentile_rank_reset(_handle.DangerousGetHandle()); @@ -19466,6 +24938,22 @@ public sealed class RollingQuantile : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_quantile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_quantile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_quantile_reset(_handle.DangerousGetHandle()); @@ -19541,6 +25029,22 @@ public sealed class RollingVwap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rolling_vwap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rolling_vwap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rolling_vwap_reset(_handle.DangerousGetHandle()); @@ -19592,6 +25096,22 @@ public sealed class RoofingFilter : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_roofing_filter_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_roofing_filter_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_roofing_filter_reset(_handle.DangerousGetHandle()); @@ -19642,6 +25162,22 @@ public sealed class Rsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rsi_reset(_handle.DangerousGetHandle()); @@ -19692,6 +25228,22 @@ public sealed class Rsx : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rsx_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rsx_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rsx_reset(_handle.DangerousGetHandle()); @@ -19820,6 +25372,22 @@ public sealed class Rvi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rvi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rvi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rvi_reset(_handle.DangerousGetHandle()); @@ -19870,6 +25438,22 @@ public sealed class RviVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rvi_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rvi_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rvi_volatility_reset(_handle.DangerousGetHandle()); @@ -19908,6 +25492,22 @@ public sealed class Rwi : IDisposable return ok ? new RwiOutput(native.high, native.low) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_rwi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_rwi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_rwi_reset(_handle.DangerousGetHandle()); @@ -19959,6 +25559,22 @@ public sealed class SampleEntropy : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sample_entropy_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sample_entropy_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sample_entropy_reset(_handle.DangerousGetHandle()); @@ -20033,6 +25649,22 @@ public sealed class SarExt : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sar_ext_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sar_ext_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sar_ext_reset(_handle.DangerousGetHandle()); @@ -20107,6 +25739,22 @@ public sealed class SeasonalZScore : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_seasonal_z_score_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_seasonal_z_score_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_seasonal_z_score_reset(_handle.DangerousGetHandle()); @@ -20181,6 +25829,22 @@ public sealed class SeparatingLines : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_separating_lines_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_separating_lines_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_separating_lines_reset(_handle.DangerousGetHandle()); @@ -20218,6 +25882,22 @@ public sealed class SessionHighLow : IDisposable return ok ? new SessionHighLowOutput(native.high, native.low) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_session_high_low_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_session_high_low_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_session_high_low_reset(_handle.DangerousGetHandle()); @@ -20255,6 +25935,22 @@ public sealed class SessionRange : IDisposable return ok ? new SessionRangeOutput(native.asia, native.eu, native.us) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_session_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_session_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_session_range_reset(_handle.DangerousGetHandle()); @@ -20329,6 +26025,22 @@ public sealed class SessionVwap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_session_vwap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_session_vwap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_session_vwap_reset(_handle.DangerousGetHandle()); @@ -20380,6 +26092,22 @@ public sealed class ShannonEntropy : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_shannon_entropy_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_shannon_entropy_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_shannon_entropy_reset(_handle.DangerousGetHandle()); @@ -20454,6 +26182,22 @@ public sealed class Shark : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_shark_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_shark_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_shark_reset(_handle.DangerousGetHandle()); @@ -20504,6 +26248,22 @@ public sealed class SharpeRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sharpe_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sharpe_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sharpe_ratio_reset(_handle.DangerousGetHandle()); @@ -20578,6 +26338,22 @@ public sealed class ShootingStar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_shooting_star_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_shooting_star_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_shooting_star_reset(_handle.DangerousGetHandle()); @@ -20652,6 +26428,22 @@ public sealed class ShortLine : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_short_line_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_short_line_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_short_line_reset(_handle.DangerousGetHandle()); @@ -20683,6 +26475,22 @@ public sealed class SignedVolume : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_signed_volume_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_signed_volume_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_signed_volume_reset(_handle.DangerousGetHandle()); @@ -20732,6 +26540,22 @@ public sealed class SineWave : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sine_wave_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sine_wave_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sine_wave_reset(_handle.DangerousGetHandle()); @@ -20782,6 +26606,22 @@ public sealed class SineWeightedMa : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sine_weighted_ma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sine_weighted_ma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sine_weighted_ma_reset(_handle.DangerousGetHandle()); @@ -20858,6 +26698,22 @@ public sealed class SinglePrints : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_single_prints_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_single_prints_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_single_prints_reset(_handle.DangerousGetHandle()); @@ -20908,6 +26764,22 @@ public sealed class Skewness : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_skewness_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_skewness_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_skewness_reset(_handle.DangerousGetHandle()); @@ -20958,6 +26830,22 @@ public sealed class Sma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sma_reset(_handle.DangerousGetHandle()); @@ -21035,6 +26923,22 @@ public sealed class Smi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_smi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_smi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_smi_reset(_handle.DangerousGetHandle()); @@ -21085,6 +26989,22 @@ public sealed class Smma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_smma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_smma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_smma_reset(_handle.DangerousGetHandle()); @@ -21123,6 +27043,22 @@ public sealed class SmoothedHeikinAshi : IDisposable return ok ? new SmoothedHeikinAshiOutput(native.open, native.high, native.low, native.close) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_smoothed_heikin_ashi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_smoothed_heikin_ashi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_smoothed_heikin_ashi_reset(_handle.DangerousGetHandle()); @@ -21173,6 +27109,22 @@ public sealed class SortinoRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sortino_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sortino_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sortino_ratio_reset(_handle.DangerousGetHandle()); @@ -21228,6 +27180,22 @@ public sealed class SpearmanCorrelation : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_spearman_correlation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_spearman_correlation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_spearman_correlation_reset(_handle.DangerousGetHandle()); @@ -21302,6 +27270,22 @@ public sealed class SpinningTop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_spinning_top_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_spinning_top_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_spinning_top_reset(_handle.DangerousGetHandle()); @@ -21357,6 +27341,22 @@ public sealed class SpreadAr1Coefficient : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_spread_ar1_coefficient_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_spread_ar1_coefficient_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_spread_ar1_coefficient_reset(_handle.DangerousGetHandle()); @@ -21395,6 +27395,22 @@ public sealed class SpreadBollingerBands : IDisposable return ok ? new SpreadBollingerBandsOutput(native.middle, native.upper, native.lower, native.percent_b) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_spread_bollinger_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_spread_bollinger_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_spread_bollinger_bands_reset(_handle.DangerousGetHandle()); @@ -21450,6 +27466,22 @@ public sealed class SpreadHurst : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_spread_hurst_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_spread_hurst_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_spread_hurst_reset(_handle.DangerousGetHandle()); @@ -21524,6 +27556,22 @@ public sealed class StalledPattern : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_stalled_pattern_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_stalled_pattern_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_stalled_pattern_reset(_handle.DangerousGetHandle()); @@ -21574,6 +27622,22 @@ public sealed class StandardError : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_standard_error_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_standard_error_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_standard_error_reset(_handle.DangerousGetHandle()); @@ -21612,6 +27676,22 @@ public sealed class StandardErrorBands : IDisposable return ok ? new StandardErrorBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_standard_error_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_standard_error_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_standard_error_bands_reset(_handle.DangerousGetHandle()); @@ -21651,6 +27731,22 @@ public sealed class StarcBands : IDisposable return ok ? new StarcBandsOutput(native.upper, native.middle, native.lower) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_starc_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_starc_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_starc_bands_reset(_handle.DangerousGetHandle()); @@ -21703,6 +27799,22 @@ public sealed class Stc : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_stc_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_stc_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_stc_reset(_handle.DangerousGetHandle()); @@ -21753,6 +27865,22 @@ public sealed class StdDev : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_std_dev_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_std_dev_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_std_dev_reset(_handle.DangerousGetHandle()); @@ -21802,6 +27930,22 @@ public sealed class StepTrailingStop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_step_trailing_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_step_trailing_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_step_trailing_stop_reset(_handle.DangerousGetHandle()); @@ -21852,6 +27996,22 @@ public sealed class SterlingRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_sterling_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_sterling_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_sterling_ratio_reset(_handle.DangerousGetHandle()); @@ -21926,6 +28086,22 @@ public sealed class StickSandwich : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_stick_sandwich_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_stick_sandwich_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_stick_sandwich_reset(_handle.DangerousGetHandle()); @@ -21977,6 +28153,22 @@ public sealed class StochRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_stoch_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_stoch_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_stoch_rsi_reset(_handle.DangerousGetHandle()); @@ -22016,6 +28208,22 @@ public sealed class Stochastic : IDisposable return ok ? new StochasticOutput(native.k, native.d) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_stochastic_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_stochastic_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_stochastic_reset(_handle.DangerousGetHandle()); @@ -22091,6 +28299,22 @@ public sealed class StochasticCci : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_stochastic_cci_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_stochastic_cci_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_stochastic_cci_reset(_handle.DangerousGetHandle()); @@ -22141,6 +28365,22 @@ public sealed class SuperSmoother : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_super_smoother_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_super_smoother_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_super_smoother_reset(_handle.DangerousGetHandle()); @@ -22179,6 +28419,22 @@ public sealed class SuperTrend : IDisposable return ok ? new SuperTrendOutput(native.@value, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_super_trend_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_super_trend_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_super_trend_reset(_handle.DangerousGetHandle()); @@ -22229,6 +28485,22 @@ public sealed class T3 : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_t3_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_t3_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_t3_reset(_handle.DangerousGetHandle()); @@ -22279,6 +28551,22 @@ public sealed class TailRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tail_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tail_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tail_ratio_reset(_handle.DangerousGetHandle()); @@ -22310,6 +28598,22 @@ public sealed class TakerBuySellRatio : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_taker_buy_sell_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_taker_buy_sell_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_taker_buy_sell_ratio_reset(_handle.DangerousGetHandle()); @@ -22384,6 +28688,22 @@ public sealed class Takuri : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_takuri_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_takuri_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_takuri_reset(_handle.DangerousGetHandle()); @@ -22458,6 +28778,22 @@ public sealed class TasukiGap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tasuki_gap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tasuki_gap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tasuki_gap_reset(_handle.DangerousGetHandle()); @@ -22532,6 +28868,22 @@ public sealed class TdCamouflage : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_camouflage_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_camouflage_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_camouflage_reset(_handle.DangerousGetHandle()); @@ -22606,6 +28958,22 @@ public sealed class TdClop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_clop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_clop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_clop_reset(_handle.DangerousGetHandle()); @@ -22680,6 +29048,22 @@ public sealed class TdClopwin : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_clopwin_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_clopwin_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_clopwin_reset(_handle.DangerousGetHandle()); @@ -22758,6 +29142,22 @@ public sealed class TdCombo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_combo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_combo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_combo_reset(_handle.DangerousGetHandle()); @@ -22836,6 +29236,22 @@ public sealed class TdCountdown : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_countdown_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_countdown_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_countdown_reset(_handle.DangerousGetHandle()); @@ -22911,6 +29327,22 @@ public sealed class TdDWave : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_d_wave_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_d_wave_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_d_wave_reset(_handle.DangerousGetHandle()); @@ -22986,6 +29418,22 @@ public sealed class TdDeMarker : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_de_marker_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_de_marker_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_de_marker_reset(_handle.DangerousGetHandle()); @@ -23060,6 +29508,22 @@ public sealed class TdDifferential : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_differential_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_differential_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_differential_reset(_handle.DangerousGetHandle()); @@ -23099,6 +29563,22 @@ public sealed class TdLines : IDisposable return ok ? new TdLinesOutput(native.resistance, native.support) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_lines_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_lines_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_lines_reset(_handle.DangerousGetHandle()); @@ -23138,6 +29618,22 @@ public sealed class TdMovingAverage : IDisposable return ok ? new TdMovingAverageOutput(native.st1, native.st2) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_moving_average_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_moving_average_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_moving_average_reset(_handle.DangerousGetHandle()); @@ -23212,6 +29708,22 @@ public sealed class TdOpen : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_open_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_open_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_open_reset(_handle.DangerousGetHandle()); @@ -23287,6 +29799,22 @@ public sealed class TdPressure : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_pressure_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_pressure_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_pressure_reset(_handle.DangerousGetHandle()); @@ -23361,6 +29889,22 @@ public sealed class TdPropulsion : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_propulsion_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_propulsion_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_propulsion_reset(_handle.DangerousGetHandle()); @@ -23398,6 +29942,22 @@ public sealed class TdRangeProjection : IDisposable return ok ? new TdRangeProjectionOutput(native.high, native.low) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_range_projection_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_range_projection_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_range_projection_reset(_handle.DangerousGetHandle()); @@ -23473,6 +30033,22 @@ public sealed class TdRei : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_rei_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_rei_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_rei_reset(_handle.DangerousGetHandle()); @@ -23512,6 +30088,22 @@ public sealed class TdRiskLevel : IDisposable return ok ? new TdRiskLevelOutput(native.buy_risk, native.sell_risk) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_risk_level_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_risk_level_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_risk_level_reset(_handle.DangerousGetHandle()); @@ -23553,6 +30145,22 @@ public sealed class TdSequential : IDisposable return ok ? new TdSequentialOutput(native.setup, native.countdown, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_sequential_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_sequential_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_sequential_reset(_handle.DangerousGetHandle()); @@ -23629,6 +30237,22 @@ public sealed class TdSetup : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_setup_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_setup_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_setup_reset(_handle.DangerousGetHandle()); @@ -23703,6 +30327,22 @@ public sealed class TdTrap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_td_trap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_td_trap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_td_trap_reset(_handle.DangerousGetHandle()); @@ -23753,6 +30393,22 @@ public sealed class Tema : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tema_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tema_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tema_reset(_handle.DangerousGetHandle()); @@ -23784,6 +30440,22 @@ public sealed class TermStructureBasis : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_term_structure_basis_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_term_structure_basis_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_term_structure_basis_reset(_handle.DangerousGetHandle()); @@ -23858,6 +30530,22 @@ public sealed class ThreeDrives : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_drives_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_drives_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_drives_reset(_handle.DangerousGetHandle()); @@ -23932,6 +30620,22 @@ public sealed class ThreeInside : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_inside_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_inside_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_inside_reset(_handle.DangerousGetHandle()); @@ -24007,6 +30711,22 @@ public sealed class ThreeLineBreak : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_line_break_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_line_break_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_line_break_reset(_handle.DangerousGetHandle()); @@ -24134,6 +30854,22 @@ public sealed class ThreeLineStrike : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_line_strike_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_line_strike_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_line_strike_reset(_handle.DangerousGetHandle()); @@ -24208,6 +30944,22 @@ public sealed class ThreeOutside : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_outside_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_outside_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_outside_reset(_handle.DangerousGetHandle()); @@ -24282,6 +31034,22 @@ public sealed class ThreeSoldiersOrCrows : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_soldiers_or_crows_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_soldiers_or_crows_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_soldiers_or_crows_reset(_handle.DangerousGetHandle()); @@ -24356,6 +31124,22 @@ public sealed class ThreeStarsInSouth : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_three_stars_in_south_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_three_stars_in_south_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_three_stars_in_south_reset(_handle.DangerousGetHandle()); @@ -24430,6 +31214,22 @@ public sealed class Thrusting : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_thrusting_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_thrusting_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_thrusting_reset(_handle.DangerousGetHandle()); @@ -24548,6 +31348,22 @@ public sealed class TickIndex : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tick_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tick_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tick_index_reset(_handle.DangerousGetHandle()); @@ -24599,6 +31415,22 @@ public sealed class Tii : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tii_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tii_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tii_reset(_handle.DangerousGetHandle()); @@ -24674,6 +31506,22 @@ public sealed class TimeBasedStop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_time_based_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_time_based_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_time_based_stop_reset(_handle.DangerousGetHandle()); @@ -24727,6 +31575,22 @@ public sealed class TimeOfDayReturnProfile : IDisposable return values; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_time_of_day_return_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_time_of_day_return_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_time_of_day_return_profile_reset(_handle.DangerousGetHandle()); @@ -24801,6 +31665,22 @@ public sealed class TowerTopBottom : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tower_top_bottom_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tower_top_bottom_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tower_top_bottom_reset(_handle.DangerousGetHandle()); @@ -24856,6 +31736,22 @@ public sealed class TpoProfile : IDisposable return new TpoProfileOutputScalars(scalars.price_low, scalars.price_high, values); } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tpo_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tpo_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tpo_profile_reset(_handle.DangerousGetHandle()); @@ -24888,6 +31784,22 @@ public sealed class TradeImbalance : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trade_imbalance_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trade_imbalance_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trade_imbalance_reset(_handle.DangerousGetHandle()); @@ -24920,6 +31832,22 @@ public sealed class TradeSignAutocorrelation : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trade_sign_autocorrelation_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trade_sign_autocorrelation_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trade_sign_autocorrelation_reset(_handle.DangerousGetHandle()); @@ -24994,6 +31922,22 @@ public sealed class TradeVolumeIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trade_volume_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trade_volume_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trade_volume_index_reset(_handle.DangerousGetHandle()); @@ -25044,6 +31988,22 @@ public sealed class TrendLabel : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trend_label_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trend_label_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trend_label_reset(_handle.DangerousGetHandle()); @@ -25094,6 +32054,22 @@ public sealed class TrendStrengthIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trend_strength_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trend_strength_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trend_strength_index_reset(_handle.DangerousGetHandle()); @@ -25144,6 +32120,22 @@ public sealed class Trendflex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trendflex_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trendflex_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trendflex_reset(_handle.DangerousGetHandle()); @@ -25199,6 +32191,22 @@ public sealed class TreynorRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_treynor_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_treynor_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_treynor_ratio_reset(_handle.DangerousGetHandle()); @@ -25273,6 +32281,22 @@ public sealed class Triangle : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_triangle_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_triangle_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_triangle_reset(_handle.DangerousGetHandle()); @@ -25323,6 +32347,22 @@ public sealed class Trima : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trima_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trima_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trima_reset(_handle.DangerousGetHandle()); @@ -25388,6 +32428,22 @@ public sealed class Trin : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trin_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trin_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trin_reset(_handle.DangerousGetHandle()); @@ -25462,6 +32518,22 @@ public sealed class TripleTopBottom : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_triple_top_bottom_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_triple_top_bottom_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_triple_top_bottom_reset(_handle.DangerousGetHandle()); @@ -25536,6 +32608,22 @@ public sealed class Tristar : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tristar_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tristar_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tristar_reset(_handle.DangerousGetHandle()); @@ -25586,6 +32674,22 @@ public sealed class Trix : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_trix_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_trix_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_trix_reset(_handle.DangerousGetHandle()); @@ -25660,6 +32764,22 @@ public sealed class TrueRange : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_true_range_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_true_range_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_true_range_reset(_handle.DangerousGetHandle()); @@ -25710,6 +32830,22 @@ public sealed class Tsf : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tsf_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tsf_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tsf_reset(_handle.DangerousGetHandle()); @@ -25760,6 +32896,22 @@ public sealed class TsfOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tsf_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tsf_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tsf_oscillator_reset(_handle.DangerousGetHandle()); @@ -25811,6 +32963,22 @@ public sealed class Tsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tsi_reset(_handle.DangerousGetHandle()); @@ -25886,6 +33054,22 @@ public sealed class Tsv : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tsv_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tsv_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tsv_reset(_handle.DangerousGetHandle()); @@ -25924,6 +33108,22 @@ public sealed class TtmSqueeze : IDisposable return ok ? new TtmSqueezeOutput(native.squeeze, native.momentum) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ttm_squeeze_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ttm_squeeze_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ttm_squeeze_reset(_handle.DangerousGetHandle()); @@ -25999,6 +33199,22 @@ public sealed class TtmTrend : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ttm_trend_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ttm_trend_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ttm_trend_reset(_handle.DangerousGetHandle()); @@ -26073,6 +33289,22 @@ public sealed class TurnOfMonth : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_turn_of_month_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_turn_of_month_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_turn_of_month_reset(_handle.DangerousGetHandle()); @@ -26147,6 +33379,22 @@ public sealed class Tweezer : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_tweezer_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_tweezer_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_tweezer_reset(_handle.DangerousGetHandle()); @@ -26222,6 +33470,22 @@ public sealed class TwiggsMoneyFlow : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_twiggs_money_flow_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_twiggs_money_flow_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_twiggs_money_flow_reset(_handle.DangerousGetHandle()); @@ -26296,6 +33560,22 @@ public sealed class TwoCrows : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_two_crows_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_two_crows_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_two_crows_reset(_handle.DangerousGetHandle()); @@ -26370,6 +33650,22 @@ public sealed class TypicalPrice : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_typical_price_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_typical_price_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_typical_price_reset(_handle.DangerousGetHandle()); @@ -26420,6 +33716,22 @@ public sealed class UlcerIndex : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ulcer_index_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ulcer_index_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ulcer_index_reset(_handle.DangerousGetHandle()); @@ -26497,6 +33809,22 @@ public sealed class UltimateOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_ultimate_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_ultimate_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_ultimate_oscillator_reset(_handle.DangerousGetHandle()); @@ -26571,6 +33899,22 @@ public sealed class UniqueThreeRiver : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_unique_three_river_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_unique_three_river_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_unique_three_river_reset(_handle.DangerousGetHandle()); @@ -26621,6 +33965,22 @@ public sealed class UniversalOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_universal_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_universal_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_universal_oscillator_reset(_handle.DangerousGetHandle()); @@ -26686,6 +34046,22 @@ public sealed class UpDownVolumeRatio : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_up_down_volume_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_up_down_volume_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_up_down_volume_ratio_reset(_handle.DangerousGetHandle()); @@ -26760,6 +34136,22 @@ public sealed class UpsideGapThreeMethods : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_upside_gap_three_methods_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_upside_gap_three_methods_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_upside_gap_three_methods_reset(_handle.DangerousGetHandle()); @@ -26834,6 +34226,22 @@ public sealed class UpsideGapTwoCrows : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_upside_gap_two_crows_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_upside_gap_two_crows_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_upside_gap_two_crows_reset(_handle.DangerousGetHandle()); @@ -26884,6 +34292,22 @@ public sealed class UpsidePotentialRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_upside_potential_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_upside_potential_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_upside_potential_ratio_reset(_handle.DangerousGetHandle()); @@ -26923,6 +34347,22 @@ public sealed class ValueArea : IDisposable return ok ? new ValueAreaOutput(native.poc, native.vah, native.val) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_value_area_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_value_area_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_value_area_reset(_handle.DangerousGetHandle()); @@ -26973,6 +34413,22 @@ public sealed class ValueAtRisk : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_value_at_risk_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_value_at_risk_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_value_at_risk_reset(_handle.DangerousGetHandle()); @@ -27023,6 +34479,22 @@ public sealed class Variance : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_variance_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_variance_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_variance_reset(_handle.DangerousGetHandle()); @@ -27079,6 +34551,22 @@ public sealed class VarianceRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_variance_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_variance_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_variance_ratio_reset(_handle.DangerousGetHandle()); @@ -27129,6 +34617,22 @@ public sealed class VerticalHorizontalFilter : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vertical_horizontal_filter_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vertical_horizontal_filter_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vertical_horizontal_filter_reset(_handle.DangerousGetHandle()); @@ -27180,6 +34684,22 @@ public sealed class Vidya : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vidya_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vidya_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vidya_reset(_handle.DangerousGetHandle()); @@ -27219,6 +34739,22 @@ public sealed class VolatilityCone : IDisposable return ok ? new VolatilityConeOutput(native.current, native.min, native.median, native.max, native.percentile) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volatility_cone_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volatility_cone_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volatility_cone_reset(_handle.DangerousGetHandle()); @@ -27270,6 +34806,22 @@ public sealed class VolatilityOfVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volatility_of_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volatility_of_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volatility_of_volatility_reset(_handle.DangerousGetHandle()); @@ -27345,6 +34897,22 @@ public sealed class VolatilityRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volatility_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volatility_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volatility_ratio_reset(_handle.DangerousGetHandle()); @@ -27420,6 +34988,22 @@ public sealed class VoltyStop : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volty_stop_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volty_stop_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volty_stop_reset(_handle.DangerousGetHandle()); @@ -27525,6 +35109,22 @@ public sealed class VolumeByTimeProfile : IDisposable return values; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_by_time_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_by_time_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_by_time_profile_reset(_handle.DangerousGetHandle()); @@ -27601,6 +35201,22 @@ public sealed class VolumeOscillator : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_oscillator_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_oscillator_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_oscillator_reset(_handle.DangerousGetHandle()); @@ -27675,6 +35291,22 @@ public sealed class VolumePriceTrend : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_price_trend_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_price_trend_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_price_trend_reset(_handle.DangerousGetHandle()); @@ -27730,6 +35362,22 @@ public sealed class VolumeProfile : IDisposable return new VolumeProfileOutputScalars(scalars.price_low, scalars.price_high, values); } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_profile_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_profile_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_profile_reset(_handle.DangerousGetHandle()); @@ -27805,6 +35453,22 @@ public sealed class VolumeRsi : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_rsi_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_rsi_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_rsi_reset(_handle.DangerousGetHandle()); @@ -27845,6 +35509,22 @@ public sealed class VolumeWeightedMacd : IDisposable return ok ? new VolumeWeightedMacdOutput(native.macd, native.signal, native.histogram) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_weighted_macd_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_weighted_macd_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_weighted_macd_reset(_handle.DangerousGetHandle()); @@ -27883,6 +35563,22 @@ public sealed class VolumeWeightedSr : IDisposable return ok ? new VolumeWeightedSrOutput(native.support, native.resistance) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_volume_weighted_sr_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_volume_weighted_sr_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_volume_weighted_sr_reset(_handle.DangerousGetHandle()); @@ -27921,6 +35617,22 @@ public sealed class Vortex : IDisposable return ok ? new VortexOutput(native.plus, native.minus) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vortex_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vortex_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vortex_reset(_handle.DangerousGetHandle()); @@ -27953,6 +35665,22 @@ public sealed class Vpin : IDisposable return result; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vpin_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vpin_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vpin_reset(_handle.DangerousGetHandle()); @@ -28027,6 +35755,22 @@ public sealed class Vwap : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vwap_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vwap_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vwap_reset(_handle.DangerousGetHandle()); @@ -28064,6 +35808,22 @@ public sealed class VwapStdDevBands : IDisposable return ok ? new VwapStdDevBandsOutput(native.upper, native.middle, native.lower, native.stddev) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vwap_std_dev_bands_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vwap_std_dev_bands_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vwap_std_dev_bands_reset(_handle.DangerousGetHandle()); @@ -28139,6 +35899,22 @@ public sealed class Vwma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vwma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vwma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vwma_reset(_handle.DangerousGetHandle()); @@ -28214,6 +35990,22 @@ public sealed class Vzo : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_vzo_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_vzo_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_vzo_reset(_handle.DangerousGetHandle()); @@ -28288,6 +36080,22 @@ public sealed class Wad : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_wad_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_wad_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_wad_reset(_handle.DangerousGetHandle()); @@ -28339,6 +36147,22 @@ public sealed class WavePm : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_wave_pm_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_wave_pm_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_wave_pm_reset(_handle.DangerousGetHandle()); @@ -28379,6 +36203,22 @@ public sealed class WaveTrend : IDisposable return ok ? new WaveTrendOutput(native.wt1, native.wt2) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_wave_trend_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_wave_trend_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_wave_trend_reset(_handle.DangerousGetHandle()); @@ -28453,6 +36293,22 @@ public sealed class Wedge : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_wedge_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_wedge_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_wedge_reset(_handle.DangerousGetHandle()); @@ -28527,6 +36383,22 @@ public sealed class WeightedClose : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_weighted_close_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_weighted_close_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_weighted_close_reset(_handle.DangerousGetHandle()); @@ -28601,6 +36473,22 @@ public sealed class WickRatio : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_wick_ratio_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_wick_ratio_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_wick_ratio_reset(_handle.DangerousGetHandle()); @@ -28638,6 +36526,22 @@ public sealed class WilliamsFractals : IDisposable return ok ? new WilliamsFractalsOutput(native.up, native.down) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_williams_fractals_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_williams_fractals_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_williams_fractals_reset(_handle.DangerousGetHandle()); @@ -28713,6 +36617,22 @@ public sealed class WilliamsR : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_williams_r_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_williams_r_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_williams_r_reset(_handle.DangerousGetHandle()); @@ -28763,6 +36683,22 @@ public sealed class WinRate : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_win_rate_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_win_rate_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_win_rate_reset(_handle.DangerousGetHandle()); @@ -28813,6 +36749,22 @@ public sealed class Wma : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_wma_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_wma_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_wma_reset(_handle.DangerousGetHandle()); @@ -28850,6 +36802,22 @@ public sealed class WoodiePivots : IDisposable return ok ? new WoodiePivotsOutput(native.pp, native.r1, native.r2, native.s1, native.s2) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_woodie_pivots_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_woodie_pivots_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_woodie_pivots_reset(_handle.DangerousGetHandle()); @@ -28926,6 +36894,22 @@ public sealed class YangZhangVolatility : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_yang_zhang_volatility_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_yang_zhang_volatility_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_yang_zhang_volatility_reset(_handle.DangerousGetHandle()); @@ -29001,6 +36985,22 @@ public sealed class YoyoExit : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_yoyo_exit_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_yoyo_exit_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_yoyo_exit_reset(_handle.DangerousGetHandle()); @@ -29051,6 +37051,22 @@ public sealed class ZScore : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_z_score_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_z_score_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_z_score_reset(_handle.DangerousGetHandle()); @@ -29091,6 +37107,22 @@ public sealed class ZeroLagMacd : IDisposable return ok ? new ZeroLagMacdOutput(native.macd, native.signal, native.histogram) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_zero_lag_macd_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_zero_lag_macd_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_zero_lag_macd_reset(_handle.DangerousGetHandle()); @@ -29128,6 +37160,22 @@ public sealed class ZigZag : IDisposable return ok ? new ZigZagOutput(native.swing, native.direction) : null; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_zig_zag_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_zig_zag_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_zig_zag_reset(_handle.DangerousGetHandle()); @@ -29178,6 +37226,22 @@ public sealed class Zlema : IDisposable return output; } + /// Number of updates required before yields a value. + public int WarmupPeriod() + { + var result = (int)NativeMethods.wickra_zlema_warmup_period(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + + /// Whether the indicator has consumed enough input to emit a value. + public bool IsReady() + { + var result = NativeMethods.wickra_zlema_is_ready(_handle.DangerousGetHandle()); + GC.KeepAlive(_handle); + return result; + } + public void Reset() { NativeMethods.wickra_zlema_reset(_handle.DangerousGetHandle()); diff --git a/bindings/csharp/Wickra/Generated/NativeMethods.g.cs b/bindings/csharp/Wickra/Generated/NativeMethods.g.cs index 3bf0e533..c7651a03 100644 --- a/bindings/csharp/Wickra/Generated/NativeMethods.g.cs +++ b/bindings/csharp/Wickra/Generated/NativeMethods.g.cs @@ -15,6 +15,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_adaptive_cycle_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adaptive_cycle_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adaptive_cycle_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adaptive_cycle_reset(nint handle); @@ -30,6 +37,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_adaptive_laguerre_filter_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adaptive_laguerre_filter_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adaptive_laguerre_filter_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adaptive_laguerre_filter_reset(nint handle); @@ -45,6 +59,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_adaptive_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adaptive_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adaptive_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adaptive_rsi_reset(nint handle); @@ -60,6 +81,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_alma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_alma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_alma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_alma_reset(nint handle); @@ -75,6 +103,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_anchored_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_anchored_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_anchored_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_anchored_rsi_reset(nint handle); @@ -90,6 +125,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_apo_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_apo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_apo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_apo_reset(nint handle); @@ -105,6 +147,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_autocorrelation_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_autocorrelation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_autocorrelation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_autocorrelation_reset(nint handle); @@ -120,6 +169,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_autocorrelation_periodogram_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_autocorrelation_periodogram_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_autocorrelation_periodogram_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_autocorrelation_periodogram_reset(nint handle); @@ -135,6 +191,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_average_drawdown_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_average_drawdown_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_average_drawdown_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_average_drawdown_reset(nint handle); @@ -150,6 +213,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_bandpass_filter_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bandpass_filter_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bandpass_filter_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bandpass_filter_reset(nint handle); @@ -165,6 +235,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_bipower_variation_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bipower_variation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bipower_variation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bipower_variation_reset(nint handle); @@ -180,6 +257,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_bollinger_bandwidth_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bollinger_bandwidth_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bollinger_bandwidth_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bollinger_bandwidth_reset(nint handle); @@ -195,6 +279,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_burke_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_burke_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_burke_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_burke_ratio_reset(nint handle); @@ -210,6 +301,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_calmar_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_calmar_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_calmar_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_calmar_ratio_reset(nint handle); @@ -225,6 +323,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_center_of_gravity_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_center_of_gravity_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_center_of_gravity_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_center_of_gravity_reset(nint handle); @@ -240,6 +345,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_cfo_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cfo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cfo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cfo_reset(nint handle); @@ -255,6 +367,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_cmo_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cmo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cmo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cmo_reset(nint handle); @@ -270,6 +389,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_coefficient_of_variation_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_coefficient_of_variation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_coefficient_of_variation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_coefficient_of_variation_reset(nint handle); @@ -285,6 +411,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_common_sense_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_common_sense_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_common_sense_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_common_sense_ratio_reset(nint handle); @@ -300,6 +433,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_conditional_value_at_risk_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_conditional_value_at_risk_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_conditional_value_at_risk_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_conditional_value_at_risk_reset(nint handle); @@ -315,6 +455,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_connors_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_connors_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_connors_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_connors_rsi_reset(nint handle); @@ -330,6 +477,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_coppock_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_coppock_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_coppock_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_coppock_reset(nint handle); @@ -345,6 +499,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_correlation_trend_indicator_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_correlation_trend_indicator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_correlation_trend_indicator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_correlation_trend_indicator_reset(nint handle); @@ -360,6 +521,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_cybernetic_cycle_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cybernetic_cycle_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cybernetic_cycle_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cybernetic_cycle_reset(nint handle); @@ -375,6 +543,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_decycler_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_decycler_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_decycler_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_decycler_reset(nint handle); @@ -390,6 +565,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_decycler_oscillator_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_decycler_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_decycler_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_decycler_oscillator_reset(nint handle); @@ -405,6 +587,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_dema_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_dema_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_dema_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_dema_reset(nint handle); @@ -420,6 +609,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_derivative_oscillator_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_derivative_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_derivative_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_derivative_oscillator_reset(nint handle); @@ -435,6 +631,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_detrended_std_dev_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_detrended_std_dev_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_detrended_std_dev_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_detrended_std_dev_reset(nint handle); @@ -450,6 +653,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_disparity_index_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_disparity_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_disparity_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_disparity_index_reset(nint handle); @@ -465,6 +675,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_dpo_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_dpo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_dpo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_dpo_reset(nint handle); @@ -480,6 +697,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_drawdown_duration_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_drawdown_duration_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_drawdown_duration_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_drawdown_duration_reset(nint handle); @@ -495,6 +719,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_dynamic_momentum_index_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_dynamic_momentum_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_dynamic_momentum_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_dynamic_momentum_index_reset(nint handle); @@ -510,6 +741,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ehlers_stochastic_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ehlers_stochastic_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ehlers_stochastic_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ehlers_stochastic_reset(nint handle); @@ -525,6 +763,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ehma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ehma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ehma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ehma_reset(nint handle); @@ -540,6 +785,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_elder_impulse_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_elder_impulse_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_elder_impulse_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_elder_impulse_reset(nint handle); @@ -555,6 +807,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ema_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ema_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ema_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ema_reset(nint handle); @@ -570,6 +829,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_empirical_mode_decomposition_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_empirical_mode_decomposition_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_empirical_mode_decomposition_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_empirical_mode_decomposition_reset(nint handle); @@ -585,6 +851,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_even_better_sinewave_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_even_better_sinewave_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_even_better_sinewave_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_even_better_sinewave_reset(nint handle); @@ -600,6 +873,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ewma_volatility_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ewma_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ewma_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ewma_volatility_reset(nint handle); @@ -615,6 +895,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_expectancy_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_expectancy_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_expectancy_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_expectancy_reset(nint handle); @@ -630,6 +917,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_fama_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fama_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fama_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fama_reset(nint handle); @@ -645,6 +939,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_fisher_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fisher_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fisher_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fisher_rsi_reset(nint handle); @@ -660,6 +961,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_fisher_transform_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fisher_transform_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fisher_transform_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fisher_transform_reset(nint handle); @@ -675,6 +983,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_frama_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_frama_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_frama_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_frama_reset(nint handle); @@ -690,6 +1005,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_gain_loss_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_gain_loss_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_gain_loss_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_gain_loss_ratio_reset(nint handle); @@ -705,6 +1027,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_gain_to_pain_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_gain_to_pain_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_gain_to_pain_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_gain_to_pain_ratio_reset(nint handle); @@ -720,6 +1049,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_garch11_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_garch11_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_garch11_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_garch11_reset(nint handle); @@ -735,6 +1071,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_generalized_dema_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_generalized_dema_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_generalized_dema_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_generalized_dema_reset(nint handle); @@ -750,6 +1093,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_geometric_ma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_geometric_ma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_geometric_ma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_geometric_ma_reset(nint handle); @@ -765,6 +1115,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_highpass_filter_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_highpass_filter_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_highpass_filter_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_highpass_filter_reset(nint handle); @@ -780,6 +1137,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hilbert_dominant_cycle_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hilbert_dominant_cycle_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hilbert_dominant_cycle_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hilbert_dominant_cycle_reset(nint handle); @@ -795,6 +1159,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_historical_volatility_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_historical_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_historical_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_historical_volatility_reset(nint handle); @@ -810,6 +1181,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hma_reset(nint handle); @@ -825,6 +1203,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_holt_winters_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_holt_winters_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_holt_winters_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_holt_winters_reset(nint handle); @@ -840,6 +1225,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ht_dc_phase_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ht_dc_phase_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ht_dc_phase_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ht_dc_phase_reset(nint handle); @@ -855,6 +1247,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ht_trend_mode_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ht_trend_mode_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ht_trend_mode_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ht_trend_mode_reset(nint handle); @@ -870,6 +1269,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hurst_exponent_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hurst_exponent_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hurst_exponent_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hurst_exponent_reset(nint handle); @@ -885,6 +1291,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_instantaneous_trendline_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_instantaneous_trendline_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_instantaneous_trendline_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_instantaneous_trendline_reset(nint handle); @@ -900,6 +1313,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_inverse_fisher_transform_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_inverse_fisher_transform_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_inverse_fisher_transform_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_inverse_fisher_transform_reset(nint handle); @@ -915,6 +1335,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_jarque_bera_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_jarque_bera_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_jarque_bera_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_jarque_bera_reset(nint handle); @@ -930,6 +1357,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_jma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_jma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_jma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_jma_reset(nint handle); @@ -945,6 +1379,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_jump_indicator_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_jump_indicator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_jump_indicator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_jump_indicator_reset(nint handle); @@ -960,6 +1401,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_k_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_k_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_k_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_k_ratio_reset(nint handle); @@ -975,6 +1423,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kama_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kama_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kama_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kama_reset(nint handle); @@ -990,6 +1445,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kelly_criterion_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kelly_criterion_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kelly_criterion_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kelly_criterion_reset(nint handle); @@ -1005,6 +1467,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kurtosis_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kurtosis_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kurtosis_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kurtosis_reset(nint handle); @@ -1020,6 +1489,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_laguerre_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_laguerre_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_laguerre_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_laguerre_rsi_reset(nint handle); @@ -1035,6 +1511,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_linear_regression_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_linear_regression_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_linear_regression_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_linear_regression_reset(nint handle); @@ -1050,6 +1533,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_lin_reg_angle_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_lin_reg_angle_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_lin_reg_angle_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_lin_reg_angle_reset(nint handle); @@ -1065,6 +1555,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_lin_reg_intercept_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_lin_reg_intercept_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_lin_reg_intercept_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_lin_reg_intercept_reset(nint handle); @@ -1080,6 +1577,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_lin_reg_slope_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_lin_reg_slope_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_lin_reg_slope_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_lin_reg_slope_reset(nint handle); @@ -1095,6 +1599,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_log_return_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_log_return_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_log_return_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_log_return_reset(nint handle); @@ -1110,6 +1621,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_m2_measure_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_m2_measure_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_m2_measure_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_m2_measure_reset(nint handle); @@ -1125,6 +1643,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_macd_histogram_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_macd_histogram_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_macd_histogram_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_macd_histogram_reset(nint handle); @@ -1140,6 +1665,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_martin_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_martin_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_martin_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_martin_ratio_reset(nint handle); @@ -1155,6 +1687,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_max_drawdown_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_max_drawdown_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_max_drawdown_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_max_drawdown_reset(nint handle); @@ -1170,6 +1709,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mc_ginley_dynamic_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mc_ginley_dynamic_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mc_ginley_dynamic_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mc_ginley_dynamic_reset(nint handle); @@ -1185,6 +1731,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_median_absolute_deviation_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_median_absolute_deviation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_median_absolute_deviation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_median_absolute_deviation_reset(nint handle); @@ -1200,6 +1753,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_median_ma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_median_ma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_median_ma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_median_ma_reset(nint handle); @@ -1215,6 +1775,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mid_point_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mid_point_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mid_point_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mid_point_reset(nint handle); @@ -1230,6 +1797,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mom_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mom_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mom_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mom_reset(nint handle); @@ -1245,6 +1819,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_omega_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_omega_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_omega_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_omega_ratio_reset(nint handle); @@ -1260,6 +1841,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pain_index_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pain_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pain_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pain_index_reset(nint handle); @@ -1275,6 +1863,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_percent_b_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_percent_b_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_percent_b_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_percent_b_reset(nint handle); @@ -1290,6 +1885,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_percentage_trailing_stop_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_percentage_trailing_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_percentage_trailing_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_percentage_trailing_stop_reset(nint handle); @@ -1305,6 +1907,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pmo_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pmo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pmo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pmo_reset(nint handle); @@ -1320,6 +1929,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_polarized_fractal_efficiency_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_polarized_fractal_efficiency_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_polarized_fractal_efficiency_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_polarized_fractal_efficiency_reset(nint handle); @@ -1335,6 +1951,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ppo_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ppo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ppo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ppo_reset(nint handle); @@ -1350,6 +1973,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ppo_histogram_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ppo_histogram_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ppo_histogram_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ppo_histogram_reset(nint handle); @@ -1365,6 +1995,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_profit_factor_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_profit_factor_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_profit_factor_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_profit_factor_reset(nint handle); @@ -1380,6 +2017,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_r_squared_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_r_squared_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_r_squared_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_r_squared_reset(nint handle); @@ -1395,6 +2039,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_realized_volatility_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_realized_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_realized_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_realized_volatility_reset(nint handle); @@ -1410,6 +2061,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_recovery_factor_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_recovery_factor_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_recovery_factor_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_recovery_factor_reset(nint handle); @@ -1425,6 +2083,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_reflex_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_reflex_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_reflex_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_reflex_reset(nint handle); @@ -1440,6 +2105,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_regime_label_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_regime_label_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_regime_label_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_regime_label_reset(nint handle); @@ -1455,6 +2127,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_renko_trailing_stop_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_renko_trailing_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_renko_trailing_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_renko_trailing_stop_reset(nint handle); @@ -1470,6 +2149,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rmi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rmi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rmi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rmi_reset(nint handle); @@ -1485,6 +2171,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_roc_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_roc_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_roc_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_roc_reset(nint handle); @@ -1500,6 +2193,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rocp_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rocp_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rocp_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rocp_reset(nint handle); @@ -1515,6 +2215,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rocr_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rocr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rocr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rocr_reset(nint handle); @@ -1530,6 +2237,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rocr100_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rocr100_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rocr100_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rocr100_reset(nint handle); @@ -1545,6 +2259,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_iqr_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_iqr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_iqr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_iqr_reset(nint handle); @@ -1560,6 +2281,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_min_max_scaler_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_min_max_scaler_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_min_max_scaler_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_min_max_scaler_reset(nint handle); @@ -1575,6 +2303,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_percentile_rank_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_percentile_rank_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_percentile_rank_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_percentile_rank_reset(nint handle); @@ -1590,6 +2325,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_quantile_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_quantile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_quantile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_quantile_reset(nint handle); @@ -1605,6 +2347,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_roofing_filter_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_roofing_filter_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_roofing_filter_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_roofing_filter_reset(nint handle); @@ -1620,6 +2369,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rsi_reset(nint handle); @@ -1635,6 +2391,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rsx_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rsx_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rsx_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rsx_reset(nint handle); @@ -1650,6 +2413,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rvi_volatility_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rvi_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rvi_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rvi_volatility_reset(nint handle); @@ -1665,6 +2435,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sample_entropy_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sample_entropy_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sample_entropy_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sample_entropy_reset(nint handle); @@ -1680,6 +2457,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_shannon_entropy_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_shannon_entropy_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_shannon_entropy_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_shannon_entropy_reset(nint handle); @@ -1695,6 +2479,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sharpe_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sharpe_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sharpe_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sharpe_ratio_reset(nint handle); @@ -1710,6 +2501,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sine_wave_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sine_wave_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sine_wave_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sine_wave_reset(nint handle); @@ -1725,6 +2523,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sine_weighted_ma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sine_weighted_ma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sine_weighted_ma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sine_weighted_ma_reset(nint handle); @@ -1740,6 +2545,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_skewness_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_skewness_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_skewness_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_skewness_reset(nint handle); @@ -1755,6 +2567,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sma_reset(nint handle); @@ -1770,6 +2589,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_smma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_smma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_smma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_smma_reset(nint handle); @@ -1785,6 +2611,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sortino_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sortino_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sortino_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sortino_ratio_reset(nint handle); @@ -1800,6 +2633,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_standard_error_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_standard_error_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_standard_error_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_standard_error_reset(nint handle); @@ -1815,6 +2655,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_stc_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_stc_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_stc_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_stc_reset(nint handle); @@ -1830,6 +2677,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_std_dev_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_std_dev_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_std_dev_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_std_dev_reset(nint handle); @@ -1845,6 +2699,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_step_trailing_stop_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_step_trailing_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_step_trailing_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_step_trailing_stop_reset(nint handle); @@ -1860,6 +2721,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sterling_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sterling_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sterling_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sterling_ratio_reset(nint handle); @@ -1875,6 +2743,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_stoch_rsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_stoch_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_stoch_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_stoch_rsi_reset(nint handle); @@ -1890,6 +2765,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_super_smoother_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_super_smoother_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_super_smoother_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_super_smoother_reset(nint handle); @@ -1905,6 +2787,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_t3_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_t3_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_t3_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_t3_reset(nint handle); @@ -1920,6 +2809,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tail_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tail_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tail_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tail_ratio_reset(nint handle); @@ -1935,6 +2831,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tema_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tema_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tema_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tema_reset(nint handle); @@ -1950,6 +2853,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tii_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tii_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tii_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tii_reset(nint handle); @@ -1965,6 +2875,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_trend_label_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trend_label_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trend_label_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trend_label_reset(nint handle); @@ -1980,6 +2897,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_trend_strength_index_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trend_strength_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trend_strength_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trend_strength_index_reset(nint handle); @@ -1995,6 +2919,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_trendflex_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trendflex_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trendflex_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trendflex_reset(nint handle); @@ -2010,6 +2941,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_trima_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trima_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trima_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trima_reset(nint handle); @@ -2025,6 +2963,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_trix_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trix_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trix_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trix_reset(nint handle); @@ -2040,6 +2985,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tsf_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tsf_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tsf_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tsf_reset(nint handle); @@ -2055,6 +3007,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tsf_oscillator_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tsf_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tsf_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tsf_oscillator_reset(nint handle); @@ -2070,6 +3029,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tsi_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tsi_reset(nint handle); @@ -2085,6 +3051,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ulcer_index_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ulcer_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ulcer_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ulcer_index_reset(nint handle); @@ -2100,6 +3073,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_universal_oscillator_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_universal_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_universal_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_universal_oscillator_reset(nint handle); @@ -2115,6 +3095,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_upside_potential_ratio_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_upside_potential_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_upside_potential_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_upside_potential_ratio_reset(nint handle); @@ -2130,6 +3117,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_value_at_risk_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_value_at_risk_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_value_at_risk_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_value_at_risk_reset(nint handle); @@ -2145,6 +3139,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_variance_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_variance_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_variance_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_variance_reset(nint handle); @@ -2160,6 +3161,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_vertical_horizontal_filter_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vertical_horizontal_filter_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vertical_horizontal_filter_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vertical_horizontal_filter_reset(nint handle); @@ -2175,6 +3183,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_vidya_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vidya_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vidya_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vidya_reset(nint handle); @@ -2190,6 +3205,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_volatility_of_volatility_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volatility_of_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volatility_of_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volatility_of_volatility_reset(nint handle); @@ -2205,6 +3227,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_wave_pm_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_wave_pm_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_wave_pm_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_wave_pm_reset(nint handle); @@ -2220,6 +3249,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_win_rate_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_win_rate_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_win_rate_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_win_rate_reset(nint handle); @@ -2235,6 +3271,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_wma_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_wma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_wma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_wma_reset(nint handle); @@ -2250,6 +3293,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_z_score_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_z_score_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_z_score_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_z_score_reset(nint handle); @@ -2265,6 +3315,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_zlema_batch(nint handle, double* input, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_zlema_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_zlema_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_zlema_reset(nint handle); @@ -2280,6 +3337,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_alpha_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_alpha_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_alpha_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_alpha_reset(nint handle); @@ -2295,6 +3359,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_beta_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_beta_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_beta_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_beta_reset(nint handle); @@ -2310,6 +3381,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_beta_neutral_spread_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_beta_neutral_spread_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_beta_neutral_spread_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_beta_neutral_spread_reset(nint handle); @@ -2325,6 +3403,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_distance_ssd_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_distance_ssd_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_distance_ssd_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_distance_ssd_reset(nint handle); @@ -2340,6 +3425,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_granger_causality_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_granger_causality_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_granger_causality_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_granger_causality_reset(nint handle); @@ -2355,6 +3447,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hasbrouck_information_share_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hasbrouck_information_share_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hasbrouck_information_share_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hasbrouck_information_share_reset(nint handle); @@ -2370,6 +3469,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_information_ratio_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_information_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_information_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_information_ratio_reset(nint handle); @@ -2385,6 +3491,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kendall_tau_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kendall_tau_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kendall_tau_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kendall_tau_reset(nint handle); @@ -2400,6 +3513,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ou_half_life_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ou_half_life_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ou_half_life_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ou_half_life_reset(nint handle); @@ -2415,6 +3535,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pair_spread_z_score_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pair_spread_z_score_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pair_spread_z_score_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pair_spread_z_score_reset(nint handle); @@ -2430,6 +3557,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pairwise_beta_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pairwise_beta_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pairwise_beta_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pairwise_beta_reset(nint handle); @@ -2445,6 +3579,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pearson_correlation_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pearson_correlation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pearson_correlation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pearson_correlation_reset(nint handle); @@ -2460,6 +3601,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_correlation_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_correlation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_correlation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_correlation_reset(nint handle); @@ -2475,6 +3623,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_covariance_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_covariance_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_covariance_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_covariance_reset(nint handle); @@ -2490,6 +3645,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_spearman_correlation_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_spearman_correlation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_spearman_correlation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_spearman_correlation_reset(nint handle); @@ -2505,6 +3667,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_spread_ar1_coefficient_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_spread_ar1_coefficient_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_spread_ar1_coefficient_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_spread_ar1_coefficient_reset(nint handle); @@ -2520,6 +3689,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_spread_hurst_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_spread_hurst_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_spread_hurst_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_spread_hurst_reset(nint handle); @@ -2535,6 +3711,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_treynor_ratio_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_treynor_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_treynor_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_treynor_ratio_reset(nint handle); @@ -2550,6 +3733,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_variance_ratio_batch(nint handle, double* x, double* y, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_variance_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_variance_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_variance_ratio_reset(nint handle); @@ -2565,6 +3755,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_abandoned_baby_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_abandoned_baby_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_abandoned_baby_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_abandoned_baby_reset(nint handle); @@ -2580,6 +3777,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_abcd_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_abcd_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_abcd_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_abcd_reset(nint handle); @@ -2595,6 +3799,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_accelerator_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_accelerator_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_accelerator_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_accelerator_oscillator_reset(nint handle); @@ -2610,6 +3821,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ad_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ad_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ad_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ad_oscillator_reset(nint handle); @@ -2625,6 +3843,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_adaptive_cci_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adaptive_cci_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adaptive_cci_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adaptive_cci_reset(nint handle); @@ -2640,6 +3865,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_adl_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adl_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adl_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adl_reset(nint handle); @@ -2655,6 +3887,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_advance_block_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_advance_block_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_advance_block_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_advance_block_reset(nint handle); @@ -2670,6 +3909,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_adxr_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adxr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adxr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adxr_reset(nint handle); @@ -2685,6 +3931,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_anchored_vwap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_anchored_vwap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_anchored_vwap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_anchored_vwap_reset(nint handle); @@ -2700,6 +3953,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_aroon_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_aroon_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_aroon_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_aroon_oscillator_reset(nint handle); @@ -2715,6 +3975,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_atr_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_atr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_atr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_atr_reset(nint handle); @@ -2730,6 +3997,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_atr_trailing_stop_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_atr_trailing_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_atr_trailing_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_atr_trailing_stop_reset(nint handle); @@ -2745,6 +4019,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_average_daily_range_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_average_daily_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_average_daily_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_average_daily_range_reset(nint handle); @@ -2760,6 +4041,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_avg_price_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_avg_price_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_avg_price_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_avg_price_reset(nint handle); @@ -2775,6 +4063,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_awesome_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_awesome_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_awesome_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_awesome_oscillator_reset(nint handle); @@ -2790,6 +4085,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_awesome_oscillator_histogram_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_awesome_oscillator_histogram_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_awesome_oscillator_histogram_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_awesome_oscillator_histogram_reset(nint handle); @@ -2805,6 +4107,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_balance_of_power_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_balance_of_power_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_balance_of_power_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_balance_of_power_reset(nint handle); @@ -2820,6 +4129,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_bat_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bat_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bat_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bat_reset(nint handle); @@ -2835,6 +4151,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_belt_hold_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_belt_hold_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_belt_hold_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_belt_hold_reset(nint handle); @@ -2850,6 +4173,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_better_volume_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_better_volume_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_better_volume_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_better_volume_reset(nint handle); @@ -2865,6 +4195,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_body_size_pct_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_body_size_pct_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_body_size_pct_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_body_size_pct_reset(nint handle); @@ -2880,6 +4217,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_breakaway_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_breakaway_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_breakaway_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_breakaway_reset(nint handle); @@ -2895,6 +4239,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_butterfly_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_butterfly_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_butterfly_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_butterfly_reset(nint handle); @@ -2910,6 +4261,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_cci_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cci_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cci_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cci_reset(nint handle); @@ -2925,6 +4283,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_chaikin_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_chaikin_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_chaikin_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_chaikin_oscillator_reset(nint handle); @@ -2940,6 +4305,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_chaikin_volatility_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_chaikin_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_chaikin_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_chaikin_volatility_reset(nint handle); @@ -2955,6 +4327,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_choppiness_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_choppiness_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_choppiness_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_choppiness_index_reset(nint handle); @@ -2970,6 +4349,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_close_vs_open_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_close_vs_open_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_close_vs_open_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_close_vs_open_reset(nint handle); @@ -2985,6 +4371,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_closing_marubozu_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_closing_marubozu_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_closing_marubozu_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_closing_marubozu_reset(nint handle); @@ -3000,6 +4393,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_chaikin_money_flow_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_chaikin_money_flow_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_chaikin_money_flow_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_chaikin_money_flow_reset(nint handle); @@ -3015,6 +4415,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_concealing_baby_swallow_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_concealing_baby_swallow_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_concealing_baby_swallow_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_concealing_baby_swallow_reset(nint handle); @@ -3030,6 +4437,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_counterattack_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_counterattack_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_counterattack_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_counterattack_reset(nint handle); @@ -3045,6 +4459,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_crab_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_crab_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_crab_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_crab_reset(nint handle); @@ -3060,6 +4481,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_cup_and_handle_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cup_and_handle_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cup_and_handle_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cup_and_handle_reset(nint handle); @@ -3075,6 +4503,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_cypher_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cypher_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cypher_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cypher_reset(nint handle); @@ -3090,6 +4525,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_demand_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_demand_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_demand_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_demand_index_reset(nint handle); @@ -3105,6 +4547,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_doji_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_doji_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_doji_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_doji_reset(nint handle); @@ -3120,6 +4569,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_doji_star_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_doji_star_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_doji_star_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_doji_star_reset(nint handle); @@ -3135,6 +4591,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_double_top_bottom_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_double_top_bottom_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_double_top_bottom_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_double_top_bottom_reset(nint handle); @@ -3150,6 +4613,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_downside_gap_three_methods_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_downside_gap_three_methods_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_downside_gap_three_methods_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_downside_gap_three_methods_reset(nint handle); @@ -3165,6 +4635,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_dragonfly_doji_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_dragonfly_doji_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_dragonfly_doji_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_dragonfly_doji_reset(nint handle); @@ -3180,6 +4657,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_dumpling_top_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_dumpling_top_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_dumpling_top_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_dumpling_top_reset(nint handle); @@ -3195,6 +4679,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_dx_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_dx_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_dx_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_dx_reset(nint handle); @@ -3210,6 +4701,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ease_of_movement_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ease_of_movement_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ease_of_movement_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ease_of_movement_reset(nint handle); @@ -3225,6 +4723,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_engulfing_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_engulfing_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_engulfing_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_engulfing_reset(nint handle); @@ -3240,6 +4745,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_evening_doji_star_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_evening_doji_star_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_evening_doji_star_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_evening_doji_star_reset(nint handle); @@ -3255,6 +4767,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_evwma_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_evwma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_evwma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_evwma_reset(nint handle); @@ -3270,6 +4789,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_falling_three_methods_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_falling_three_methods_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_falling_three_methods_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_falling_three_methods_reset(nint handle); @@ -3285,6 +4811,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_flag_pennant_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_flag_pennant_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_flag_pennant_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_flag_pennant_reset(nint handle); @@ -3300,6 +4833,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_force_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_force_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_force_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_force_index_reset(nint handle); @@ -3315,6 +4855,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_fry_pan_bottom_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fry_pan_bottom_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fry_pan_bottom_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fry_pan_bottom_reset(nint handle); @@ -3330,6 +4877,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_gap_side_by_side_white_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_gap_side_by_side_white_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_gap_side_by_side_white_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_gap_side_by_side_white_reset(nint handle); @@ -3345,6 +4899,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_garman_klass_volatility_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_garman_klass_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_garman_klass_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_garman_klass_volatility_reset(nint handle); @@ -3360,6 +4921,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_gartley_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_gartley_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_gartley_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_gartley_reset(nint handle); @@ -3375,6 +4943,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_gravestone_doji_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_gravestone_doji_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_gravestone_doji_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_gravestone_doji_reset(nint handle); @@ -3390,6 +4965,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hammer_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hammer_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hammer_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hammer_reset(nint handle); @@ -3405,6 +4987,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hanging_man_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hanging_man_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hanging_man_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hanging_man_reset(nint handle); @@ -3420,6 +5009,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_harami_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_harami_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_harami_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_harami_reset(nint handle); @@ -3435,6 +5031,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_harami_cross_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_harami_cross_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_harami_cross_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_harami_cross_reset(nint handle); @@ -3450,6 +5053,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_head_and_shoulders_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_head_and_shoulders_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_head_and_shoulders_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_head_and_shoulders_reset(nint handle); @@ -3465,6 +5075,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_heikin_ashi_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_heikin_ashi_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_heikin_ashi_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_heikin_ashi_oscillator_reset(nint handle); @@ -3480,6 +5097,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_high_low_range_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_high_low_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_high_low_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_high_low_range_reset(nint handle); @@ -3495,6 +5119,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_high_wave_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_high_wave_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_high_wave_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_high_wave_reset(nint handle); @@ -3510,6 +5141,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hikkake_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hikkake_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hikkake_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hikkake_reset(nint handle); @@ -3525,6 +5163,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hikkake_modified_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hikkake_modified_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hikkake_modified_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hikkake_modified_reset(nint handle); @@ -3540,6 +5185,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_hi_lo_activator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hi_lo_activator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hi_lo_activator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hi_lo_activator_reset(nint handle); @@ -3555,6 +5207,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_homing_pigeon_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_homing_pigeon_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_homing_pigeon_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_homing_pigeon_reset(nint handle); @@ -3570,6 +5229,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_identical_three_crows_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_identical_three_crows_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_identical_three_crows_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_identical_three_crows_reset(nint handle); @@ -3585,6 +5251,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_in_neck_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_in_neck_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_in_neck_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_in_neck_reset(nint handle); @@ -3600,6 +5273,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_inertia_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_inertia_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_inertia_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_inertia_reset(nint handle); @@ -3615,6 +5295,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_intraday_intensity_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_intraday_intensity_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_intraday_intensity_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_intraday_intensity_reset(nint handle); @@ -3630,6 +5317,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_intraday_momentum_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_intraday_momentum_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_intraday_momentum_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_intraday_momentum_index_reset(nint handle); @@ -3645,6 +5339,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_inverted_hammer_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_inverted_hammer_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_inverted_hammer_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_inverted_hammer_reset(nint handle); @@ -3660,6 +5361,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kicking_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kicking_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kicking_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kicking_reset(nint handle); @@ -3675,6 +5383,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kicking_by_length_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kicking_by_length_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kicking_by_length_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kicking_by_length_reset(nint handle); @@ -3690,6 +5405,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_kvo_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kvo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kvo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kvo_reset(nint handle); @@ -3705,6 +5427,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ladder_bottom_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ladder_bottom_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ladder_bottom_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ladder_bottom_reset(nint handle); @@ -3720,6 +5449,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_long_legged_doji_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_long_legged_doji_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_long_legged_doji_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_long_legged_doji_reset(nint handle); @@ -3735,6 +5471,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_long_line_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_long_line_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_long_line_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_long_line_reset(nint handle); @@ -3750,6 +5493,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_market_facilitation_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_market_facilitation_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_market_facilitation_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_market_facilitation_index_reset(nint handle); @@ -3765,6 +5515,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_marubozu_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_marubozu_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_marubozu_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_marubozu_reset(nint handle); @@ -3780,6 +5537,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mass_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mass_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mass_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mass_index_reset(nint handle); @@ -3795,6 +5559,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mat_hold_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mat_hold_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mat_hold_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mat_hold_reset(nint handle); @@ -3810,6 +5581,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_matching_low_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_matching_low_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_matching_low_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_matching_low_reset(nint handle); @@ -3825,6 +5603,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_median_price_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_median_price_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_median_price_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_median_price_reset(nint handle); @@ -3840,6 +5625,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mfi_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mfi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mfi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mfi_reset(nint handle); @@ -3855,6 +5647,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_mid_price_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mid_price_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mid_price_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mid_price_reset(nint handle); @@ -3870,6 +5669,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_minus_di_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_minus_di_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_minus_di_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_minus_di_reset(nint handle); @@ -3885,6 +5691,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_minus_dm_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_minus_dm_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_minus_dm_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_minus_dm_reset(nint handle); @@ -3900,6 +5713,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_morning_doji_star_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_morning_doji_star_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_morning_doji_star_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_morning_doji_star_reset(nint handle); @@ -3915,6 +5735,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_morning_evening_star_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_morning_evening_star_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_morning_evening_star_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_morning_evening_star_reset(nint handle); @@ -3930,6 +5757,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_naked_poc_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_naked_poc_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_naked_poc_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_naked_poc_reset(nint handle); @@ -3945,6 +5779,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_natr_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_natr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_natr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_natr_reset(nint handle); @@ -3960,6 +5801,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_new_price_lines_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_new_price_lines_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_new_price_lines_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_new_price_lines_reset(nint handle); @@ -3975,6 +5823,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_nvi_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_nvi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_nvi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_nvi_reset(nint handle); @@ -3990,6 +5845,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_obv_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_obv_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_obv_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_obv_reset(nint handle); @@ -4005,6 +5867,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_on_neck_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_on_neck_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_on_neck_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_on_neck_reset(nint handle); @@ -4020,6 +5889,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_opening_marubozu_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_opening_marubozu_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_opening_marubozu_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_opening_marubozu_reset(nint handle); @@ -4035,6 +5911,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_overnight_gap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_overnight_gap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_overnight_gap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_overnight_gap_reset(nint handle); @@ -4050,6 +5933,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_parkinson_volatility_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_parkinson_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_parkinson_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_parkinson_volatility_reset(nint handle); @@ -4065,6 +5955,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pgo_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pgo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pgo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pgo_reset(nint handle); @@ -4080,6 +5977,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_piercing_dark_cloud_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_piercing_dark_cloud_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_piercing_dark_cloud_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_piercing_dark_cloud_reset(nint handle); @@ -4095,6 +5999,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pivot_reversal_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pivot_reversal_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pivot_reversal_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pivot_reversal_reset(nint handle); @@ -4110,6 +6021,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_plus_di_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_plus_di_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_plus_di_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_plus_di_reset(nint handle); @@ -4125,6 +6043,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_plus_dm_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_plus_dm_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_plus_dm_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_plus_dm_reset(nint handle); @@ -4140,6 +6065,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_profile_shape_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_profile_shape_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_profile_shape_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_profile_shape_reset(nint handle); @@ -4155,6 +6087,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_projection_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_projection_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_projection_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_projection_oscillator_reset(nint handle); @@ -4170,6 +6109,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_psar_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_psar_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_psar_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_psar_reset(nint handle); @@ -4185,6 +6131,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_pvi_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pvi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pvi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pvi_reset(nint handle); @@ -4200,6 +6153,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_qstick_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_qstick_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_qstick_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_qstick_reset(nint handle); @@ -4215,6 +6175,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rectangle_range_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rectangle_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rectangle_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rectangle_range_reset(nint handle); @@ -4230,6 +6197,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rickshaw_man_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rickshaw_man_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rickshaw_man_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rickshaw_man_reset(nint handle); @@ -4245,6 +6219,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rising_three_methods_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rising_three_methods_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rising_three_methods_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rising_three_methods_reset(nint handle); @@ -4260,6 +6241,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rogers_satchell_volatility_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rogers_satchell_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rogers_satchell_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rogers_satchell_volatility_reset(nint handle); @@ -4275,6 +6263,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rvi_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rvi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rvi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rvi_reset(nint handle); @@ -4290,6 +6285,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_sar_ext_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_sar_ext_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_sar_ext_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_sar_ext_reset(nint handle); @@ -4305,6 +6307,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_seasonal_z_score_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_seasonal_z_score_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_seasonal_z_score_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_seasonal_z_score_reset(nint handle); @@ -4320,6 +6329,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_separating_lines_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_separating_lines_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_separating_lines_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_separating_lines_reset(nint handle); @@ -4335,6 +6351,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_session_vwap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_session_vwap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_session_vwap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_session_vwap_reset(nint handle); @@ -4350,6 +6373,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_shark_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_shark_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_shark_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_shark_reset(nint handle); @@ -4365,6 +6395,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_shooting_star_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_shooting_star_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_shooting_star_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_shooting_star_reset(nint handle); @@ -4380,6 +6417,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_short_line_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_short_line_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_short_line_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_short_line_reset(nint handle); @@ -4395,6 +6439,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_single_prints_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_single_prints_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_single_prints_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_single_prints_reset(nint handle); @@ -4410,6 +6461,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_smi_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_smi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_smi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_smi_reset(nint handle); @@ -4425,6 +6483,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_spinning_top_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_spinning_top_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_spinning_top_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_spinning_top_reset(nint handle); @@ -4440,6 +6505,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_stalled_pattern_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_stalled_pattern_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_stalled_pattern_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_stalled_pattern_reset(nint handle); @@ -4455,6 +6527,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_stick_sandwich_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_stick_sandwich_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_stick_sandwich_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_stick_sandwich_reset(nint handle); @@ -4470,6 +6549,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_stochastic_cci_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_stochastic_cci_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_stochastic_cci_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_stochastic_cci_reset(nint handle); @@ -4485,6 +6571,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_takuri_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_takuri_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_takuri_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_takuri_reset(nint handle); @@ -4500,6 +6593,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tasuki_gap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tasuki_gap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tasuki_gap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tasuki_gap_reset(nint handle); @@ -4515,6 +6615,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_camouflage_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_camouflage_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_camouflage_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_camouflage_reset(nint handle); @@ -4530,6 +6637,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_clop_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_clop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_clop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_clop_reset(nint handle); @@ -4545,6 +6659,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_clopwin_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_clopwin_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_clopwin_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_clopwin_reset(nint handle); @@ -4560,6 +6681,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_combo_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_combo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_combo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_combo_reset(nint handle); @@ -4575,6 +6703,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_countdown_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_countdown_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_countdown_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_countdown_reset(nint handle); @@ -4590,6 +6725,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_de_marker_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_de_marker_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_de_marker_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_de_marker_reset(nint handle); @@ -4605,6 +6747,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_differential_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_differential_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_differential_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_differential_reset(nint handle); @@ -4620,6 +6769,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_d_wave_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_d_wave_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_d_wave_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_d_wave_reset(nint handle); @@ -4635,6 +6791,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_open_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_open_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_open_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_open_reset(nint handle); @@ -4650,6 +6813,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_pressure_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_pressure_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_pressure_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_pressure_reset(nint handle); @@ -4665,6 +6835,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_propulsion_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_propulsion_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_propulsion_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_propulsion_reset(nint handle); @@ -4680,6 +6857,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_rei_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_rei_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_rei_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_rei_reset(nint handle); @@ -4695,6 +6879,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_setup_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_setup_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_setup_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_setup_reset(nint handle); @@ -4710,6 +6901,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_td_trap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_trap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_trap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_trap_reset(nint handle); @@ -4725,6 +6923,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_drives_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_drives_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_drives_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_drives_reset(nint handle); @@ -4740,6 +6945,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_inside_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_inside_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_inside_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_inside_reset(nint handle); @@ -4755,6 +6967,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_line_break_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_line_break_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_line_break_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_line_break_reset(nint handle); @@ -4770,6 +6989,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_line_strike_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_line_strike_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_line_strike_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_line_strike_reset(nint handle); @@ -4785,6 +7011,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_outside_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_outside_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_outside_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_outside_reset(nint handle); @@ -4800,6 +7033,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_soldiers_or_crows_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_soldiers_or_crows_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_soldiers_or_crows_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_soldiers_or_crows_reset(nint handle); @@ -4815,6 +7055,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_three_stars_in_south_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_three_stars_in_south_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_three_stars_in_south_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_three_stars_in_south_reset(nint handle); @@ -4830,6 +7077,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_thrusting_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_thrusting_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_thrusting_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_thrusting_reset(nint handle); @@ -4845,6 +7099,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_time_based_stop_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_time_based_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_time_based_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_time_based_stop_reset(nint handle); @@ -4860,6 +7121,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tower_top_bottom_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tower_top_bottom_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tower_top_bottom_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tower_top_bottom_reset(nint handle); @@ -4875,6 +7143,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_trade_volume_index_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trade_volume_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trade_volume_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trade_volume_index_reset(nint handle); @@ -4890,6 +7165,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_triangle_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_triangle_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_triangle_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_triangle_reset(nint handle); @@ -4905,6 +7187,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_triple_top_bottom_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_triple_top_bottom_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_triple_top_bottom_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_triple_top_bottom_reset(nint handle); @@ -4920,6 +7209,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tristar_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tristar_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tristar_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tristar_reset(nint handle); @@ -4935,6 +7231,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_true_range_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_true_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_true_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_true_range_reset(nint handle); @@ -4950,6 +7253,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tsv_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tsv_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tsv_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tsv_reset(nint handle); @@ -4965,6 +7275,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ttm_trend_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ttm_trend_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ttm_trend_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ttm_trend_reset(nint handle); @@ -4980,6 +7297,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_turn_of_month_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_turn_of_month_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_turn_of_month_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_turn_of_month_reset(nint handle); @@ -4995,6 +7319,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_tweezer_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tweezer_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tweezer_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tweezer_reset(nint handle); @@ -5010,6 +7341,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_twiggs_money_flow_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_twiggs_money_flow_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_twiggs_money_flow_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_twiggs_money_flow_reset(nint handle); @@ -5025,6 +7363,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_two_crows_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_two_crows_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_two_crows_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_two_crows_reset(nint handle); @@ -5040,6 +7385,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_typical_price_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_typical_price_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_typical_price_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_typical_price_reset(nint handle); @@ -5055,6 +7407,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_ultimate_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ultimate_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ultimate_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ultimate_oscillator_reset(nint handle); @@ -5070,6 +7429,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_unique_three_river_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_unique_three_river_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_unique_three_river_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_unique_three_river_reset(nint handle); @@ -5085,6 +7451,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_upside_gap_three_methods_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_upside_gap_three_methods_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_upside_gap_three_methods_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_upside_gap_three_methods_reset(nint handle); @@ -5100,6 +7473,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_upside_gap_two_crows_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_upside_gap_two_crows_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_upside_gap_two_crows_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_upside_gap_two_crows_reset(nint handle); @@ -5115,6 +7495,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_volatility_ratio_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volatility_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volatility_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volatility_ratio_reset(nint handle); @@ -5130,6 +7517,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_volty_stop_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volty_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volty_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volty_stop_reset(nint handle); @@ -5145,6 +7539,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_volume_oscillator_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_oscillator_reset(nint handle); @@ -5160,6 +7561,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_volume_rsi_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_rsi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_rsi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_rsi_reset(nint handle); @@ -5175,6 +7583,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_volume_price_trend_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_price_trend_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_price_trend_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_price_trend_reset(nint handle); @@ -5190,6 +7605,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_vwap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vwap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vwap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vwap_reset(nint handle); @@ -5205,6 +7627,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_rolling_vwap_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rolling_vwap_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rolling_vwap_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rolling_vwap_reset(nint handle); @@ -5220,6 +7649,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_vwma_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vwma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vwma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vwma_reset(nint handle); @@ -5235,6 +7671,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_vzo_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vzo_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vzo_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vzo_reset(nint handle); @@ -5250,6 +7693,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_wad_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_wad_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_wad_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_wad_reset(nint handle); @@ -5265,6 +7715,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_wedge_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_wedge_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_wedge_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_wedge_reset(nint handle); @@ -5280,6 +7737,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_weighted_close_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_weighted_close_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_weighted_close_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_weighted_close_reset(nint handle); @@ -5295,6 +7759,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_wick_ratio_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_wick_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_wick_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_wick_ratio_reset(nint handle); @@ -5310,6 +7781,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_williams_r_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_williams_r_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_williams_r_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_williams_r_reset(nint handle); @@ -5325,6 +7803,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_yang_zhang_volatility_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_yang_zhang_volatility_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_yang_zhang_volatility_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_yang_zhang_volatility_reset(nint handle); @@ -5340,6 +7825,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial void wickra_yoyo_exit_batch(nint handle, double* open, double* high, double* low, double* close, double* volume, long* timestamp, double* @out, nuint n); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_yoyo_exit_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_yoyo_exit_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_yoyo_exit_reset(nint handle); @@ -5352,6 +7844,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_amihud_illiquidity_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_amihud_illiquidity_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_amihud_illiquidity_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_amihud_illiquidity_reset(nint handle); @@ -5364,6 +7863,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_cumulative_volume_delta_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cumulative_volume_delta_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cumulative_volume_delta_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cumulative_volume_delta_reset(nint handle); @@ -5376,6 +7882,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_pin_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_pin_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_pin_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_pin_reset(nint handle); @@ -5388,6 +7901,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_roll_measure_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_roll_measure_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_roll_measure_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_roll_measure_reset(nint handle); @@ -5400,6 +7920,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_signed_volume_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_signed_volume_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_signed_volume_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_signed_volume_reset(nint handle); @@ -5412,6 +7939,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_trade_imbalance_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trade_imbalance_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trade_imbalance_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trade_imbalance_reset(nint handle); @@ -5424,6 +7958,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_trade_sign_autocorrelation_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trade_sign_autocorrelation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trade_sign_autocorrelation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trade_sign_autocorrelation_reset(nint handle); @@ -5436,6 +7977,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_vpin_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vpin_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vpin_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vpin_reset(nint handle); @@ -5448,6 +7996,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_effective_spread_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp, double mid); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_effective_spread_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_effective_spread_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_effective_spread_reset(nint handle); @@ -5460,6 +8015,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_kyles_lambda_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp, double mid); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kyles_lambda_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kyles_lambda_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kyles_lambda_reset(nint handle); @@ -5472,6 +8034,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_realized_spread_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp, double mid); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_realized_spread_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_realized_spread_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_realized_spread_reset(nint handle); @@ -5484,6 +8053,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_calendar_spread_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_calendar_spread_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_calendar_spread_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_calendar_spread_reset(nint handle); @@ -5496,6 +8072,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_estimated_leverage_ratio_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_estimated_leverage_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_estimated_leverage_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_estimated_leverage_ratio_reset(nint handle); @@ -5508,6 +8091,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_funding_basis_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_funding_basis_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_funding_basis_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_funding_basis_reset(nint handle); @@ -5520,6 +8110,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_funding_implied_apr_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_funding_implied_apr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_funding_implied_apr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_funding_implied_apr_reset(nint handle); @@ -5532,6 +8129,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_funding_rate_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_funding_rate_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_funding_rate_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_funding_rate_reset(nint handle); @@ -5544,6 +8148,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_funding_rate_mean_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_funding_rate_mean_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_funding_rate_mean_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_funding_rate_mean_reset(nint handle); @@ -5556,6 +8167,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_funding_rate_z_score_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_funding_rate_z_score_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_funding_rate_z_score_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_funding_rate_z_score_reset(nint handle); @@ -5568,6 +8186,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_long_short_ratio_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_long_short_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_long_short_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_long_short_ratio_reset(nint handle); @@ -5580,6 +8205,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_open_interest_delta_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_open_interest_delta_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_open_interest_delta_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_open_interest_delta_reset(nint handle); @@ -5592,6 +8224,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_oi_price_divergence_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_oi_price_divergence_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_oi_price_divergence_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_oi_price_divergence_reset(nint handle); @@ -5604,6 +8243,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_oi_to_volume_ratio_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_oi_to_volume_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_oi_to_volume_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_oi_to_volume_ratio_reset(nint handle); @@ -5616,6 +8262,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_oi_weighted_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_oi_weighted_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_oi_weighted_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_oi_weighted_reset(nint handle); @@ -5628,6 +8281,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_open_interest_momentum_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_open_interest_momentum_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_open_interest_momentum_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_open_interest_momentum_reset(nint handle); @@ -5640,6 +8300,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_perpetual_premium_index_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_perpetual_premium_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_perpetual_premium_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_perpetual_premium_index_reset(nint handle); @@ -5652,6 +8319,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_taker_buy_sell_ratio_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_taker_buy_sell_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_taker_buy_sell_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_taker_buy_sell_ratio_reset(nint handle); @@ -5664,6 +8338,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static partial double wickra_term_structure_basis_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_term_structure_basis_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_term_structure_basis_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_term_structure_basis_reset(nint handle); @@ -5676,6 +8357,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_depth_slope_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_depth_slope_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_depth_slope_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_depth_slope_reset(nint handle); @@ -5688,6 +8376,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_microprice_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_microprice_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_microprice_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_microprice_reset(nint handle); @@ -5700,6 +8395,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_order_book_imbalance_full_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_order_book_imbalance_full_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_order_book_imbalance_full_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_order_book_imbalance_full_reset(nint handle); @@ -5712,6 +8414,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_order_book_imbalance_top1_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_order_book_imbalance_top1_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_order_book_imbalance_top1_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_order_book_imbalance_top1_reset(nint handle); @@ -5724,6 +8433,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_order_book_imbalance_top_n_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_order_book_imbalance_top_n_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_order_book_imbalance_top_n_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_order_book_imbalance_top_n_reset(nint handle); @@ -5736,6 +8452,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_order_flow_imbalance_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_order_flow_imbalance_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_order_flow_imbalance_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_order_flow_imbalance_reset(nint handle); @@ -5748,6 +8471,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_quoted_spread_update(nint handle, double* bidPrice, double* bidSize, nuint nBids, double* askPrice, double* askSize, nuint nAsks); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_quoted_spread_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_quoted_spread_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_quoted_spread_reset(nint handle); @@ -5760,6 +8490,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_absolute_breadth_index_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_absolute_breadth_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_absolute_breadth_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_absolute_breadth_index_reset(nint handle); @@ -5772,6 +8509,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_ad_volume_line_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ad_volume_line_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ad_volume_line_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ad_volume_line_reset(nint handle); @@ -5784,6 +8528,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_advance_decline_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_advance_decline_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_advance_decline_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_advance_decline_reset(nint handle); @@ -5796,6 +8547,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_advance_decline_ratio_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_advance_decline_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_advance_decline_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_advance_decline_ratio_reset(nint handle); @@ -5808,6 +8566,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_breadth_thrust_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_breadth_thrust_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_breadth_thrust_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_breadth_thrust_reset(nint handle); @@ -5820,6 +8585,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_bullish_percent_index_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bullish_percent_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bullish_percent_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bullish_percent_index_reset(nint handle); @@ -5832,6 +8604,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_cumulative_volume_index_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cumulative_volume_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cumulative_volume_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cumulative_volume_index_reset(nint handle); @@ -5844,6 +8623,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_high_low_index_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_high_low_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_high_low_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_high_low_index_reset(nint handle); @@ -5856,6 +8642,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_mc_clellan_oscillator_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mc_clellan_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mc_clellan_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mc_clellan_oscillator_reset(nint handle); @@ -5868,6 +8661,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_mc_clellan_summation_index_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mc_clellan_summation_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mc_clellan_summation_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mc_clellan_summation_index_reset(nint handle); @@ -5880,6 +8680,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_new_highs_new_lows_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_new_highs_new_lows_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_new_highs_new_lows_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_new_highs_new_lows_reset(nint handle); @@ -5892,6 +8699,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_percent_above_ma_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_percent_above_ma_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_percent_above_ma_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_percent_above_ma_reset(nint handle); @@ -5904,6 +8718,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_tick_index_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tick_index_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tick_index_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tick_index_reset(nint handle); @@ -5916,6 +8737,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_trin_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_trin_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_trin_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_trin_reset(nint handle); @@ -5928,6 +8756,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial double wickra_up_down_volume_ratio_update(nint handle, double* change, double* volume, bool* newHigh, bool* newLow, bool* aboveMa, bool* onBuySignal, nuint n, long timestamp); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_up_down_volume_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_up_down_volume_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_up_down_volume_ratio_reset(nint handle); @@ -5941,6 +8776,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_acceleration_bands_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAccelerationBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_acceleration_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_acceleration_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_acceleration_bands_reset(nint handle); @@ -5954,6 +8796,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_adx_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAdxOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_adx_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_adx_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_adx_reset(nint handle); @@ -5967,6 +8816,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_alligator_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAlligatorOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_alligator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_alligator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_alligator_reset(nint handle); @@ -5980,6 +8836,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_andrews_pitchfork_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAndrewsPitchforkOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_andrews_pitchfork_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_andrews_pitchfork_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_andrews_pitchfork_reset(nint handle); @@ -5993,6 +8856,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_aroon_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAroonOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_aroon_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_aroon_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_aroon_reset(nint handle); @@ -6006,6 +8876,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_atr_bands_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAtrBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_atr_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_atr_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_atr_bands_reset(nint handle); @@ -6019,6 +8896,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_atr_ratchet_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAtrRatchetOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_atr_ratchet_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_atr_ratchet_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_atr_ratchet_reset(nint handle); @@ -6032,6 +8916,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_auto_fib_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraAutoFibOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_auto_fib_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_auto_fib_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_auto_fib_reset(nint handle); @@ -6045,6 +8936,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_bollinger_bands_update(nint handle, double @value, WickraBollingerOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bollinger_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bollinger_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bollinger_bands_reset(nint handle); @@ -6058,6 +8956,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_bomar_bands_update(nint handle, double @value, WickraBomarBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_bomar_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_bomar_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_bomar_bands_reset(nint handle); @@ -6071,6 +8976,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_camarilla_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraCamarillaPivotsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_camarilla_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_camarilla_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_camarilla_reset(nint handle); @@ -6084,6 +8996,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_candle_volume_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraCandleVolumeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_candle_volume_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_candle_volume_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_candle_volume_reset(nint handle); @@ -6097,6 +9016,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_central_pivot_range_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraCentralPivotRangeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_central_pivot_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_central_pivot_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_central_pivot_range_reset(nint handle); @@ -6110,6 +9036,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_chande_kroll_stop_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraChandeKrollStopOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_chande_kroll_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_chande_kroll_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_chande_kroll_stop_reset(nint handle); @@ -6123,6 +9056,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_chandelier_exit_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraChandelierExitOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_chandelier_exit_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_chandelier_exit_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_chandelier_exit_reset(nint handle); @@ -6136,6 +9076,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_classic_pivots_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraClassicPivotsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_classic_pivots_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_classic_pivots_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_classic_pivots_reset(nint handle); @@ -6149,6 +9096,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_cointegration_update(nint handle, double x, double y, WickraCointegrationOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_cointegration_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_cointegration_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_cointegration_reset(nint handle); @@ -6162,6 +9116,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_composite_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraCompositeProfileOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_composite_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_composite_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_composite_profile_reset(nint handle); @@ -6175,6 +9136,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_demark_pivots_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraDemarkPivotsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_demark_pivots_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_demark_pivots_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_demark_pivots_reset(nint handle); @@ -6188,6 +9156,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_donchian_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraDonchianOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_donchian_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_donchian_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_donchian_reset(nint handle); @@ -6201,6 +9176,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_donchian_stop_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraDonchianStopOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_donchian_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_donchian_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_donchian_stop_reset(nint handle); @@ -6214,6 +9196,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_double_bollinger_update(nint handle, double @value, WickraDoubleBollingerOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_double_bollinger_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_double_bollinger_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_double_bollinger_reset(nint handle); @@ -6227,6 +9216,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_elder_ray_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraElderRayOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_elder_ray_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_elder_ray_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_elder_ray_reset(nint handle); @@ -6240,6 +9236,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_elder_safe_zone_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraElderSafeZoneOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_elder_safe_zone_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_elder_safe_zone_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_elder_safe_zone_reset(nint handle); @@ -6253,6 +9256,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_equivolume_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraEquivolumeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_equivolume_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_equivolume_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_equivolume_reset(nint handle); @@ -6266,6 +9276,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_arcs_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibArcsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_arcs_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_arcs_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_arcs_reset(nint handle); @@ -6279,6 +9296,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_channel_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibChannelOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_channel_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_channel_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_channel_reset(nint handle); @@ -6292,6 +9316,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_confluence_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibConfluenceOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_confluence_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_confluence_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_confluence_reset(nint handle); @@ -6305,6 +9336,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_extension_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibExtensionOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_extension_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_extension_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_extension_reset(nint handle); @@ -6318,6 +9356,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_fan_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibFanOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_fan_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_fan_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_fan_reset(nint handle); @@ -6331,6 +9376,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_projection_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibProjectionOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_projection_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_projection_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_projection_reset(nint handle); @@ -6344,6 +9396,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_retracement_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibRetracementOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_retracement_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_retracement_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_retracement_reset(nint handle); @@ -6357,6 +9416,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fib_time_zones_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibTimeZonesOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fib_time_zones_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fib_time_zones_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fib_time_zones_reset(nint handle); @@ -6370,6 +9436,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fibonacci_pivots_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFibonacciPivotsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fibonacci_pivots_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fibonacci_pivots_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fibonacci_pivots_reset(nint handle); @@ -6383,6 +9456,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_fractal_chaos_bands_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraFractalChaosBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_fractal_chaos_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_fractal_chaos_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_fractal_chaos_bands_reset(nint handle); @@ -6396,6 +9476,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_gator_oscillator_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraGatorOscillatorOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_gator_oscillator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_gator_oscillator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_gator_oscillator_reset(nint handle); @@ -6409,6 +9496,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_golden_pocket_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraGoldenPocketOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_golden_pocket_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_golden_pocket_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_golden_pocket_reset(nint handle); @@ -6422,6 +9516,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_heikin_ashi_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraHeikinAshiOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_heikin_ashi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_heikin_ashi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_heikin_ashi_reset(nint handle); @@ -6435,6 +9536,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_high_low_volume_nodes_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraHighLowVolumeNodesOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_high_low_volume_nodes_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_high_low_volume_nodes_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_high_low_volume_nodes_reset(nint handle); @@ -6448,6 +9556,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_ht_phasor_update(nint handle, double @value, WickraHtPhasorOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ht_phasor_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ht_phasor_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ht_phasor_reset(nint handle); @@ -6461,6 +9576,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_hurst_channel_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraHurstChannelOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_hurst_channel_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_hurst_channel_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_hurst_channel_reset(nint handle); @@ -6474,6 +9596,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_ichimoku_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraIchimokuOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ichimoku_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ichimoku_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ichimoku_reset(nint handle); @@ -6487,6 +9616,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_initial_balance_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraInitialBalanceOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_initial_balance_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_initial_balance_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_initial_balance_reset(nint handle); @@ -6500,6 +9636,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_kalman_hedge_ratio_update(nint handle, double x, double y, WickraKalmanHedgeRatioOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kalman_hedge_ratio_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kalman_hedge_ratio_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kalman_hedge_ratio_reset(nint handle); @@ -6513,6 +9656,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_kase_dev_stop_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraKaseDevStopOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kase_dev_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kase_dev_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kase_dev_stop_reset(nint handle); @@ -6526,6 +9676,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_kase_permission_stochastic_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraKasePermissionStochasticOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kase_permission_stochastic_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kase_permission_stochastic_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kase_permission_stochastic_reset(nint handle); @@ -6539,6 +9696,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_keltner_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraKeltnerOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_keltner_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_keltner_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_keltner_reset(nint handle); @@ -6552,6 +9716,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_kst_update(nint handle, double @value, WickraKstOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_kst_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_kst_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_kst_reset(nint handle); @@ -6565,6 +9736,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_lead_lag_cross_correlation_update(nint handle, double x, double y, WickraLeadLagCrossCorrelationOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_lead_lag_cross_correlation_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_lead_lag_cross_correlation_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_lead_lag_cross_correlation_reset(nint handle); @@ -6578,6 +9756,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_lin_reg_channel_update(nint handle, double @value, WickraLinRegChannelOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_lin_reg_channel_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_lin_reg_channel_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_lin_reg_channel_reset(nint handle); @@ -6591,6 +9776,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_liquidation_features_update(nint handle, double fundingRate, double markPrice, double indexPrice, double futuresPrice, double openInterest, double longSize, double shortSize, double takerBuyVolume, double takerSellVolume, double longLiquidation, double shortLiquidation, long timestamp, WickraLiquidationFeaturesOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_liquidation_features_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_liquidation_features_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_liquidation_features_reset(nint handle); @@ -6604,6 +9796,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_ma_envelope_update(nint handle, double @value, WickraMaEnvelopeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ma_envelope_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ma_envelope_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ma_envelope_reset(nint handle); @@ -6617,6 +9816,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_macd_indicator_update(nint handle, double @value, WickraMacdOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_macd_indicator_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_macd_indicator_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_macd_indicator_reset(nint handle); @@ -6630,6 +9836,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_macd_fix_update(nint handle, double @value, WickraMacdOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_macd_fix_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_macd_fix_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_macd_fix_reset(nint handle); @@ -6643,6 +9856,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_mama_update(nint handle, double @value, WickraMamaOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_mama_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_mama_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_mama_reset(nint handle); @@ -6656,6 +9876,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_median_channel_update(nint handle, double @value, WickraMedianChannelOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_median_channel_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_median_channel_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_median_channel_reset(nint handle); @@ -6669,6 +9896,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_modified_ma_stop_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraModifiedMaStopOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_modified_ma_stop_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_modified_ma_stop_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_modified_ma_stop_reset(nint handle); @@ -6682,6 +9916,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_murrey_math_lines_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraMurreyMathLinesOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_murrey_math_lines_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_murrey_math_lines_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_murrey_math_lines_reset(nint handle); @@ -6695,6 +9936,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_nrtr_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraNrtrOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_nrtr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_nrtr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_nrtr_reset(nint handle); @@ -6708,6 +9956,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_opening_range_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraOpeningRangeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_opening_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_opening_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_opening_range_reset(nint handle); @@ -6721,6 +9976,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_overnight_intraday_return_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraOvernightIntradayReturnOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_overnight_intraday_return_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_overnight_intraday_return_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_overnight_intraday_return_reset(nint handle); @@ -6734,6 +9996,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_projection_bands_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraProjectionBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_projection_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_projection_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_projection_bands_reset(nint handle); @@ -6747,6 +10016,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_qqe_update(nint handle, double @value, WickraQqeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_qqe_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_qqe_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_qqe_reset(nint handle); @@ -6760,6 +10036,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_quartile_bands_update(nint handle, double @value, WickraQuartileBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_quartile_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_quartile_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_quartile_bands_reset(nint handle); @@ -6773,6 +10056,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_relative_strength_ab_update(nint handle, double x, double y, WickraRelativeStrengthOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_relative_strength_ab_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_relative_strength_ab_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_relative_strength_ab_reset(nint handle); @@ -6786,6 +10076,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_rwi_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraRwiOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_rwi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_rwi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_rwi_reset(nint handle); @@ -6799,6 +10096,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_session_high_low_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraSessionHighLowOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_session_high_low_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_session_high_low_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_session_high_low_reset(nint handle); @@ -6812,6 +10116,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_session_range_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraSessionRangeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_session_range_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_session_range_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_session_range_reset(nint handle); @@ -6825,6 +10136,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_smoothed_heikin_ashi_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraSmoothedHeikinAshiOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_smoothed_heikin_ashi_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_smoothed_heikin_ashi_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_smoothed_heikin_ashi_reset(nint handle); @@ -6838,6 +10156,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_spread_bollinger_bands_update(nint handle, double x, double y, WickraSpreadBollingerBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_spread_bollinger_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_spread_bollinger_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_spread_bollinger_bands_reset(nint handle); @@ -6851,6 +10176,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_standard_error_bands_update(nint handle, double @value, WickraStandardErrorBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_standard_error_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_standard_error_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_standard_error_bands_reset(nint handle); @@ -6864,6 +10196,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_starc_bands_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraStarcBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_starc_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_starc_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_starc_bands_reset(nint handle); @@ -6877,6 +10216,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_stochastic_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraStochasticOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_stochastic_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_stochastic_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_stochastic_reset(nint handle); @@ -6890,6 +10236,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_super_trend_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraSuperTrendOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_super_trend_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_super_trend_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_super_trend_reset(nint handle); @@ -6903,6 +10256,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_td_lines_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTdLinesOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_lines_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_lines_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_lines_reset(nint handle); @@ -6916,6 +10276,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_td_moving_average_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTdMovingAverageOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_moving_average_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_moving_average_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_moving_average_reset(nint handle); @@ -6929,6 +10296,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_td_range_projection_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTdRangeProjectionOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_range_projection_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_range_projection_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_range_projection_reset(nint handle); @@ -6942,6 +10316,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_td_risk_level_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTdRiskLevelOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_risk_level_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_risk_level_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_risk_level_reset(nint handle); @@ -6955,6 +10336,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_td_sequential_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTdSequentialOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_td_sequential_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_td_sequential_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_td_sequential_reset(nint handle); @@ -6968,6 +10356,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_ttm_squeeze_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTtmSqueezeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_ttm_squeeze_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_ttm_squeeze_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_ttm_squeeze_reset(nint handle); @@ -6981,6 +10376,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_value_area_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraValueAreaOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_value_area_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_value_area_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_value_area_reset(nint handle); @@ -6994,6 +10396,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_volatility_cone_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraVolatilityConeOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volatility_cone_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volatility_cone_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volatility_cone_reset(nint handle); @@ -7007,6 +10416,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_volume_weighted_macd_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraVolumeWeightedMacdOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_weighted_macd_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_weighted_macd_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_weighted_macd_reset(nint handle); @@ -7020,6 +10436,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_volume_weighted_sr_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraVolumeWeightedSrOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_weighted_sr_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_weighted_sr_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_weighted_sr_reset(nint handle); @@ -7033,6 +10456,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_vortex_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraVortexOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vortex_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vortex_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vortex_reset(nint handle); @@ -7046,6 +10476,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_vwap_std_dev_bands_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraVwapStdDevBandsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_vwap_std_dev_bands_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_vwap_std_dev_bands_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_vwap_std_dev_bands_reset(nint handle); @@ -7059,6 +10496,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_wave_trend_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraWaveTrendOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_wave_trend_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_wave_trend_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_wave_trend_reset(nint handle); @@ -7072,6 +10516,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_williams_fractals_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraWilliamsFractalsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_williams_fractals_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_williams_fractals_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_williams_fractals_reset(nint handle); @@ -7085,6 +10536,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_woodie_pivots_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraWoodiePivotsOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_woodie_pivots_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_woodie_pivots_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_woodie_pivots_reset(nint handle); @@ -7098,6 +10556,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_zero_lag_macd_update(nint handle, double @value, WickraZeroLagMacdOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_zero_lag_macd_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_zero_lag_macd_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_zero_lag_macd_reset(nint handle); @@ -7111,6 +10576,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_zig_zag_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraZigZagOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_zig_zag_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_zig_zag_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_zig_zag_reset(nint handle); @@ -7123,6 +10595,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_day_of_week_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, double* values, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_day_of_week_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_day_of_week_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_day_of_week_profile_reset(nint handle); @@ -7135,6 +10614,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_intraday_volatility_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, double* values, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_intraday_volatility_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_intraday_volatility_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_intraday_volatility_profile_reset(nint handle); @@ -7147,6 +10633,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_time_of_day_return_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, double* values, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_time_of_day_return_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_time_of_day_return_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_time_of_day_return_profile_reset(nint handle); @@ -7159,6 +10652,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_tpo_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraTpoProfileOutputScalars* scalars, double* values, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_tpo_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_tpo_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_tpo_profile_reset(nint handle); @@ -7171,6 +10671,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_volume_by_time_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, double* values, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_by_time_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_by_time_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_by_time_profile_reset(nint handle); @@ -7183,6 +10690,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_volume_profile_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraVolumeProfileOutputScalars* scalars, double* values, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_volume_profile_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_volume_profile_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_volume_profile_reset(nint handle); @@ -7316,6 +10830,13 @@ internal static partial class NativeMethods [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool wickra_macd_ext_update(nint handle, double @value, WickraMacdOutput* @out); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_macd_ext_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_macd_ext_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_macd_ext_reset(nint handle); @@ -7328,6 +10849,13 @@ internal static partial class NativeMethods [LibraryImport(WickraNative.LibraryName)] internal static unsafe partial nint wickra_footprint_update(nint handle, double price, double size, [MarshalAs(UnmanagedType.U1)] bool isBuy, long timestamp, WickraFootprintLevel* @out, nuint cap); + [LibraryImport(WickraNative.LibraryName)] + internal static partial nuint wickra_footprint_warmup_period(nint handle); + + [LibraryImport(WickraNative.LibraryName)] + [return: MarshalAs(UnmanagedType.U1)] + internal static partial bool wickra_footprint_is_ready(nint handle); + [LibraryImport(WickraNative.LibraryName)] internal static partial void wickra_footprint_reset(nint handle); diff --git a/bindings/go/include/wickra.h b/bindings/go/include/wickra.h index 0c4ca4e9..e8589bda 100644 --- a/bindings/go/include/wickra.h +++ b/bindings/go/include/wickra.h @@ -1688,6 +1688,10 @@ void wickra_adaptive_cycle_batch(struct AdaptiveCycle *handle, double *out, uintptr_t n); +uintptr_t wickra_adaptive_cycle_warmup_period(struct AdaptiveCycle *handle); + +bool wickra_adaptive_cycle_is_ready(struct AdaptiveCycle *handle); + void wickra_adaptive_cycle_reset(struct AdaptiveCycle *handle); void wickra_adaptive_cycle_free(struct AdaptiveCycle *handle); @@ -1701,6 +1705,10 @@ void wickra_adaptive_laguerre_filter_batch(struct AdaptiveLaguerreFilter *handle double *out, uintptr_t n); +uintptr_t wickra_adaptive_laguerre_filter_warmup_period(struct AdaptiveLaguerreFilter *handle); + +bool wickra_adaptive_laguerre_filter_is_ready(struct AdaptiveLaguerreFilter *handle); + void wickra_adaptive_laguerre_filter_reset(struct AdaptiveLaguerreFilter *handle); void wickra_adaptive_laguerre_filter_free(struct AdaptiveLaguerreFilter *handle); @@ -1714,6 +1722,10 @@ void wickra_adaptive_rsi_batch(struct AdaptiveRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_adaptive_rsi_warmup_period(struct AdaptiveRsi *handle); + +bool wickra_adaptive_rsi_is_ready(struct AdaptiveRsi *handle); + void wickra_adaptive_rsi_reset(struct AdaptiveRsi *handle); void wickra_adaptive_rsi_free(struct AdaptiveRsi *handle); @@ -1724,6 +1736,10 @@ double wickra_alma_update(struct Alma *handle, double value); void wickra_alma_batch(struct Alma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_alma_warmup_period(struct Alma *handle); + +bool wickra_alma_is_ready(struct Alma *handle); + void wickra_alma_reset(struct Alma *handle); void wickra_alma_free(struct Alma *handle); @@ -1737,6 +1753,10 @@ void wickra_anchored_rsi_batch(struct AnchoredRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_anchored_rsi_warmup_period(struct AnchoredRsi *handle); + +bool wickra_anchored_rsi_is_ready(struct AnchoredRsi *handle); + void wickra_anchored_rsi_reset(struct AnchoredRsi *handle); void wickra_anchored_rsi_free(struct AnchoredRsi *handle); @@ -1747,6 +1767,10 @@ double wickra_apo_update(struct Apo *handle, double value); void wickra_apo_batch(struct Apo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_apo_warmup_period(struct Apo *handle); + +bool wickra_apo_is_ready(struct Apo *handle); + void wickra_apo_reset(struct Apo *handle); void wickra_apo_free(struct Apo *handle); @@ -1760,6 +1784,10 @@ void wickra_autocorrelation_batch(struct Autocorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_autocorrelation_warmup_period(struct Autocorrelation *handle); + +bool wickra_autocorrelation_is_ready(struct Autocorrelation *handle); + void wickra_autocorrelation_reset(struct Autocorrelation *handle); void wickra_autocorrelation_free(struct Autocorrelation *handle); @@ -1775,6 +1803,10 @@ void wickra_autocorrelation_periodogram_batch(struct AutocorrelationPeriodogram double *out, uintptr_t n); +uintptr_t wickra_autocorrelation_periodogram_warmup_period(struct AutocorrelationPeriodogram *handle); + +bool wickra_autocorrelation_periodogram_is_ready(struct AutocorrelationPeriodogram *handle); + void wickra_autocorrelation_periodogram_reset(struct AutocorrelationPeriodogram *handle); void wickra_autocorrelation_periodogram_free(struct AutocorrelationPeriodogram *handle); @@ -1788,6 +1820,10 @@ void wickra_average_drawdown_batch(struct AverageDrawdown *handle, double *out, uintptr_t n); +uintptr_t wickra_average_drawdown_warmup_period(struct AverageDrawdown *handle); + +bool wickra_average_drawdown_is_ready(struct AverageDrawdown *handle); + void wickra_average_drawdown_reset(struct AverageDrawdown *handle); void wickra_average_drawdown_free(struct AverageDrawdown *handle); @@ -1801,6 +1837,10 @@ void wickra_bandpass_filter_batch(struct BandpassFilter *handle, double *out, uintptr_t n); +uintptr_t wickra_bandpass_filter_warmup_period(struct BandpassFilter *handle); + +bool wickra_bandpass_filter_is_ready(struct BandpassFilter *handle); + void wickra_bandpass_filter_reset(struct BandpassFilter *handle); void wickra_bandpass_filter_free(struct BandpassFilter *handle); @@ -1814,6 +1854,10 @@ void wickra_bipower_variation_batch(struct BipowerVariation *handle, double *out, uintptr_t n); +uintptr_t wickra_bipower_variation_warmup_period(struct BipowerVariation *handle); + +bool wickra_bipower_variation_is_ready(struct BipowerVariation *handle); + void wickra_bipower_variation_reset(struct BipowerVariation *handle); void wickra_bipower_variation_free(struct BipowerVariation *handle); @@ -1827,6 +1871,10 @@ void wickra_bollinger_bandwidth_batch(struct BollingerBandwidth *handle, double *out, uintptr_t n); +uintptr_t wickra_bollinger_bandwidth_warmup_period(struct BollingerBandwidth *handle); + +bool wickra_bollinger_bandwidth_is_ready(struct BollingerBandwidth *handle); + void wickra_bollinger_bandwidth_reset(struct BollingerBandwidth *handle); void wickra_bollinger_bandwidth_free(struct BollingerBandwidth *handle); @@ -1840,6 +1888,10 @@ void wickra_burke_ratio_batch(struct BurkeRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_burke_ratio_warmup_period(struct BurkeRatio *handle); + +bool wickra_burke_ratio_is_ready(struct BurkeRatio *handle); + void wickra_burke_ratio_reset(struct BurkeRatio *handle); void wickra_burke_ratio_free(struct BurkeRatio *handle); @@ -1853,6 +1905,10 @@ void wickra_calmar_ratio_batch(struct CalmarRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_calmar_ratio_warmup_period(struct CalmarRatio *handle); + +bool wickra_calmar_ratio_is_ready(struct CalmarRatio *handle); + void wickra_calmar_ratio_reset(struct CalmarRatio *handle); void wickra_calmar_ratio_free(struct CalmarRatio *handle); @@ -1866,6 +1922,10 @@ void wickra_center_of_gravity_batch(struct CenterOfGravity *handle, double *out, uintptr_t n); +uintptr_t wickra_center_of_gravity_warmup_period(struct CenterOfGravity *handle); + +bool wickra_center_of_gravity_is_ready(struct CenterOfGravity *handle); + void wickra_center_of_gravity_reset(struct CenterOfGravity *handle); void wickra_center_of_gravity_free(struct CenterOfGravity *handle); @@ -1876,6 +1936,10 @@ double wickra_cfo_update(struct Cfo *handle, double value); void wickra_cfo_batch(struct Cfo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_cfo_warmup_period(struct Cfo *handle); + +bool wickra_cfo_is_ready(struct Cfo *handle); + void wickra_cfo_reset(struct Cfo *handle); void wickra_cfo_free(struct Cfo *handle); @@ -1886,6 +1950,10 @@ double wickra_cmo_update(struct Cmo *handle, double value); void wickra_cmo_batch(struct Cmo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_cmo_warmup_period(struct Cmo *handle); + +bool wickra_cmo_is_ready(struct Cmo *handle); + void wickra_cmo_reset(struct Cmo *handle); void wickra_cmo_free(struct Cmo *handle); @@ -1899,6 +1967,10 @@ void wickra_coefficient_of_variation_batch(struct CoefficientOfVariation *handle double *out, uintptr_t n); +uintptr_t wickra_coefficient_of_variation_warmup_period(struct CoefficientOfVariation *handle); + +bool wickra_coefficient_of_variation_is_ready(struct CoefficientOfVariation *handle); + void wickra_coefficient_of_variation_reset(struct CoefficientOfVariation *handle); void wickra_coefficient_of_variation_free(struct CoefficientOfVariation *handle); @@ -1912,6 +1984,10 @@ void wickra_common_sense_ratio_batch(struct CommonSenseRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_common_sense_ratio_warmup_period(struct CommonSenseRatio *handle); + +bool wickra_common_sense_ratio_is_ready(struct CommonSenseRatio *handle); + void wickra_common_sense_ratio_reset(struct CommonSenseRatio *handle); void wickra_common_sense_ratio_free(struct CommonSenseRatio *handle); @@ -1926,6 +2002,10 @@ void wickra_conditional_value_at_risk_batch(struct ConditionalValueAtRisk *handl double *out, uintptr_t n); +uintptr_t wickra_conditional_value_at_risk_warmup_period(struct ConditionalValueAtRisk *handle); + +bool wickra_conditional_value_at_risk_is_ready(struct ConditionalValueAtRisk *handle); + void wickra_conditional_value_at_risk_reset(struct ConditionalValueAtRisk *handle); void wickra_conditional_value_at_risk_free(struct ConditionalValueAtRisk *handle); @@ -1941,6 +2021,10 @@ void wickra_connors_rsi_batch(struct ConnorsRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_connors_rsi_warmup_period(struct ConnorsRsi *handle); + +bool wickra_connors_rsi_is_ready(struct ConnorsRsi *handle); + void wickra_connors_rsi_reset(struct ConnorsRsi *handle); void wickra_connors_rsi_free(struct ConnorsRsi *handle); @@ -1953,6 +2037,10 @@ double wickra_coppock_update(struct Coppock *handle, double value); void wickra_coppock_batch(struct Coppock *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_coppock_warmup_period(struct Coppock *handle); + +bool wickra_coppock_is_ready(struct Coppock *handle); + void wickra_coppock_reset(struct Coppock *handle); void wickra_coppock_free(struct Coppock *handle); @@ -1967,6 +2055,10 @@ void wickra_correlation_trend_indicator_batch(struct CorrelationTrendIndicator * double *out, uintptr_t n); +uintptr_t wickra_correlation_trend_indicator_warmup_period(struct CorrelationTrendIndicator *handle); + +bool wickra_correlation_trend_indicator_is_ready(struct CorrelationTrendIndicator *handle); + void wickra_correlation_trend_indicator_reset(struct CorrelationTrendIndicator *handle); void wickra_correlation_trend_indicator_free(struct CorrelationTrendIndicator *handle); @@ -1980,6 +2072,10 @@ void wickra_cybernetic_cycle_batch(struct CyberneticCycle *handle, double *out, uintptr_t n); +uintptr_t wickra_cybernetic_cycle_warmup_period(struct CyberneticCycle *handle); + +bool wickra_cybernetic_cycle_is_ready(struct CyberneticCycle *handle); + void wickra_cybernetic_cycle_reset(struct CyberneticCycle *handle); void wickra_cybernetic_cycle_free(struct CyberneticCycle *handle); @@ -1990,6 +2086,10 @@ double wickra_decycler_update(struct Decycler *handle, double value); void wickra_decycler_batch(struct Decycler *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_decycler_warmup_period(struct Decycler *handle); + +bool wickra_decycler_is_ready(struct Decycler *handle); + void wickra_decycler_reset(struct Decycler *handle); void wickra_decycler_free(struct Decycler *handle); @@ -2003,6 +2103,10 @@ void wickra_decycler_oscillator_batch(struct DecyclerOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_decycler_oscillator_warmup_period(struct DecyclerOscillator *handle); + +bool wickra_decycler_oscillator_is_ready(struct DecyclerOscillator *handle); + void wickra_decycler_oscillator_reset(struct DecyclerOscillator *handle); void wickra_decycler_oscillator_free(struct DecyclerOscillator *handle); @@ -2013,6 +2117,10 @@ double wickra_dema_update(struct Dema *handle, double value); void wickra_dema_batch(struct Dema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_dema_warmup_period(struct Dema *handle); + +bool wickra_dema_is_ready(struct Dema *handle); + void wickra_dema_reset(struct Dema *handle); void wickra_dema_free(struct Dema *handle); @@ -2029,6 +2137,10 @@ void wickra_derivative_oscillator_batch(struct DerivativeOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_derivative_oscillator_warmup_period(struct DerivativeOscillator *handle); + +bool wickra_derivative_oscillator_is_ready(struct DerivativeOscillator *handle); + void wickra_derivative_oscillator_reset(struct DerivativeOscillator *handle); void wickra_derivative_oscillator_free(struct DerivativeOscillator *handle); @@ -2042,6 +2154,10 @@ void wickra_detrended_std_dev_batch(struct DetrendedStdDev *handle, double *out, uintptr_t n); +uintptr_t wickra_detrended_std_dev_warmup_period(struct DetrendedStdDev *handle); + +bool wickra_detrended_std_dev_is_ready(struct DetrendedStdDev *handle); + void wickra_detrended_std_dev_reset(struct DetrendedStdDev *handle); void wickra_detrended_std_dev_free(struct DetrendedStdDev *handle); @@ -2055,6 +2171,10 @@ void wickra_disparity_index_batch(struct DisparityIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_disparity_index_warmup_period(struct DisparityIndex *handle); + +bool wickra_disparity_index_is_ready(struct DisparityIndex *handle); + void wickra_disparity_index_reset(struct DisparityIndex *handle); void wickra_disparity_index_free(struct DisparityIndex *handle); @@ -2065,6 +2185,10 @@ double wickra_dpo_update(struct Dpo *handle, double value); void wickra_dpo_batch(struct Dpo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_dpo_warmup_period(struct Dpo *handle); + +bool wickra_dpo_is_ready(struct Dpo *handle); + void wickra_dpo_reset(struct Dpo *handle); void wickra_dpo_free(struct Dpo *handle); @@ -2078,6 +2202,10 @@ void wickra_drawdown_duration_batch(struct DrawdownDuration *handle, double *out, uintptr_t n); +uintptr_t wickra_drawdown_duration_warmup_period(struct DrawdownDuration *handle); + +bool wickra_drawdown_duration_is_ready(struct DrawdownDuration *handle); + void wickra_drawdown_duration_reset(struct DrawdownDuration *handle); void wickra_drawdown_duration_free(struct DrawdownDuration *handle); @@ -2091,6 +2219,10 @@ void wickra_dynamic_momentum_index_batch(struct DynamicMomentumIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_dynamic_momentum_index_warmup_period(struct DynamicMomentumIndex *handle); + +bool wickra_dynamic_momentum_index_is_ready(struct DynamicMomentumIndex *handle); + void wickra_dynamic_momentum_index_reset(struct DynamicMomentumIndex *handle); void wickra_dynamic_momentum_index_free(struct DynamicMomentumIndex *handle); @@ -2104,6 +2236,10 @@ void wickra_ehlers_stochastic_batch(struct EhlersStochastic *handle, double *out, uintptr_t n); +uintptr_t wickra_ehlers_stochastic_warmup_period(struct EhlersStochastic *handle); + +bool wickra_ehlers_stochastic_is_ready(struct EhlersStochastic *handle); + void wickra_ehlers_stochastic_reset(struct EhlersStochastic *handle); void wickra_ehlers_stochastic_free(struct EhlersStochastic *handle); @@ -2114,6 +2250,10 @@ double wickra_ehma_update(struct Ehma *handle, double value); void wickra_ehma_batch(struct Ehma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_ehma_warmup_period(struct Ehma *handle); + +bool wickra_ehma_is_ready(struct Ehma *handle); + void wickra_ehma_reset(struct Ehma *handle); void wickra_ehma_free(struct Ehma *handle); @@ -2130,6 +2270,10 @@ void wickra_elder_impulse_batch(struct ElderImpulse *handle, double *out, uintptr_t n); +uintptr_t wickra_elder_impulse_warmup_period(struct ElderImpulse *handle); + +bool wickra_elder_impulse_is_ready(struct ElderImpulse *handle); + void wickra_elder_impulse_reset(struct ElderImpulse *handle); void wickra_elder_impulse_free(struct ElderImpulse *handle); @@ -2140,6 +2284,10 @@ double wickra_ema_update(struct Ema *handle, double value); void wickra_ema_batch(struct Ema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_ema_warmup_period(struct Ema *handle); + +bool wickra_ema_is_ready(struct Ema *handle); + void wickra_ema_reset(struct Ema *handle); void wickra_ema_free(struct Ema *handle); @@ -2155,6 +2303,10 @@ void wickra_empirical_mode_decomposition_batch(struct EmpiricalModeDecomposition double *out, uintptr_t n); +uintptr_t wickra_empirical_mode_decomposition_warmup_period(struct EmpiricalModeDecomposition *handle); + +bool wickra_empirical_mode_decomposition_is_ready(struct EmpiricalModeDecomposition *handle); + void wickra_empirical_mode_decomposition_reset(struct EmpiricalModeDecomposition *handle); void wickra_empirical_mode_decomposition_free(struct EmpiricalModeDecomposition *handle); @@ -2169,6 +2321,10 @@ void wickra_even_better_sinewave_batch(struct EvenBetterSinewave *handle, double *out, uintptr_t n); +uintptr_t wickra_even_better_sinewave_warmup_period(struct EvenBetterSinewave *handle); + +bool wickra_even_better_sinewave_is_ready(struct EvenBetterSinewave *handle); + void wickra_even_better_sinewave_reset(struct EvenBetterSinewave *handle); void wickra_even_better_sinewave_free(struct EvenBetterSinewave *handle); @@ -2182,6 +2338,10 @@ void wickra_ewma_volatility_batch(struct EwmaVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_ewma_volatility_warmup_period(struct EwmaVolatility *handle); + +bool wickra_ewma_volatility_is_ready(struct EwmaVolatility *handle); + void wickra_ewma_volatility_reset(struct EwmaVolatility *handle); void wickra_ewma_volatility_free(struct EwmaVolatility *handle); @@ -2195,6 +2355,10 @@ void wickra_expectancy_batch(struct Expectancy *handle, double *out, uintptr_t n); +uintptr_t wickra_expectancy_warmup_period(struct Expectancy *handle); + +bool wickra_expectancy_is_ready(struct Expectancy *handle); + void wickra_expectancy_reset(struct Expectancy *handle); void wickra_expectancy_free(struct Expectancy *handle); @@ -2205,6 +2369,10 @@ double wickra_fama_update(struct Fama *handle, double value); void wickra_fama_batch(struct Fama *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_fama_warmup_period(struct Fama *handle); + +bool wickra_fama_is_ready(struct Fama *handle); + void wickra_fama_reset(struct Fama *handle); void wickra_fama_free(struct Fama *handle); @@ -2218,6 +2386,10 @@ void wickra_fisher_rsi_batch(struct FisherRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_fisher_rsi_warmup_period(struct FisherRsi *handle); + +bool wickra_fisher_rsi_is_ready(struct FisherRsi *handle); + void wickra_fisher_rsi_reset(struct FisherRsi *handle); void wickra_fisher_rsi_free(struct FisherRsi *handle); @@ -2231,6 +2403,10 @@ void wickra_fisher_transform_batch(struct FisherTransform *handle, double *out, uintptr_t n); +uintptr_t wickra_fisher_transform_warmup_period(struct FisherTransform *handle); + +bool wickra_fisher_transform_is_ready(struct FisherTransform *handle); + void wickra_fisher_transform_reset(struct FisherTransform *handle); void wickra_fisher_transform_free(struct FisherTransform *handle); @@ -2241,6 +2417,10 @@ double wickra_frama_update(struct Frama *handle, double value); void wickra_frama_batch(struct Frama *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_frama_warmup_period(struct Frama *handle); + +bool wickra_frama_is_ready(struct Frama *handle); + void wickra_frama_reset(struct Frama *handle); void wickra_frama_free(struct Frama *handle); @@ -2254,6 +2434,10 @@ void wickra_gain_loss_ratio_batch(struct GainLossRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_gain_loss_ratio_warmup_period(struct GainLossRatio *handle); + +bool wickra_gain_loss_ratio_is_ready(struct GainLossRatio *handle); + void wickra_gain_loss_ratio_reset(struct GainLossRatio *handle); void wickra_gain_loss_ratio_free(struct GainLossRatio *handle); @@ -2267,6 +2451,10 @@ void wickra_gain_to_pain_ratio_batch(struct GainToPainRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_gain_to_pain_ratio_warmup_period(struct GainToPainRatio *handle); + +bool wickra_gain_to_pain_ratio_is_ready(struct GainToPainRatio *handle); + void wickra_gain_to_pain_ratio_reset(struct GainToPainRatio *handle); void wickra_gain_to_pain_ratio_free(struct GainToPainRatio *handle); @@ -2277,6 +2465,10 @@ double wickra_garch11_update(struct Garch11 *handle, double value); void wickra_garch11_batch(struct Garch11 *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_garch11_warmup_period(struct Garch11 *handle); + +bool wickra_garch11_is_ready(struct Garch11 *handle); + void wickra_garch11_reset(struct Garch11 *handle); void wickra_garch11_free(struct Garch11 *handle); @@ -2290,6 +2482,10 @@ void wickra_generalized_dema_batch(struct GeneralizedDema *handle, double *out, uintptr_t n); +uintptr_t wickra_generalized_dema_warmup_period(struct GeneralizedDema *handle); + +bool wickra_generalized_dema_is_ready(struct GeneralizedDema *handle); + void wickra_generalized_dema_reset(struct GeneralizedDema *handle); void wickra_generalized_dema_free(struct GeneralizedDema *handle); @@ -2303,6 +2499,10 @@ void wickra_geometric_ma_batch(struct GeometricMa *handle, double *out, uintptr_t n); +uintptr_t wickra_geometric_ma_warmup_period(struct GeometricMa *handle); + +bool wickra_geometric_ma_is_ready(struct GeometricMa *handle); + void wickra_geometric_ma_reset(struct GeometricMa *handle); void wickra_geometric_ma_free(struct GeometricMa *handle); @@ -2316,6 +2516,10 @@ void wickra_highpass_filter_batch(struct HighpassFilter *handle, double *out, uintptr_t n); +uintptr_t wickra_highpass_filter_warmup_period(struct HighpassFilter *handle); + +bool wickra_highpass_filter_is_ready(struct HighpassFilter *handle); + void wickra_highpass_filter_reset(struct HighpassFilter *handle); void wickra_highpass_filter_free(struct HighpassFilter *handle); @@ -2329,6 +2533,10 @@ void wickra_hilbert_dominant_cycle_batch(struct HilbertDominantCycle *handle, double *out, uintptr_t n); +uintptr_t wickra_hilbert_dominant_cycle_warmup_period(struct HilbertDominantCycle *handle); + +bool wickra_hilbert_dominant_cycle_is_ready(struct HilbertDominantCycle *handle); + void wickra_hilbert_dominant_cycle_reset(struct HilbertDominantCycle *handle); void wickra_hilbert_dominant_cycle_free(struct HilbertDominantCycle *handle); @@ -2343,6 +2551,10 @@ void wickra_historical_volatility_batch(struct HistoricalVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_historical_volatility_warmup_period(struct HistoricalVolatility *handle); + +bool wickra_historical_volatility_is_ready(struct HistoricalVolatility *handle); + void wickra_historical_volatility_reset(struct HistoricalVolatility *handle); void wickra_historical_volatility_free(struct HistoricalVolatility *handle); @@ -2353,6 +2565,10 @@ double wickra_hma_update(struct Hma *handle, double value); void wickra_hma_batch(struct Hma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_hma_warmup_period(struct Hma *handle); + +bool wickra_hma_is_ready(struct Hma *handle); + void wickra_hma_reset(struct Hma *handle); void wickra_hma_free(struct Hma *handle); @@ -2366,6 +2582,10 @@ void wickra_holt_winters_batch(struct HoltWinters *handle, double *out, uintptr_t n); +uintptr_t wickra_holt_winters_warmup_period(struct HoltWinters *handle); + +bool wickra_holt_winters_is_ready(struct HoltWinters *handle); + void wickra_holt_winters_reset(struct HoltWinters *handle); void wickra_holt_winters_free(struct HoltWinters *handle); @@ -2379,6 +2599,10 @@ void wickra_ht_dc_phase_batch(struct HtDcPhase *handle, double *out, uintptr_t n); +uintptr_t wickra_ht_dc_phase_warmup_period(struct HtDcPhase *handle); + +bool wickra_ht_dc_phase_is_ready(struct HtDcPhase *handle); + void wickra_ht_dc_phase_reset(struct HtDcPhase *handle); void wickra_ht_dc_phase_free(struct HtDcPhase *handle); @@ -2392,6 +2616,10 @@ void wickra_ht_trend_mode_batch(struct HtTrendMode *handle, double *out, uintptr_t n); +uintptr_t wickra_ht_trend_mode_warmup_period(struct HtTrendMode *handle); + +bool wickra_ht_trend_mode_is_ready(struct HtTrendMode *handle); + void wickra_ht_trend_mode_reset(struct HtTrendMode *handle); void wickra_ht_trend_mode_free(struct HtTrendMode *handle); @@ -2405,6 +2633,10 @@ void wickra_hurst_exponent_batch(struct HurstExponent *handle, double *out, uintptr_t n); +uintptr_t wickra_hurst_exponent_warmup_period(struct HurstExponent *handle); + +bool wickra_hurst_exponent_is_ready(struct HurstExponent *handle); + void wickra_hurst_exponent_reset(struct HurstExponent *handle); void wickra_hurst_exponent_free(struct HurstExponent *handle); @@ -2418,6 +2650,10 @@ void wickra_instantaneous_trendline_batch(struct InstantaneousTrendline *handle, double *out, uintptr_t n); +uintptr_t wickra_instantaneous_trendline_warmup_period(struct InstantaneousTrendline *handle); + +bool wickra_instantaneous_trendline_is_ready(struct InstantaneousTrendline *handle); + void wickra_instantaneous_trendline_reset(struct InstantaneousTrendline *handle); void wickra_instantaneous_trendline_free(struct InstantaneousTrendline *handle); @@ -2431,6 +2667,10 @@ void wickra_inverse_fisher_transform_batch(struct InverseFisherTransform *handle double *out, uintptr_t n); +uintptr_t wickra_inverse_fisher_transform_warmup_period(struct InverseFisherTransform *handle); + +bool wickra_inverse_fisher_transform_is_ready(struct InverseFisherTransform *handle); + void wickra_inverse_fisher_transform_reset(struct InverseFisherTransform *handle); void wickra_inverse_fisher_transform_free(struct InverseFisherTransform *handle); @@ -2444,6 +2684,10 @@ void wickra_jarque_bera_batch(struct JarqueBera *handle, double *out, uintptr_t n); +uintptr_t wickra_jarque_bera_warmup_period(struct JarqueBera *handle); + +bool wickra_jarque_bera_is_ready(struct JarqueBera *handle); + void wickra_jarque_bera_reset(struct JarqueBera *handle); void wickra_jarque_bera_free(struct JarqueBera *handle); @@ -2454,6 +2698,10 @@ double wickra_jma_update(struct Jma *handle, double value); void wickra_jma_batch(struct Jma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_jma_warmup_period(struct Jma *handle); + +bool wickra_jma_is_ready(struct Jma *handle); + void wickra_jma_reset(struct Jma *handle); void wickra_jma_free(struct Jma *handle); @@ -2467,6 +2715,10 @@ void wickra_jump_indicator_batch(struct JumpIndicator *handle, double *out, uintptr_t n); +uintptr_t wickra_jump_indicator_warmup_period(struct JumpIndicator *handle); + +bool wickra_jump_indicator_is_ready(struct JumpIndicator *handle); + void wickra_jump_indicator_reset(struct JumpIndicator *handle); void wickra_jump_indicator_free(struct JumpIndicator *handle); @@ -2477,6 +2729,10 @@ double wickra_k_ratio_update(struct KRatio *handle, double value); void wickra_k_ratio_batch(struct KRatio *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_k_ratio_warmup_period(struct KRatio *handle); + +bool wickra_k_ratio_is_ready(struct KRatio *handle); + void wickra_k_ratio_reset(struct KRatio *handle); void wickra_k_ratio_free(struct KRatio *handle); @@ -2487,6 +2743,10 @@ double wickra_kama_update(struct Kama *handle, double value); void wickra_kama_batch(struct Kama *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_kama_warmup_period(struct Kama *handle); + +bool wickra_kama_is_ready(struct Kama *handle); + void wickra_kama_reset(struct Kama *handle); void wickra_kama_free(struct Kama *handle); @@ -2500,6 +2760,10 @@ void wickra_kelly_criterion_batch(struct KellyCriterion *handle, double *out, uintptr_t n); +uintptr_t wickra_kelly_criterion_warmup_period(struct KellyCriterion *handle); + +bool wickra_kelly_criterion_is_ready(struct KellyCriterion *handle); + void wickra_kelly_criterion_reset(struct KellyCriterion *handle); void wickra_kelly_criterion_free(struct KellyCriterion *handle); @@ -2510,6 +2774,10 @@ double wickra_kurtosis_update(struct Kurtosis *handle, double value); void wickra_kurtosis_batch(struct Kurtosis *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_kurtosis_warmup_period(struct Kurtosis *handle); + +bool wickra_kurtosis_is_ready(struct Kurtosis *handle); + void wickra_kurtosis_reset(struct Kurtosis *handle); void wickra_kurtosis_free(struct Kurtosis *handle); @@ -2523,6 +2791,10 @@ void wickra_laguerre_rsi_batch(struct LaguerreRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_laguerre_rsi_warmup_period(struct LaguerreRsi *handle); + +bool wickra_laguerre_rsi_is_ready(struct LaguerreRsi *handle); + void wickra_laguerre_rsi_reset(struct LaguerreRsi *handle); void wickra_laguerre_rsi_free(struct LaguerreRsi *handle); @@ -2536,6 +2808,10 @@ void wickra_linear_regression_batch(struct LinearRegression *handle, double *out, uintptr_t n); +uintptr_t wickra_linear_regression_warmup_period(struct LinearRegression *handle); + +bool wickra_linear_regression_is_ready(struct LinearRegression *handle); + void wickra_linear_regression_reset(struct LinearRegression *handle); void wickra_linear_regression_free(struct LinearRegression *handle); @@ -2549,6 +2825,10 @@ void wickra_lin_reg_angle_batch(struct LinRegAngle *handle, double *out, uintptr_t n); +uintptr_t wickra_lin_reg_angle_warmup_period(struct LinRegAngle *handle); + +bool wickra_lin_reg_angle_is_ready(struct LinRegAngle *handle); + void wickra_lin_reg_angle_reset(struct LinRegAngle *handle); void wickra_lin_reg_angle_free(struct LinRegAngle *handle); @@ -2562,6 +2842,10 @@ void wickra_lin_reg_intercept_batch(struct LinRegIntercept *handle, double *out, uintptr_t n); +uintptr_t wickra_lin_reg_intercept_warmup_period(struct LinRegIntercept *handle); + +bool wickra_lin_reg_intercept_is_ready(struct LinRegIntercept *handle); + void wickra_lin_reg_intercept_reset(struct LinRegIntercept *handle); void wickra_lin_reg_intercept_free(struct LinRegIntercept *handle); @@ -2575,6 +2859,10 @@ void wickra_lin_reg_slope_batch(struct LinRegSlope *handle, double *out, uintptr_t n); +uintptr_t wickra_lin_reg_slope_warmup_period(struct LinRegSlope *handle); + +bool wickra_lin_reg_slope_is_ready(struct LinRegSlope *handle); + void wickra_lin_reg_slope_reset(struct LinRegSlope *handle); void wickra_lin_reg_slope_free(struct LinRegSlope *handle); @@ -2588,6 +2876,10 @@ void wickra_log_return_batch(struct LogReturn *handle, double *out, uintptr_t n); +uintptr_t wickra_log_return_warmup_period(struct LogReturn *handle); + +bool wickra_log_return_is_ready(struct LogReturn *handle); + void wickra_log_return_reset(struct LogReturn *handle); void wickra_log_return_free(struct LogReturn *handle); @@ -2603,6 +2895,10 @@ void wickra_m2_measure_batch(struct M2Measure *handle, double *out, uintptr_t n); +uintptr_t wickra_m2_measure_warmup_period(struct M2Measure *handle); + +bool wickra_m2_measure_is_ready(struct M2Measure *handle); + void wickra_m2_measure_reset(struct M2Measure *handle); void wickra_m2_measure_free(struct M2Measure *handle); @@ -2616,6 +2912,10 @@ void wickra_macd_histogram_batch(struct MacdHistogram *handle, double *out, uintptr_t n); +uintptr_t wickra_macd_histogram_warmup_period(struct MacdHistogram *handle); + +bool wickra_macd_histogram_is_ready(struct MacdHistogram *handle); + void wickra_macd_histogram_reset(struct MacdHistogram *handle); void wickra_macd_histogram_free(struct MacdHistogram *handle); @@ -2629,6 +2929,10 @@ void wickra_martin_ratio_batch(struct MartinRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_martin_ratio_warmup_period(struct MartinRatio *handle); + +bool wickra_martin_ratio_is_ready(struct MartinRatio *handle); + void wickra_martin_ratio_reset(struct MartinRatio *handle); void wickra_martin_ratio_free(struct MartinRatio *handle); @@ -2642,6 +2946,10 @@ void wickra_max_drawdown_batch(struct MaxDrawdown *handle, double *out, uintptr_t n); +uintptr_t wickra_max_drawdown_warmup_period(struct MaxDrawdown *handle); + +bool wickra_max_drawdown_is_ready(struct MaxDrawdown *handle); + void wickra_max_drawdown_reset(struct MaxDrawdown *handle); void wickra_max_drawdown_free(struct MaxDrawdown *handle); @@ -2655,6 +2963,10 @@ void wickra_mc_ginley_dynamic_batch(struct McGinleyDynamic *handle, double *out, uintptr_t n); +uintptr_t wickra_mc_ginley_dynamic_warmup_period(struct McGinleyDynamic *handle); + +bool wickra_mc_ginley_dynamic_is_ready(struct McGinleyDynamic *handle); + void wickra_mc_ginley_dynamic_reset(struct McGinleyDynamic *handle); void wickra_mc_ginley_dynamic_free(struct McGinleyDynamic *handle); @@ -2669,6 +2981,10 @@ void wickra_median_absolute_deviation_batch(struct MedianAbsoluteDeviation *hand double *out, uintptr_t n); +uintptr_t wickra_median_absolute_deviation_warmup_period(struct MedianAbsoluteDeviation *handle); + +bool wickra_median_absolute_deviation_is_ready(struct MedianAbsoluteDeviation *handle); + void wickra_median_absolute_deviation_reset(struct MedianAbsoluteDeviation *handle); void wickra_median_absolute_deviation_free(struct MedianAbsoluteDeviation *handle); @@ -2679,6 +2995,10 @@ double wickra_median_ma_update(struct MedianMa *handle, double value); void wickra_median_ma_batch(struct MedianMa *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_median_ma_warmup_period(struct MedianMa *handle); + +bool wickra_median_ma_is_ready(struct MedianMa *handle); + void wickra_median_ma_reset(struct MedianMa *handle); void wickra_median_ma_free(struct MedianMa *handle); @@ -2689,6 +3009,10 @@ double wickra_mid_point_update(struct MidPoint *handle, double value); void wickra_mid_point_batch(struct MidPoint *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_mid_point_warmup_period(struct MidPoint *handle); + +bool wickra_mid_point_is_ready(struct MidPoint *handle); + void wickra_mid_point_reset(struct MidPoint *handle); void wickra_mid_point_free(struct MidPoint *handle); @@ -2699,6 +3023,10 @@ double wickra_mom_update(struct Mom *handle, double value); void wickra_mom_batch(struct Mom *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_mom_warmup_period(struct Mom *handle); + +bool wickra_mom_is_ready(struct Mom *handle); + void wickra_mom_reset(struct Mom *handle); void wickra_mom_free(struct Mom *handle); @@ -2712,6 +3040,10 @@ void wickra_omega_ratio_batch(struct OmegaRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_omega_ratio_warmup_period(struct OmegaRatio *handle); + +bool wickra_omega_ratio_is_ready(struct OmegaRatio *handle); + void wickra_omega_ratio_reset(struct OmegaRatio *handle); void wickra_omega_ratio_free(struct OmegaRatio *handle); @@ -2725,6 +3057,10 @@ void wickra_pain_index_batch(struct PainIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_pain_index_warmup_period(struct PainIndex *handle); + +bool wickra_pain_index_is_ready(struct PainIndex *handle); + void wickra_pain_index_reset(struct PainIndex *handle); void wickra_pain_index_free(struct PainIndex *handle); @@ -2735,6 +3071,10 @@ double wickra_percent_b_update(struct PercentB *handle, double value); void wickra_percent_b_batch(struct PercentB *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_percent_b_warmup_period(struct PercentB *handle); + +bool wickra_percent_b_is_ready(struct PercentB *handle); + void wickra_percent_b_reset(struct PercentB *handle); void wickra_percent_b_free(struct PercentB *handle); @@ -2748,6 +3088,10 @@ void wickra_percentage_trailing_stop_batch(struct PercentageTrailingStop *handle double *out, uintptr_t n); +uintptr_t wickra_percentage_trailing_stop_warmup_period(struct PercentageTrailingStop *handle); + +bool wickra_percentage_trailing_stop_is_ready(struct PercentageTrailingStop *handle); + void wickra_percentage_trailing_stop_reset(struct PercentageTrailingStop *handle); void wickra_percentage_trailing_stop_free(struct PercentageTrailingStop *handle); @@ -2758,6 +3102,10 @@ double wickra_pmo_update(struct Pmo *handle, double value); void wickra_pmo_batch(struct Pmo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_pmo_warmup_period(struct Pmo *handle); + +bool wickra_pmo_is_ready(struct Pmo *handle); + void wickra_pmo_reset(struct Pmo *handle); void wickra_pmo_free(struct Pmo *handle); @@ -2773,6 +3121,10 @@ void wickra_polarized_fractal_efficiency_batch(struct PolarizedFractalEfficiency double *out, uintptr_t n); +uintptr_t wickra_polarized_fractal_efficiency_warmup_period(struct PolarizedFractalEfficiency *handle); + +bool wickra_polarized_fractal_efficiency_is_ready(struct PolarizedFractalEfficiency *handle); + void wickra_polarized_fractal_efficiency_reset(struct PolarizedFractalEfficiency *handle); void wickra_polarized_fractal_efficiency_free(struct PolarizedFractalEfficiency *handle); @@ -2783,6 +3135,10 @@ double wickra_ppo_update(struct Ppo *handle, double value); void wickra_ppo_batch(struct Ppo *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_ppo_warmup_period(struct Ppo *handle); + +bool wickra_ppo_is_ready(struct Ppo *handle); + void wickra_ppo_reset(struct Ppo *handle); void wickra_ppo_free(struct Ppo *handle); @@ -2796,6 +3152,10 @@ void wickra_ppo_histogram_batch(struct PpoHistogram *handle, double *out, uintptr_t n); +uintptr_t wickra_ppo_histogram_warmup_period(struct PpoHistogram *handle); + +bool wickra_ppo_histogram_is_ready(struct PpoHistogram *handle); + void wickra_ppo_histogram_reset(struct PpoHistogram *handle); void wickra_ppo_histogram_free(struct PpoHistogram *handle); @@ -2809,6 +3169,10 @@ void wickra_profit_factor_batch(struct ProfitFactor *handle, double *out, uintptr_t n); +uintptr_t wickra_profit_factor_warmup_period(struct ProfitFactor *handle); + +bool wickra_profit_factor_is_ready(struct ProfitFactor *handle); + void wickra_profit_factor_reset(struct ProfitFactor *handle); void wickra_profit_factor_free(struct ProfitFactor *handle); @@ -2819,6 +3183,10 @@ double wickra_r_squared_update(struct RSquared *handle, double value); void wickra_r_squared_batch(struct RSquared *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_r_squared_warmup_period(struct RSquared *handle); + +bool wickra_r_squared_is_ready(struct RSquared *handle); + void wickra_r_squared_reset(struct RSquared *handle); void wickra_r_squared_free(struct RSquared *handle); @@ -2832,6 +3200,10 @@ void wickra_realized_volatility_batch(struct RealizedVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_realized_volatility_warmup_period(struct RealizedVolatility *handle); + +bool wickra_realized_volatility_is_ready(struct RealizedVolatility *handle); + void wickra_realized_volatility_reset(struct RealizedVolatility *handle); void wickra_realized_volatility_free(struct RealizedVolatility *handle); @@ -2845,6 +3217,10 @@ void wickra_recovery_factor_batch(struct RecoveryFactor *handle, double *out, uintptr_t n); +uintptr_t wickra_recovery_factor_warmup_period(struct RecoveryFactor *handle); + +bool wickra_recovery_factor_is_ready(struct RecoveryFactor *handle); + void wickra_recovery_factor_reset(struct RecoveryFactor *handle); void wickra_recovery_factor_free(struct RecoveryFactor *handle); @@ -2855,6 +3231,10 @@ double wickra_reflex_update(struct Reflex *handle, double value); void wickra_reflex_batch(struct Reflex *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_reflex_warmup_period(struct Reflex *handle); + +bool wickra_reflex_is_ready(struct Reflex *handle); + void wickra_reflex_reset(struct Reflex *handle); void wickra_reflex_free(struct Reflex *handle); @@ -2868,6 +3248,10 @@ void wickra_regime_label_batch(struct RegimeLabel *handle, double *out, uintptr_t n); +uintptr_t wickra_regime_label_warmup_period(struct RegimeLabel *handle); + +bool wickra_regime_label_is_ready(struct RegimeLabel *handle); + void wickra_regime_label_reset(struct RegimeLabel *handle); void wickra_regime_label_free(struct RegimeLabel *handle); @@ -2881,6 +3265,10 @@ void wickra_renko_trailing_stop_batch(struct RenkoTrailingStop *handle, double *out, uintptr_t n); +uintptr_t wickra_renko_trailing_stop_warmup_period(struct RenkoTrailingStop *handle); + +bool wickra_renko_trailing_stop_is_ready(struct RenkoTrailingStop *handle); + void wickra_renko_trailing_stop_reset(struct RenkoTrailingStop *handle); void wickra_renko_trailing_stop_free(struct RenkoTrailingStop *handle); @@ -2891,6 +3279,10 @@ double wickra_rmi_update(struct Rmi *handle, double value); void wickra_rmi_batch(struct Rmi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rmi_warmup_period(struct Rmi *handle); + +bool wickra_rmi_is_ready(struct Rmi *handle); + void wickra_rmi_reset(struct Rmi *handle); void wickra_rmi_free(struct Rmi *handle); @@ -2901,6 +3293,10 @@ double wickra_roc_update(struct Roc *handle, double value); void wickra_roc_batch(struct Roc *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_roc_warmup_period(struct Roc *handle); + +bool wickra_roc_is_ready(struct Roc *handle); + void wickra_roc_reset(struct Roc *handle); void wickra_roc_free(struct Roc *handle); @@ -2911,6 +3307,10 @@ double wickra_rocp_update(struct Rocp *handle, double value); void wickra_rocp_batch(struct Rocp *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rocp_warmup_period(struct Rocp *handle); + +bool wickra_rocp_is_ready(struct Rocp *handle); + void wickra_rocp_reset(struct Rocp *handle); void wickra_rocp_free(struct Rocp *handle); @@ -2921,6 +3321,10 @@ double wickra_rocr_update(struct Rocr *handle, double value); void wickra_rocr_batch(struct Rocr *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rocr_warmup_period(struct Rocr *handle); + +bool wickra_rocr_is_ready(struct Rocr *handle); + void wickra_rocr_reset(struct Rocr *handle); void wickra_rocr_free(struct Rocr *handle); @@ -2931,6 +3335,10 @@ double wickra_rocr100_update(struct Rocr100 *handle, double value); void wickra_rocr100_batch(struct Rocr100 *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rocr100_warmup_period(struct Rocr100 *handle); + +bool wickra_rocr100_is_ready(struct Rocr100 *handle); + void wickra_rocr100_reset(struct Rocr100 *handle); void wickra_rocr100_free(struct Rocr100 *handle); @@ -2944,6 +3352,10 @@ void wickra_rolling_iqr_batch(struct RollingIqr *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_iqr_warmup_period(struct RollingIqr *handle); + +bool wickra_rolling_iqr_is_ready(struct RollingIqr *handle); + void wickra_rolling_iqr_reset(struct RollingIqr *handle); void wickra_rolling_iqr_free(struct RollingIqr *handle); @@ -2957,6 +3369,10 @@ void wickra_rolling_min_max_scaler_batch(struct RollingMinMaxScaler *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_min_max_scaler_warmup_period(struct RollingMinMaxScaler *handle); + +bool wickra_rolling_min_max_scaler_is_ready(struct RollingMinMaxScaler *handle); + void wickra_rolling_min_max_scaler_reset(struct RollingMinMaxScaler *handle); void wickra_rolling_min_max_scaler_free(struct RollingMinMaxScaler *handle); @@ -2970,6 +3386,10 @@ void wickra_rolling_percentile_rank_batch(struct RollingPercentileRank *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_percentile_rank_warmup_period(struct RollingPercentileRank *handle); + +bool wickra_rolling_percentile_rank_is_ready(struct RollingPercentileRank *handle); + void wickra_rolling_percentile_rank_reset(struct RollingPercentileRank *handle); void wickra_rolling_percentile_rank_free(struct RollingPercentileRank *handle); @@ -2983,6 +3403,10 @@ void wickra_rolling_quantile_batch(struct RollingQuantile *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_quantile_warmup_period(struct RollingQuantile *handle); + +bool wickra_rolling_quantile_is_ready(struct RollingQuantile *handle); + void wickra_rolling_quantile_reset(struct RollingQuantile *handle); void wickra_rolling_quantile_free(struct RollingQuantile *handle); @@ -2996,6 +3420,10 @@ void wickra_roofing_filter_batch(struct RoofingFilter *handle, double *out, uintptr_t n); +uintptr_t wickra_roofing_filter_warmup_period(struct RoofingFilter *handle); + +bool wickra_roofing_filter_is_ready(struct RoofingFilter *handle); + void wickra_roofing_filter_reset(struct RoofingFilter *handle); void wickra_roofing_filter_free(struct RoofingFilter *handle); @@ -3006,6 +3434,10 @@ double wickra_rsi_update(struct Rsi *handle, double value); void wickra_rsi_batch(struct Rsi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rsi_warmup_period(struct Rsi *handle); + +bool wickra_rsi_is_ready(struct Rsi *handle); + void wickra_rsi_reset(struct Rsi *handle); void wickra_rsi_free(struct Rsi *handle); @@ -3016,6 +3448,10 @@ double wickra_rsx_update(struct Rsx *handle, double value); void wickra_rsx_batch(struct Rsx *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_rsx_warmup_period(struct Rsx *handle); + +bool wickra_rsx_is_ready(struct Rsx *handle); + void wickra_rsx_reset(struct Rsx *handle); void wickra_rsx_free(struct Rsx *handle); @@ -3029,6 +3465,10 @@ void wickra_rvi_volatility_batch(struct RviVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_rvi_volatility_warmup_period(struct RviVolatility *handle); + +bool wickra_rvi_volatility_is_ready(struct RviVolatility *handle); + void wickra_rvi_volatility_reset(struct RviVolatility *handle); void wickra_rvi_volatility_free(struct RviVolatility *handle); @@ -3042,6 +3482,10 @@ void wickra_sample_entropy_batch(struct SampleEntropy *handle, double *out, uintptr_t n); +uintptr_t wickra_sample_entropy_warmup_period(struct SampleEntropy *handle); + +bool wickra_sample_entropy_is_ready(struct SampleEntropy *handle); + void wickra_sample_entropy_reset(struct SampleEntropy *handle); void wickra_sample_entropy_free(struct SampleEntropy *handle); @@ -3055,6 +3499,10 @@ void wickra_shannon_entropy_batch(struct ShannonEntropy *handle, double *out, uintptr_t n); +uintptr_t wickra_shannon_entropy_warmup_period(struct ShannonEntropy *handle); + +bool wickra_shannon_entropy_is_ready(struct ShannonEntropy *handle); + void wickra_shannon_entropy_reset(struct ShannonEntropy *handle); void wickra_shannon_entropy_free(struct ShannonEntropy *handle); @@ -3068,6 +3516,10 @@ void wickra_sharpe_ratio_batch(struct SharpeRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_sharpe_ratio_warmup_period(struct SharpeRatio *handle); + +bool wickra_sharpe_ratio_is_ready(struct SharpeRatio *handle); + void wickra_sharpe_ratio_reset(struct SharpeRatio *handle); void wickra_sharpe_ratio_free(struct SharpeRatio *handle); @@ -3078,6 +3530,10 @@ double wickra_sine_wave_update(struct SineWave *handle, double value); void wickra_sine_wave_batch(struct SineWave *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_sine_wave_warmup_period(struct SineWave *handle); + +bool wickra_sine_wave_is_ready(struct SineWave *handle); + void wickra_sine_wave_reset(struct SineWave *handle); void wickra_sine_wave_free(struct SineWave *handle); @@ -3091,6 +3547,10 @@ void wickra_sine_weighted_ma_batch(struct SineWeightedMa *handle, double *out, uintptr_t n); +uintptr_t wickra_sine_weighted_ma_warmup_period(struct SineWeightedMa *handle); + +bool wickra_sine_weighted_ma_is_ready(struct SineWeightedMa *handle); + void wickra_sine_weighted_ma_reset(struct SineWeightedMa *handle); void wickra_sine_weighted_ma_free(struct SineWeightedMa *handle); @@ -3101,6 +3561,10 @@ double wickra_skewness_update(struct Skewness *handle, double value); void wickra_skewness_batch(struct Skewness *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_skewness_warmup_period(struct Skewness *handle); + +bool wickra_skewness_is_ready(struct Skewness *handle); + void wickra_skewness_reset(struct Skewness *handle); void wickra_skewness_free(struct Skewness *handle); @@ -3111,6 +3575,10 @@ double wickra_sma_update(struct Sma *handle, double value); void wickra_sma_batch(struct Sma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_sma_warmup_period(struct Sma *handle); + +bool wickra_sma_is_ready(struct Sma *handle); + void wickra_sma_reset(struct Sma *handle); void wickra_sma_free(struct Sma *handle); @@ -3121,6 +3589,10 @@ double wickra_smma_update(struct Smma *handle, double value); void wickra_smma_batch(struct Smma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_smma_warmup_period(struct Smma *handle); + +bool wickra_smma_is_ready(struct Smma *handle); + void wickra_smma_reset(struct Smma *handle); void wickra_smma_free(struct Smma *handle); @@ -3134,6 +3606,10 @@ void wickra_sortino_ratio_batch(struct SortinoRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_sortino_ratio_warmup_period(struct SortinoRatio *handle); + +bool wickra_sortino_ratio_is_ready(struct SortinoRatio *handle); + void wickra_sortino_ratio_reset(struct SortinoRatio *handle); void wickra_sortino_ratio_free(struct SortinoRatio *handle); @@ -3147,6 +3623,10 @@ void wickra_standard_error_batch(struct StandardError *handle, double *out, uintptr_t n); +uintptr_t wickra_standard_error_warmup_period(struct StandardError *handle); + +bool wickra_standard_error_is_ready(struct StandardError *handle); + void wickra_standard_error_reset(struct StandardError *handle); void wickra_standard_error_free(struct StandardError *handle); @@ -3157,6 +3637,10 @@ double wickra_stc_update(struct Stc *handle, double value); void wickra_stc_batch(struct Stc *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_stc_warmup_period(struct Stc *handle); + +bool wickra_stc_is_ready(struct Stc *handle); + void wickra_stc_reset(struct Stc *handle); void wickra_stc_free(struct Stc *handle); @@ -3167,6 +3651,10 @@ double wickra_std_dev_update(struct StdDev *handle, double value); void wickra_std_dev_batch(struct StdDev *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_std_dev_warmup_period(struct StdDev *handle); + +bool wickra_std_dev_is_ready(struct StdDev *handle); + void wickra_std_dev_reset(struct StdDev *handle); void wickra_std_dev_free(struct StdDev *handle); @@ -3180,6 +3668,10 @@ void wickra_step_trailing_stop_batch(struct StepTrailingStop *handle, double *out, uintptr_t n); +uintptr_t wickra_step_trailing_stop_warmup_period(struct StepTrailingStop *handle); + +bool wickra_step_trailing_stop_is_ready(struct StepTrailingStop *handle); + void wickra_step_trailing_stop_reset(struct StepTrailingStop *handle); void wickra_step_trailing_stop_free(struct StepTrailingStop *handle); @@ -3193,6 +3685,10 @@ void wickra_sterling_ratio_batch(struct SterlingRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_sterling_ratio_warmup_period(struct SterlingRatio *handle); + +bool wickra_sterling_ratio_is_ready(struct SterlingRatio *handle); + void wickra_sterling_ratio_reset(struct SterlingRatio *handle); void wickra_sterling_ratio_free(struct SterlingRatio *handle); @@ -3203,6 +3699,10 @@ double wickra_stoch_rsi_update(struct StochRsi *handle, double value); void wickra_stoch_rsi_batch(struct StochRsi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_stoch_rsi_warmup_period(struct StochRsi *handle); + +bool wickra_stoch_rsi_is_ready(struct StochRsi *handle); + void wickra_stoch_rsi_reset(struct StochRsi *handle); void wickra_stoch_rsi_free(struct StochRsi *handle); @@ -3216,6 +3716,10 @@ void wickra_super_smoother_batch(struct SuperSmoother *handle, double *out, uintptr_t n); +uintptr_t wickra_super_smoother_warmup_period(struct SuperSmoother *handle); + +bool wickra_super_smoother_is_ready(struct SuperSmoother *handle); + void wickra_super_smoother_reset(struct SuperSmoother *handle); void wickra_super_smoother_free(struct SuperSmoother *handle); @@ -3226,6 +3730,10 @@ double wickra_t3_update(struct T3 *handle, double value); void wickra_t3_batch(struct T3 *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_t3_warmup_period(struct T3 *handle); + +bool wickra_t3_is_ready(struct T3 *handle); + void wickra_t3_reset(struct T3 *handle); void wickra_t3_free(struct T3 *handle); @@ -3239,6 +3747,10 @@ void wickra_tail_ratio_batch(struct TailRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_tail_ratio_warmup_period(struct TailRatio *handle); + +bool wickra_tail_ratio_is_ready(struct TailRatio *handle); + void wickra_tail_ratio_reset(struct TailRatio *handle); void wickra_tail_ratio_free(struct TailRatio *handle); @@ -3249,6 +3761,10 @@ double wickra_tema_update(struct Tema *handle, double value); void wickra_tema_batch(struct Tema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tema_warmup_period(struct Tema *handle); + +bool wickra_tema_is_ready(struct Tema *handle); + void wickra_tema_reset(struct Tema *handle); void wickra_tema_free(struct Tema *handle); @@ -3259,6 +3775,10 @@ double wickra_tii_update(struct Tii *handle, double value); void wickra_tii_batch(struct Tii *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tii_warmup_period(struct Tii *handle); + +bool wickra_tii_is_ready(struct Tii *handle); + void wickra_tii_reset(struct Tii *handle); void wickra_tii_free(struct Tii *handle); @@ -3272,6 +3792,10 @@ void wickra_trend_label_batch(struct TrendLabel *handle, double *out, uintptr_t n); +uintptr_t wickra_trend_label_warmup_period(struct TrendLabel *handle); + +bool wickra_trend_label_is_ready(struct TrendLabel *handle); + void wickra_trend_label_reset(struct TrendLabel *handle); void wickra_trend_label_free(struct TrendLabel *handle); @@ -3285,6 +3809,10 @@ void wickra_trend_strength_index_batch(struct TrendStrengthIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_trend_strength_index_warmup_period(struct TrendStrengthIndex *handle); + +bool wickra_trend_strength_index_is_ready(struct TrendStrengthIndex *handle); + void wickra_trend_strength_index_reset(struct TrendStrengthIndex *handle); void wickra_trend_strength_index_free(struct TrendStrengthIndex *handle); @@ -3298,6 +3826,10 @@ void wickra_trendflex_batch(struct Trendflex *handle, double *out, uintptr_t n); +uintptr_t wickra_trendflex_warmup_period(struct Trendflex *handle); + +bool wickra_trendflex_is_ready(struct Trendflex *handle); + void wickra_trendflex_reset(struct Trendflex *handle); void wickra_trendflex_free(struct Trendflex *handle); @@ -3308,6 +3840,10 @@ double wickra_trima_update(struct Trima *handle, double value); void wickra_trima_batch(struct Trima *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_trima_warmup_period(struct Trima *handle); + +bool wickra_trima_is_ready(struct Trima *handle); + void wickra_trima_reset(struct Trima *handle); void wickra_trima_free(struct Trima *handle); @@ -3318,6 +3854,10 @@ double wickra_trix_update(struct Trix *handle, double value); void wickra_trix_batch(struct Trix *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_trix_warmup_period(struct Trix *handle); + +bool wickra_trix_is_ready(struct Trix *handle); + void wickra_trix_reset(struct Trix *handle); void wickra_trix_free(struct Trix *handle); @@ -3328,6 +3868,10 @@ double wickra_tsf_update(struct Tsf *handle, double value); void wickra_tsf_batch(struct Tsf *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tsf_warmup_period(struct Tsf *handle); + +bool wickra_tsf_is_ready(struct Tsf *handle); + void wickra_tsf_reset(struct Tsf *handle); void wickra_tsf_free(struct Tsf *handle); @@ -3341,6 +3885,10 @@ void wickra_tsf_oscillator_batch(struct TsfOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_tsf_oscillator_warmup_period(struct TsfOscillator *handle); + +bool wickra_tsf_oscillator_is_ready(struct TsfOscillator *handle); + void wickra_tsf_oscillator_reset(struct TsfOscillator *handle); void wickra_tsf_oscillator_free(struct TsfOscillator *handle); @@ -3351,6 +3899,10 @@ double wickra_tsi_update(struct Tsi *handle, double value); void wickra_tsi_batch(struct Tsi *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_tsi_warmup_period(struct Tsi *handle); + +bool wickra_tsi_is_ready(struct Tsi *handle); + void wickra_tsi_reset(struct Tsi *handle); void wickra_tsi_free(struct Tsi *handle); @@ -3364,6 +3916,10 @@ void wickra_ulcer_index_batch(struct UlcerIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_ulcer_index_warmup_period(struct UlcerIndex *handle); + +bool wickra_ulcer_index_is_ready(struct UlcerIndex *handle); + void wickra_ulcer_index_reset(struct UlcerIndex *handle); void wickra_ulcer_index_free(struct UlcerIndex *handle); @@ -3377,6 +3933,10 @@ void wickra_universal_oscillator_batch(struct UniversalOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_universal_oscillator_warmup_period(struct UniversalOscillator *handle); + +bool wickra_universal_oscillator_is_ready(struct UniversalOscillator *handle); + void wickra_universal_oscillator_reset(struct UniversalOscillator *handle); void wickra_universal_oscillator_free(struct UniversalOscillator *handle); @@ -3390,6 +3950,10 @@ void wickra_upside_potential_ratio_batch(struct UpsidePotentialRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_upside_potential_ratio_warmup_period(struct UpsidePotentialRatio *handle); + +bool wickra_upside_potential_ratio_is_ready(struct UpsidePotentialRatio *handle); + void wickra_upside_potential_ratio_reset(struct UpsidePotentialRatio *handle); void wickra_upside_potential_ratio_free(struct UpsidePotentialRatio *handle); @@ -3403,6 +3967,10 @@ void wickra_value_at_risk_batch(struct ValueAtRisk *handle, double *out, uintptr_t n); +uintptr_t wickra_value_at_risk_warmup_period(struct ValueAtRisk *handle); + +bool wickra_value_at_risk_is_ready(struct ValueAtRisk *handle); + void wickra_value_at_risk_reset(struct ValueAtRisk *handle); void wickra_value_at_risk_free(struct ValueAtRisk *handle); @@ -3413,6 +3981,10 @@ double wickra_variance_update(struct Variance *handle, double value); void wickra_variance_batch(struct Variance *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_variance_warmup_period(struct Variance *handle); + +bool wickra_variance_is_ready(struct Variance *handle); + void wickra_variance_reset(struct Variance *handle); void wickra_variance_free(struct Variance *handle); @@ -3427,6 +3999,10 @@ void wickra_vertical_horizontal_filter_batch(struct VerticalHorizontalFilter *ha double *out, uintptr_t n); +uintptr_t wickra_vertical_horizontal_filter_warmup_period(struct VerticalHorizontalFilter *handle); + +bool wickra_vertical_horizontal_filter_is_ready(struct VerticalHorizontalFilter *handle); + void wickra_vertical_horizontal_filter_reset(struct VerticalHorizontalFilter *handle); void wickra_vertical_horizontal_filter_free(struct VerticalHorizontalFilter *handle); @@ -3437,6 +4013,10 @@ double wickra_vidya_update(struct Vidya *handle, double value); void wickra_vidya_batch(struct Vidya *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_vidya_warmup_period(struct Vidya *handle); + +bool wickra_vidya_is_ready(struct Vidya *handle); + void wickra_vidya_reset(struct Vidya *handle); void wickra_vidya_free(struct Vidya *handle); @@ -3451,6 +4031,10 @@ void wickra_volatility_of_volatility_batch(struct VolatilityOfVolatility *handle double *out, uintptr_t n); +uintptr_t wickra_volatility_of_volatility_warmup_period(struct VolatilityOfVolatility *handle); + +bool wickra_volatility_of_volatility_is_ready(struct VolatilityOfVolatility *handle); + void wickra_volatility_of_volatility_reset(struct VolatilityOfVolatility *handle); void wickra_volatility_of_volatility_free(struct VolatilityOfVolatility *handle); @@ -3461,6 +4045,10 @@ double wickra_wave_pm_update(struct WavePm *handle, double value); void wickra_wave_pm_batch(struct WavePm *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_wave_pm_warmup_period(struct WavePm *handle); + +bool wickra_wave_pm_is_ready(struct WavePm *handle); + void wickra_wave_pm_reset(struct WavePm *handle); void wickra_wave_pm_free(struct WavePm *handle); @@ -3471,6 +4059,10 @@ double wickra_win_rate_update(struct WinRate *handle, double value); void wickra_win_rate_batch(struct WinRate *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_win_rate_warmup_period(struct WinRate *handle); + +bool wickra_win_rate_is_ready(struct WinRate *handle); + void wickra_win_rate_reset(struct WinRate *handle); void wickra_win_rate_free(struct WinRate *handle); @@ -3481,6 +4073,10 @@ double wickra_wma_update(struct Wma *handle, double value); void wickra_wma_batch(struct Wma *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_wma_warmup_period(struct Wma *handle); + +bool wickra_wma_is_ready(struct Wma *handle); + void wickra_wma_reset(struct Wma *handle); void wickra_wma_free(struct Wma *handle); @@ -3491,6 +4087,10 @@ double wickra_z_score_update(struct ZScore *handle, double value); void wickra_z_score_batch(struct ZScore *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_z_score_warmup_period(struct ZScore *handle); + +bool wickra_z_score_is_ready(struct ZScore *handle); + void wickra_z_score_reset(struct ZScore *handle); void wickra_z_score_free(struct ZScore *handle); @@ -3501,6 +4101,10 @@ double wickra_zlema_update(struct Zlema *handle, double value); void wickra_zlema_batch(struct Zlema *handle, const double *input, double *out, uintptr_t n); +uintptr_t wickra_zlema_warmup_period(struct Zlema *handle); + +bool wickra_zlema_is_ready(struct Zlema *handle); + void wickra_zlema_reset(struct Zlema *handle); void wickra_zlema_free(struct Zlema *handle); @@ -3515,6 +4119,10 @@ void wickra_alpha_batch(struct Alpha *handle, double *out, uintptr_t n); +uintptr_t wickra_alpha_warmup_period(struct Alpha *handle); + +bool wickra_alpha_is_ready(struct Alpha *handle); + void wickra_alpha_reset(struct Alpha *handle); void wickra_alpha_free(struct Alpha *handle); @@ -3529,6 +4137,10 @@ void wickra_beta_batch(struct Beta *handle, double *out, uintptr_t n); +uintptr_t wickra_beta_warmup_period(struct Beta *handle); + +bool wickra_beta_is_ready(struct Beta *handle); + void wickra_beta_reset(struct Beta *handle); void wickra_beta_free(struct Beta *handle); @@ -3543,6 +4155,10 @@ void wickra_beta_neutral_spread_batch(struct BetaNeutralSpread *handle, double *out, uintptr_t n); +uintptr_t wickra_beta_neutral_spread_warmup_period(struct BetaNeutralSpread *handle); + +bool wickra_beta_neutral_spread_is_ready(struct BetaNeutralSpread *handle); + void wickra_beta_neutral_spread_reset(struct BetaNeutralSpread *handle); void wickra_beta_neutral_spread_free(struct BetaNeutralSpread *handle); @@ -3557,6 +4173,10 @@ void wickra_distance_ssd_batch(struct DistanceSsd *handle, double *out, uintptr_t n); +uintptr_t wickra_distance_ssd_warmup_period(struct DistanceSsd *handle); + +bool wickra_distance_ssd_is_ready(struct DistanceSsd *handle); + void wickra_distance_ssd_reset(struct DistanceSsd *handle); void wickra_distance_ssd_free(struct DistanceSsd *handle); @@ -3571,6 +4191,10 @@ void wickra_granger_causality_batch(struct GrangerCausality *handle, double *out, uintptr_t n); +uintptr_t wickra_granger_causality_warmup_period(struct GrangerCausality *handle); + +bool wickra_granger_causality_is_ready(struct GrangerCausality *handle); + void wickra_granger_causality_reset(struct GrangerCausality *handle); void wickra_granger_causality_free(struct GrangerCausality *handle); @@ -3587,6 +4211,10 @@ void wickra_hasbrouck_information_share_batch(struct HasbrouckInformationShare * double *out, uintptr_t n); +uintptr_t wickra_hasbrouck_information_share_warmup_period(struct HasbrouckInformationShare *handle); + +bool wickra_hasbrouck_information_share_is_ready(struct HasbrouckInformationShare *handle); + void wickra_hasbrouck_information_share_reset(struct HasbrouckInformationShare *handle); void wickra_hasbrouck_information_share_free(struct HasbrouckInformationShare *handle); @@ -3601,6 +4229,10 @@ void wickra_information_ratio_batch(struct InformationRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_information_ratio_warmup_period(struct InformationRatio *handle); + +bool wickra_information_ratio_is_ready(struct InformationRatio *handle); + void wickra_information_ratio_reset(struct InformationRatio *handle); void wickra_information_ratio_free(struct InformationRatio *handle); @@ -3615,6 +4247,10 @@ void wickra_kendall_tau_batch(struct KendallTau *handle, double *out, uintptr_t n); +uintptr_t wickra_kendall_tau_warmup_period(struct KendallTau *handle); + +bool wickra_kendall_tau_is_ready(struct KendallTau *handle); + void wickra_kendall_tau_reset(struct KendallTau *handle); void wickra_kendall_tau_free(struct KendallTau *handle); @@ -3629,6 +4265,10 @@ void wickra_ou_half_life_batch(struct OuHalfLife *handle, double *out, uintptr_t n); +uintptr_t wickra_ou_half_life_warmup_period(struct OuHalfLife *handle); + +bool wickra_ou_half_life_is_ready(struct OuHalfLife *handle); + void wickra_ou_half_life_reset(struct OuHalfLife *handle); void wickra_ou_half_life_free(struct OuHalfLife *handle); @@ -3643,6 +4283,10 @@ void wickra_pair_spread_z_score_batch(struct PairSpreadZScore *handle, double *out, uintptr_t n); +uintptr_t wickra_pair_spread_z_score_warmup_period(struct PairSpreadZScore *handle); + +bool wickra_pair_spread_z_score_is_ready(struct PairSpreadZScore *handle); + void wickra_pair_spread_z_score_reset(struct PairSpreadZScore *handle); void wickra_pair_spread_z_score_free(struct PairSpreadZScore *handle); @@ -3657,6 +4301,10 @@ void wickra_pairwise_beta_batch(struct PairwiseBeta *handle, double *out, uintptr_t n); +uintptr_t wickra_pairwise_beta_warmup_period(struct PairwiseBeta *handle); + +bool wickra_pairwise_beta_is_ready(struct PairwiseBeta *handle); + void wickra_pairwise_beta_reset(struct PairwiseBeta *handle); void wickra_pairwise_beta_free(struct PairwiseBeta *handle); @@ -3671,6 +4319,10 @@ void wickra_pearson_correlation_batch(struct PearsonCorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_pearson_correlation_warmup_period(struct PearsonCorrelation *handle); + +bool wickra_pearson_correlation_is_ready(struct PearsonCorrelation *handle); + void wickra_pearson_correlation_reset(struct PearsonCorrelation *handle); void wickra_pearson_correlation_free(struct PearsonCorrelation *handle); @@ -3685,6 +4337,10 @@ void wickra_rolling_correlation_batch(struct RollingCorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_correlation_warmup_period(struct RollingCorrelation *handle); + +bool wickra_rolling_correlation_is_ready(struct RollingCorrelation *handle); + void wickra_rolling_correlation_reset(struct RollingCorrelation *handle); void wickra_rolling_correlation_free(struct RollingCorrelation *handle); @@ -3699,6 +4355,10 @@ void wickra_rolling_covariance_batch(struct RollingCovariance *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_covariance_warmup_period(struct RollingCovariance *handle); + +bool wickra_rolling_covariance_is_ready(struct RollingCovariance *handle); + void wickra_rolling_covariance_reset(struct RollingCovariance *handle); void wickra_rolling_covariance_free(struct RollingCovariance *handle); @@ -3713,6 +4373,10 @@ void wickra_spearman_correlation_batch(struct SpearmanCorrelation *handle, double *out, uintptr_t n); +uintptr_t wickra_spearman_correlation_warmup_period(struct SpearmanCorrelation *handle); + +bool wickra_spearman_correlation_is_ready(struct SpearmanCorrelation *handle); + void wickra_spearman_correlation_reset(struct SpearmanCorrelation *handle); void wickra_spearman_correlation_free(struct SpearmanCorrelation *handle); @@ -3729,6 +4393,10 @@ void wickra_spread_ar1_coefficient_batch(struct SpreadAr1Coefficient *handle, double *out, uintptr_t n); +uintptr_t wickra_spread_ar1_coefficient_warmup_period(struct SpreadAr1Coefficient *handle); + +bool wickra_spread_ar1_coefficient_is_ready(struct SpreadAr1Coefficient *handle); + void wickra_spread_ar1_coefficient_reset(struct SpreadAr1Coefficient *handle); void wickra_spread_ar1_coefficient_free(struct SpreadAr1Coefficient *handle); @@ -3743,6 +4411,10 @@ void wickra_spread_hurst_batch(struct SpreadHurst *handle, double *out, uintptr_t n); +uintptr_t wickra_spread_hurst_warmup_period(struct SpreadHurst *handle); + +bool wickra_spread_hurst_is_ready(struct SpreadHurst *handle); + void wickra_spread_hurst_reset(struct SpreadHurst *handle); void wickra_spread_hurst_free(struct SpreadHurst *handle); @@ -3757,6 +4429,10 @@ void wickra_treynor_ratio_batch(struct TreynorRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_treynor_ratio_warmup_period(struct TreynorRatio *handle); + +bool wickra_treynor_ratio_is_ready(struct TreynorRatio *handle); + void wickra_treynor_ratio_reset(struct TreynorRatio *handle); void wickra_treynor_ratio_free(struct TreynorRatio *handle); @@ -3771,6 +4447,10 @@ void wickra_variance_ratio_batch(struct VarianceRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_variance_ratio_warmup_period(struct VarianceRatio *handle); + +bool wickra_variance_ratio_is_ready(struct VarianceRatio *handle); + void wickra_variance_ratio_reset(struct VarianceRatio *handle); void wickra_variance_ratio_free(struct VarianceRatio *handle); @@ -3795,6 +4475,10 @@ void wickra_abandoned_baby_batch(struct AbandonedBaby *handle, double *out, uintptr_t n); +uintptr_t wickra_abandoned_baby_warmup_period(struct AbandonedBaby *handle); + +bool wickra_abandoned_baby_is_ready(struct AbandonedBaby *handle); + void wickra_abandoned_baby_reset(struct AbandonedBaby *handle); void wickra_abandoned_baby_free(struct AbandonedBaby *handle); @@ -3819,6 +4503,10 @@ void wickra_abcd_batch(struct Abcd *handle, double *out, uintptr_t n); +uintptr_t wickra_abcd_warmup_period(struct Abcd *handle); + +bool wickra_abcd_is_ready(struct Abcd *handle); + void wickra_abcd_reset(struct Abcd *handle); void wickra_abcd_free(struct Abcd *handle); @@ -3845,6 +4533,10 @@ void wickra_accelerator_oscillator_batch(struct AcceleratorOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_accelerator_oscillator_warmup_period(struct AcceleratorOscillator *handle); + +bool wickra_accelerator_oscillator_is_ready(struct AcceleratorOscillator *handle); + void wickra_accelerator_oscillator_reset(struct AcceleratorOscillator *handle); void wickra_accelerator_oscillator_free(struct AcceleratorOscillator *handle); @@ -3869,6 +4561,10 @@ void wickra_ad_oscillator_batch(struct AdOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_ad_oscillator_warmup_period(struct AdOscillator *handle); + +bool wickra_ad_oscillator_is_ready(struct AdOscillator *handle); + void wickra_ad_oscillator_reset(struct AdOscillator *handle); void wickra_ad_oscillator_free(struct AdOscillator *handle); @@ -3893,6 +4589,10 @@ void wickra_adaptive_cci_batch(struct AdaptiveCci *handle, double *out, uintptr_t n); +uintptr_t wickra_adaptive_cci_warmup_period(struct AdaptiveCci *handle); + +bool wickra_adaptive_cci_is_ready(struct AdaptiveCci *handle); + void wickra_adaptive_cci_reset(struct AdaptiveCci *handle); void wickra_adaptive_cci_free(struct AdaptiveCci *handle); @@ -3917,6 +4617,10 @@ void wickra_adl_batch(struct Adl *handle, double *out, uintptr_t n); +uintptr_t wickra_adl_warmup_period(struct Adl *handle); + +bool wickra_adl_is_ready(struct Adl *handle); + void wickra_adl_reset(struct Adl *handle); void wickra_adl_free(struct Adl *handle); @@ -3941,6 +4645,10 @@ void wickra_advance_block_batch(struct AdvanceBlock *handle, double *out, uintptr_t n); +uintptr_t wickra_advance_block_warmup_period(struct AdvanceBlock *handle); + +bool wickra_advance_block_is_ready(struct AdvanceBlock *handle); + void wickra_advance_block_reset(struct AdvanceBlock *handle); void wickra_advance_block_free(struct AdvanceBlock *handle); @@ -3965,6 +4673,10 @@ void wickra_adxr_batch(struct Adxr *handle, double *out, uintptr_t n); +uintptr_t wickra_adxr_warmup_period(struct Adxr *handle); + +bool wickra_adxr_is_ready(struct Adxr *handle); + void wickra_adxr_reset(struct Adxr *handle); void wickra_adxr_free(struct Adxr *handle); @@ -3989,6 +4701,10 @@ void wickra_anchored_vwap_batch(struct AnchoredVwap *handle, double *out, uintptr_t n); +uintptr_t wickra_anchored_vwap_warmup_period(struct AnchoredVwap *handle); + +bool wickra_anchored_vwap_is_ready(struct AnchoredVwap *handle); + void wickra_anchored_vwap_reset(struct AnchoredVwap *handle); void wickra_anchored_vwap_free(struct AnchoredVwap *handle); @@ -4013,6 +4729,10 @@ void wickra_aroon_oscillator_batch(struct AroonOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_aroon_oscillator_warmup_period(struct AroonOscillator *handle); + +bool wickra_aroon_oscillator_is_ready(struct AroonOscillator *handle); + void wickra_aroon_oscillator_reset(struct AroonOscillator *handle); void wickra_aroon_oscillator_free(struct AroonOscillator *handle); @@ -4037,6 +4757,10 @@ void wickra_atr_batch(struct Atr *handle, double *out, uintptr_t n); +uintptr_t wickra_atr_warmup_period(struct Atr *handle); + +bool wickra_atr_is_ready(struct Atr *handle); + void wickra_atr_reset(struct Atr *handle); void wickra_atr_free(struct Atr *handle); @@ -4061,6 +4785,10 @@ void wickra_atr_trailing_stop_batch(struct AtrTrailingStop *handle, double *out, uintptr_t n); +uintptr_t wickra_atr_trailing_stop_warmup_period(struct AtrTrailingStop *handle); + +bool wickra_atr_trailing_stop_is_ready(struct AtrTrailingStop *handle); + void wickra_atr_trailing_stop_reset(struct AtrTrailingStop *handle); void wickra_atr_trailing_stop_free(struct AtrTrailingStop *handle); @@ -4086,6 +4814,10 @@ void wickra_average_daily_range_batch(struct AverageDailyRange *handle, double *out, uintptr_t n); +uintptr_t wickra_average_daily_range_warmup_period(struct AverageDailyRange *handle); + +bool wickra_average_daily_range_is_ready(struct AverageDailyRange *handle); + void wickra_average_daily_range_reset(struct AverageDailyRange *handle); void wickra_average_daily_range_free(struct AverageDailyRange *handle); @@ -4110,6 +4842,10 @@ void wickra_avg_price_batch(struct AvgPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_avg_price_warmup_period(struct AvgPrice *handle); + +bool wickra_avg_price_is_ready(struct AvgPrice *handle); + void wickra_avg_price_reset(struct AvgPrice *handle); void wickra_avg_price_free(struct AvgPrice *handle); @@ -4134,6 +4870,10 @@ void wickra_awesome_oscillator_batch(struct AwesomeOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_awesome_oscillator_warmup_period(struct AwesomeOscillator *handle); + +bool wickra_awesome_oscillator_is_ready(struct AwesomeOscillator *handle); + void wickra_awesome_oscillator_reset(struct AwesomeOscillator *handle); void wickra_awesome_oscillator_free(struct AwesomeOscillator *handle); @@ -4160,6 +4900,10 @@ void wickra_awesome_oscillator_histogram_batch(struct AwesomeOscillatorHistogram double *out, uintptr_t n); +uintptr_t wickra_awesome_oscillator_histogram_warmup_period(struct AwesomeOscillatorHistogram *handle); + +bool wickra_awesome_oscillator_histogram_is_ready(struct AwesomeOscillatorHistogram *handle); + void wickra_awesome_oscillator_histogram_reset(struct AwesomeOscillatorHistogram *handle); void wickra_awesome_oscillator_histogram_free(struct AwesomeOscillatorHistogram *handle); @@ -4184,6 +4928,10 @@ void wickra_balance_of_power_batch(struct BalanceOfPower *handle, double *out, uintptr_t n); +uintptr_t wickra_balance_of_power_warmup_period(struct BalanceOfPower *handle); + +bool wickra_balance_of_power_is_ready(struct BalanceOfPower *handle); + void wickra_balance_of_power_reset(struct BalanceOfPower *handle); void wickra_balance_of_power_free(struct BalanceOfPower *handle); @@ -4208,6 +4956,10 @@ void wickra_bat_batch(struct Bat *handle, double *out, uintptr_t n); +uintptr_t wickra_bat_warmup_period(struct Bat *handle); + +bool wickra_bat_is_ready(struct Bat *handle); + void wickra_bat_reset(struct Bat *handle); void wickra_bat_free(struct Bat *handle); @@ -4232,6 +4984,10 @@ void wickra_belt_hold_batch(struct BeltHold *handle, double *out, uintptr_t n); +uintptr_t wickra_belt_hold_warmup_period(struct BeltHold *handle); + +bool wickra_belt_hold_is_ready(struct BeltHold *handle); + void wickra_belt_hold_reset(struct BeltHold *handle); void wickra_belt_hold_free(struct BeltHold *handle); @@ -4256,6 +5012,10 @@ void wickra_better_volume_batch(struct BetterVolume *handle, double *out, uintptr_t n); +uintptr_t wickra_better_volume_warmup_period(struct BetterVolume *handle); + +bool wickra_better_volume_is_ready(struct BetterVolume *handle); + void wickra_better_volume_reset(struct BetterVolume *handle); void wickra_better_volume_free(struct BetterVolume *handle); @@ -4280,6 +5040,10 @@ void wickra_body_size_pct_batch(struct BodySizePct *handle, double *out, uintptr_t n); +uintptr_t wickra_body_size_pct_warmup_period(struct BodySizePct *handle); + +bool wickra_body_size_pct_is_ready(struct BodySizePct *handle); + void wickra_body_size_pct_reset(struct BodySizePct *handle); void wickra_body_size_pct_free(struct BodySizePct *handle); @@ -4304,6 +5068,10 @@ void wickra_breakaway_batch(struct Breakaway *handle, double *out, uintptr_t n); +uintptr_t wickra_breakaway_warmup_period(struct Breakaway *handle); + +bool wickra_breakaway_is_ready(struct Breakaway *handle); + void wickra_breakaway_reset(struct Breakaway *handle); void wickra_breakaway_free(struct Breakaway *handle); @@ -4328,6 +5096,10 @@ void wickra_butterfly_batch(struct Butterfly *handle, double *out, uintptr_t n); +uintptr_t wickra_butterfly_warmup_period(struct Butterfly *handle); + +bool wickra_butterfly_is_ready(struct Butterfly *handle); + void wickra_butterfly_reset(struct Butterfly *handle); void wickra_butterfly_free(struct Butterfly *handle); @@ -4352,6 +5124,10 @@ void wickra_cci_batch(struct Cci *handle, double *out, uintptr_t n); +uintptr_t wickra_cci_warmup_period(struct Cci *handle); + +bool wickra_cci_is_ready(struct Cci *handle); + void wickra_cci_reset(struct Cci *handle); void wickra_cci_free(struct Cci *handle); @@ -4376,6 +5152,10 @@ void wickra_chaikin_oscillator_batch(struct ChaikinOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_chaikin_oscillator_warmup_period(struct ChaikinOscillator *handle); + +bool wickra_chaikin_oscillator_is_ready(struct ChaikinOscillator *handle); + void wickra_chaikin_oscillator_reset(struct ChaikinOscillator *handle); void wickra_chaikin_oscillator_free(struct ChaikinOscillator *handle); @@ -4400,6 +5180,10 @@ void wickra_chaikin_volatility_batch(struct ChaikinVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_chaikin_volatility_warmup_period(struct ChaikinVolatility *handle); + +bool wickra_chaikin_volatility_is_ready(struct ChaikinVolatility *handle); + void wickra_chaikin_volatility_reset(struct ChaikinVolatility *handle); void wickra_chaikin_volatility_free(struct ChaikinVolatility *handle); @@ -4424,6 +5208,10 @@ void wickra_choppiness_index_batch(struct ChoppinessIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_choppiness_index_warmup_period(struct ChoppinessIndex *handle); + +bool wickra_choppiness_index_is_ready(struct ChoppinessIndex *handle); + void wickra_choppiness_index_reset(struct ChoppinessIndex *handle); void wickra_choppiness_index_free(struct ChoppinessIndex *handle); @@ -4448,6 +5236,10 @@ void wickra_close_vs_open_batch(struct CloseVsOpen *handle, double *out, uintptr_t n); +uintptr_t wickra_close_vs_open_warmup_period(struct CloseVsOpen *handle); + +bool wickra_close_vs_open_is_ready(struct CloseVsOpen *handle); + void wickra_close_vs_open_reset(struct CloseVsOpen *handle); void wickra_close_vs_open_free(struct CloseVsOpen *handle); @@ -4472,6 +5264,10 @@ void wickra_closing_marubozu_batch(struct ClosingMarubozu *handle, double *out, uintptr_t n); +uintptr_t wickra_closing_marubozu_warmup_period(struct ClosingMarubozu *handle); + +bool wickra_closing_marubozu_is_ready(struct ClosingMarubozu *handle); + void wickra_closing_marubozu_reset(struct ClosingMarubozu *handle); void wickra_closing_marubozu_free(struct ClosingMarubozu *handle); @@ -4496,6 +5292,10 @@ void wickra_chaikin_money_flow_batch(struct ChaikinMoneyFlow *handle, double *out, uintptr_t n); +uintptr_t wickra_chaikin_money_flow_warmup_period(struct ChaikinMoneyFlow *handle); + +bool wickra_chaikin_money_flow_is_ready(struct ChaikinMoneyFlow *handle); + void wickra_chaikin_money_flow_reset(struct ChaikinMoneyFlow *handle); void wickra_chaikin_money_flow_free(struct ChaikinMoneyFlow *handle); @@ -4520,6 +5320,10 @@ void wickra_concealing_baby_swallow_batch(struct ConcealingBabySwallow *handle, double *out, uintptr_t n); +uintptr_t wickra_concealing_baby_swallow_warmup_period(struct ConcealingBabySwallow *handle); + +bool wickra_concealing_baby_swallow_is_ready(struct ConcealingBabySwallow *handle); + void wickra_concealing_baby_swallow_reset(struct ConcealingBabySwallow *handle); void wickra_concealing_baby_swallow_free(struct ConcealingBabySwallow *handle); @@ -4544,6 +5348,10 @@ void wickra_counterattack_batch(struct Counterattack *handle, double *out, uintptr_t n); +uintptr_t wickra_counterattack_warmup_period(struct Counterattack *handle); + +bool wickra_counterattack_is_ready(struct Counterattack *handle); + void wickra_counterattack_reset(struct Counterattack *handle); void wickra_counterattack_free(struct Counterattack *handle); @@ -4568,6 +5376,10 @@ void wickra_crab_batch(struct Crab *handle, double *out, uintptr_t n); +uintptr_t wickra_crab_warmup_period(struct Crab *handle); + +bool wickra_crab_is_ready(struct Crab *handle); + void wickra_crab_reset(struct Crab *handle); void wickra_crab_free(struct Crab *handle); @@ -4592,6 +5404,10 @@ void wickra_cup_and_handle_batch(struct CupAndHandle *handle, double *out, uintptr_t n); +uintptr_t wickra_cup_and_handle_warmup_period(struct CupAndHandle *handle); + +bool wickra_cup_and_handle_is_ready(struct CupAndHandle *handle); + void wickra_cup_and_handle_reset(struct CupAndHandle *handle); void wickra_cup_and_handle_free(struct CupAndHandle *handle); @@ -4616,6 +5432,10 @@ void wickra_cypher_batch(struct Cypher *handle, double *out, uintptr_t n); +uintptr_t wickra_cypher_warmup_period(struct Cypher *handle); + +bool wickra_cypher_is_ready(struct Cypher *handle); + void wickra_cypher_reset(struct Cypher *handle); void wickra_cypher_free(struct Cypher *handle); @@ -4640,6 +5460,10 @@ void wickra_demand_index_batch(struct DemandIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_demand_index_warmup_period(struct DemandIndex *handle); + +bool wickra_demand_index_is_ready(struct DemandIndex *handle); + void wickra_demand_index_reset(struct DemandIndex *handle); void wickra_demand_index_free(struct DemandIndex *handle); @@ -4664,6 +5488,10 @@ void wickra_doji_batch(struct Doji *handle, double *out, uintptr_t n); +uintptr_t wickra_doji_warmup_period(struct Doji *handle); + +bool wickra_doji_is_ready(struct Doji *handle); + void wickra_doji_reset(struct Doji *handle); void wickra_doji_free(struct Doji *handle); @@ -4688,6 +5516,10 @@ void wickra_doji_star_batch(struct DojiStar *handle, double *out, uintptr_t n); +uintptr_t wickra_doji_star_warmup_period(struct DojiStar *handle); + +bool wickra_doji_star_is_ready(struct DojiStar *handle); + void wickra_doji_star_reset(struct DojiStar *handle); void wickra_doji_star_free(struct DojiStar *handle); @@ -4712,6 +5544,10 @@ void wickra_double_top_bottom_batch(struct DoubleTopBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_double_top_bottom_warmup_period(struct DoubleTopBottom *handle); + +bool wickra_double_top_bottom_is_ready(struct DoubleTopBottom *handle); + void wickra_double_top_bottom_reset(struct DoubleTopBottom *handle); void wickra_double_top_bottom_free(struct DoubleTopBottom *handle); @@ -4736,6 +5572,10 @@ void wickra_downside_gap_three_methods_batch(struct DownsideGapThreeMethods *han double *out, uintptr_t n); +uintptr_t wickra_downside_gap_three_methods_warmup_period(struct DownsideGapThreeMethods *handle); + +bool wickra_downside_gap_three_methods_is_ready(struct DownsideGapThreeMethods *handle); + void wickra_downside_gap_three_methods_reset(struct DownsideGapThreeMethods *handle); void wickra_downside_gap_three_methods_free(struct DownsideGapThreeMethods *handle); @@ -4760,6 +5600,10 @@ void wickra_dragonfly_doji_batch(struct DragonflyDoji *handle, double *out, uintptr_t n); +uintptr_t wickra_dragonfly_doji_warmup_period(struct DragonflyDoji *handle); + +bool wickra_dragonfly_doji_is_ready(struct DragonflyDoji *handle); + void wickra_dragonfly_doji_reset(struct DragonflyDoji *handle); void wickra_dragonfly_doji_free(struct DragonflyDoji *handle); @@ -4784,6 +5628,10 @@ void wickra_dumpling_top_batch(struct DumplingTop *handle, double *out, uintptr_t n); +uintptr_t wickra_dumpling_top_warmup_period(struct DumplingTop *handle); + +bool wickra_dumpling_top_is_ready(struct DumplingTop *handle); + void wickra_dumpling_top_reset(struct DumplingTop *handle); void wickra_dumpling_top_free(struct DumplingTop *handle); @@ -4808,6 +5656,10 @@ void wickra_dx_batch(struct Dx *handle, double *out, uintptr_t n); +uintptr_t wickra_dx_warmup_period(struct Dx *handle); + +bool wickra_dx_is_ready(struct Dx *handle); + void wickra_dx_reset(struct Dx *handle); void wickra_dx_free(struct Dx *handle); @@ -4832,6 +5684,10 @@ void wickra_ease_of_movement_batch(struct EaseOfMovement *handle, double *out, uintptr_t n); +uintptr_t wickra_ease_of_movement_warmup_period(struct EaseOfMovement *handle); + +bool wickra_ease_of_movement_is_ready(struct EaseOfMovement *handle); + void wickra_ease_of_movement_reset(struct EaseOfMovement *handle); void wickra_ease_of_movement_free(struct EaseOfMovement *handle); @@ -4856,6 +5712,10 @@ void wickra_engulfing_batch(struct Engulfing *handle, double *out, uintptr_t n); +uintptr_t wickra_engulfing_warmup_period(struct Engulfing *handle); + +bool wickra_engulfing_is_ready(struct Engulfing *handle); + void wickra_engulfing_reset(struct Engulfing *handle); void wickra_engulfing_free(struct Engulfing *handle); @@ -4880,6 +5740,10 @@ void wickra_evening_doji_star_batch(struct EveningDojiStar *handle, double *out, uintptr_t n); +uintptr_t wickra_evening_doji_star_warmup_period(struct EveningDojiStar *handle); + +bool wickra_evening_doji_star_is_ready(struct EveningDojiStar *handle); + void wickra_evening_doji_star_reset(struct EveningDojiStar *handle); void wickra_evening_doji_star_free(struct EveningDojiStar *handle); @@ -4904,6 +5768,10 @@ void wickra_evwma_batch(struct Evwma *handle, double *out, uintptr_t n); +uintptr_t wickra_evwma_warmup_period(struct Evwma *handle); + +bool wickra_evwma_is_ready(struct Evwma *handle); + void wickra_evwma_reset(struct Evwma *handle); void wickra_evwma_free(struct Evwma *handle); @@ -4928,6 +5796,10 @@ void wickra_falling_three_methods_batch(struct FallingThreeMethods *handle, double *out, uintptr_t n); +uintptr_t wickra_falling_three_methods_warmup_period(struct FallingThreeMethods *handle); + +bool wickra_falling_three_methods_is_ready(struct FallingThreeMethods *handle); + void wickra_falling_three_methods_reset(struct FallingThreeMethods *handle); void wickra_falling_three_methods_free(struct FallingThreeMethods *handle); @@ -4952,6 +5824,10 @@ void wickra_flag_pennant_batch(struct FlagPennant *handle, double *out, uintptr_t n); +uintptr_t wickra_flag_pennant_warmup_period(struct FlagPennant *handle); + +bool wickra_flag_pennant_is_ready(struct FlagPennant *handle); + void wickra_flag_pennant_reset(struct FlagPennant *handle); void wickra_flag_pennant_free(struct FlagPennant *handle); @@ -4976,6 +5852,10 @@ void wickra_force_index_batch(struct ForceIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_force_index_warmup_period(struct ForceIndex *handle); + +bool wickra_force_index_is_ready(struct ForceIndex *handle); + void wickra_force_index_reset(struct ForceIndex *handle); void wickra_force_index_free(struct ForceIndex *handle); @@ -5000,6 +5880,10 @@ void wickra_fry_pan_bottom_batch(struct FryPanBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_fry_pan_bottom_warmup_period(struct FryPanBottom *handle); + +bool wickra_fry_pan_bottom_is_ready(struct FryPanBottom *handle); + void wickra_fry_pan_bottom_reset(struct FryPanBottom *handle); void wickra_fry_pan_bottom_free(struct FryPanBottom *handle); @@ -5024,6 +5908,10 @@ void wickra_gap_side_by_side_white_batch(struct GapSideBySideWhite *handle, double *out, uintptr_t n); +uintptr_t wickra_gap_side_by_side_white_warmup_period(struct GapSideBySideWhite *handle); + +bool wickra_gap_side_by_side_white_is_ready(struct GapSideBySideWhite *handle); + void wickra_gap_side_by_side_white_reset(struct GapSideBySideWhite *handle); void wickra_gap_side_by_side_white_free(struct GapSideBySideWhite *handle); @@ -5049,6 +5937,10 @@ void wickra_garman_klass_volatility_batch(struct GarmanKlassVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_garman_klass_volatility_warmup_period(struct GarmanKlassVolatility *handle); + +bool wickra_garman_klass_volatility_is_ready(struct GarmanKlassVolatility *handle); + void wickra_garman_klass_volatility_reset(struct GarmanKlassVolatility *handle); void wickra_garman_klass_volatility_free(struct GarmanKlassVolatility *handle); @@ -5073,6 +5965,10 @@ void wickra_gartley_batch(struct Gartley *handle, double *out, uintptr_t n); +uintptr_t wickra_gartley_warmup_period(struct Gartley *handle); + +bool wickra_gartley_is_ready(struct Gartley *handle); + void wickra_gartley_reset(struct Gartley *handle); void wickra_gartley_free(struct Gartley *handle); @@ -5097,6 +5993,10 @@ void wickra_gravestone_doji_batch(struct GravestoneDoji *handle, double *out, uintptr_t n); +uintptr_t wickra_gravestone_doji_warmup_period(struct GravestoneDoji *handle); + +bool wickra_gravestone_doji_is_ready(struct GravestoneDoji *handle); + void wickra_gravestone_doji_reset(struct GravestoneDoji *handle); void wickra_gravestone_doji_free(struct GravestoneDoji *handle); @@ -5121,6 +6021,10 @@ void wickra_hammer_batch(struct Hammer *handle, double *out, uintptr_t n); +uintptr_t wickra_hammer_warmup_period(struct Hammer *handle); + +bool wickra_hammer_is_ready(struct Hammer *handle); + void wickra_hammer_reset(struct Hammer *handle); void wickra_hammer_free(struct Hammer *handle); @@ -5145,6 +6049,10 @@ void wickra_hanging_man_batch(struct HangingMan *handle, double *out, uintptr_t n); +uintptr_t wickra_hanging_man_warmup_period(struct HangingMan *handle); + +bool wickra_hanging_man_is_ready(struct HangingMan *handle); + void wickra_hanging_man_reset(struct HangingMan *handle); void wickra_hanging_man_free(struct HangingMan *handle); @@ -5169,6 +6077,10 @@ void wickra_harami_batch(struct Harami *handle, double *out, uintptr_t n); +uintptr_t wickra_harami_warmup_period(struct Harami *handle); + +bool wickra_harami_is_ready(struct Harami *handle); + void wickra_harami_reset(struct Harami *handle); void wickra_harami_free(struct Harami *handle); @@ -5193,6 +6105,10 @@ void wickra_harami_cross_batch(struct HaramiCross *handle, double *out, uintptr_t n); +uintptr_t wickra_harami_cross_warmup_period(struct HaramiCross *handle); + +bool wickra_harami_cross_is_ready(struct HaramiCross *handle); + void wickra_harami_cross_reset(struct HaramiCross *handle); void wickra_harami_cross_free(struct HaramiCross *handle); @@ -5217,6 +6133,10 @@ void wickra_head_and_shoulders_batch(struct HeadAndShoulders *handle, double *out, uintptr_t n); +uintptr_t wickra_head_and_shoulders_warmup_period(struct HeadAndShoulders *handle); + +bool wickra_head_and_shoulders_is_ready(struct HeadAndShoulders *handle); + void wickra_head_and_shoulders_reset(struct HeadAndShoulders *handle); void wickra_head_and_shoulders_free(struct HeadAndShoulders *handle); @@ -5241,6 +6161,10 @@ void wickra_heikin_ashi_oscillator_batch(struct HeikinAshiOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_heikin_ashi_oscillator_warmup_period(struct HeikinAshiOscillator *handle); + +bool wickra_heikin_ashi_oscillator_is_ready(struct HeikinAshiOscillator *handle); + void wickra_heikin_ashi_oscillator_reset(struct HeikinAshiOscillator *handle); void wickra_heikin_ashi_oscillator_free(struct HeikinAshiOscillator *handle); @@ -5265,6 +6189,10 @@ void wickra_high_low_range_batch(struct HighLowRange *handle, double *out, uintptr_t n); +uintptr_t wickra_high_low_range_warmup_period(struct HighLowRange *handle); + +bool wickra_high_low_range_is_ready(struct HighLowRange *handle); + void wickra_high_low_range_reset(struct HighLowRange *handle); void wickra_high_low_range_free(struct HighLowRange *handle); @@ -5289,6 +6217,10 @@ void wickra_high_wave_batch(struct HighWave *handle, double *out, uintptr_t n); +uintptr_t wickra_high_wave_warmup_period(struct HighWave *handle); + +bool wickra_high_wave_is_ready(struct HighWave *handle); + void wickra_high_wave_reset(struct HighWave *handle); void wickra_high_wave_free(struct HighWave *handle); @@ -5313,6 +6245,10 @@ void wickra_hikkake_batch(struct Hikkake *handle, double *out, uintptr_t n); +uintptr_t wickra_hikkake_warmup_period(struct Hikkake *handle); + +bool wickra_hikkake_is_ready(struct Hikkake *handle); + void wickra_hikkake_reset(struct Hikkake *handle); void wickra_hikkake_free(struct Hikkake *handle); @@ -5337,6 +6273,10 @@ void wickra_hikkake_modified_batch(struct HikkakeModified *handle, double *out, uintptr_t n); +uintptr_t wickra_hikkake_modified_warmup_period(struct HikkakeModified *handle); + +bool wickra_hikkake_modified_is_ready(struct HikkakeModified *handle); + void wickra_hikkake_modified_reset(struct HikkakeModified *handle); void wickra_hikkake_modified_free(struct HikkakeModified *handle); @@ -5361,6 +6301,10 @@ void wickra_hi_lo_activator_batch(struct HiLoActivator *handle, double *out, uintptr_t n); +uintptr_t wickra_hi_lo_activator_warmup_period(struct HiLoActivator *handle); + +bool wickra_hi_lo_activator_is_ready(struct HiLoActivator *handle); + void wickra_hi_lo_activator_reset(struct HiLoActivator *handle); void wickra_hi_lo_activator_free(struct HiLoActivator *handle); @@ -5385,6 +6329,10 @@ void wickra_homing_pigeon_batch(struct HomingPigeon *handle, double *out, uintptr_t n); +uintptr_t wickra_homing_pigeon_warmup_period(struct HomingPigeon *handle); + +bool wickra_homing_pigeon_is_ready(struct HomingPigeon *handle); + void wickra_homing_pigeon_reset(struct HomingPigeon *handle); void wickra_homing_pigeon_free(struct HomingPigeon *handle); @@ -5409,6 +6357,10 @@ void wickra_identical_three_crows_batch(struct IdenticalThreeCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_identical_three_crows_warmup_period(struct IdenticalThreeCrows *handle); + +bool wickra_identical_three_crows_is_ready(struct IdenticalThreeCrows *handle); + void wickra_identical_three_crows_reset(struct IdenticalThreeCrows *handle); void wickra_identical_three_crows_free(struct IdenticalThreeCrows *handle); @@ -5433,6 +6385,10 @@ void wickra_in_neck_batch(struct InNeck *handle, double *out, uintptr_t n); +uintptr_t wickra_in_neck_warmup_period(struct InNeck *handle); + +bool wickra_in_neck_is_ready(struct InNeck *handle); + void wickra_in_neck_reset(struct InNeck *handle); void wickra_in_neck_free(struct InNeck *handle); @@ -5457,6 +6413,10 @@ void wickra_inertia_batch(struct Inertia *handle, double *out, uintptr_t n); +uintptr_t wickra_inertia_warmup_period(struct Inertia *handle); + +bool wickra_inertia_is_ready(struct Inertia *handle); + void wickra_inertia_reset(struct Inertia *handle); void wickra_inertia_free(struct Inertia *handle); @@ -5481,6 +6441,10 @@ void wickra_intraday_intensity_batch(struct IntradayIntensity *handle, double *out, uintptr_t n); +uintptr_t wickra_intraday_intensity_warmup_period(struct IntradayIntensity *handle); + +bool wickra_intraday_intensity_is_ready(struct IntradayIntensity *handle); + void wickra_intraday_intensity_reset(struct IntradayIntensity *handle); void wickra_intraday_intensity_free(struct IntradayIntensity *handle); @@ -5505,6 +6469,10 @@ void wickra_intraday_momentum_index_batch(struct IntradayMomentumIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_intraday_momentum_index_warmup_period(struct IntradayMomentumIndex *handle); + +bool wickra_intraday_momentum_index_is_ready(struct IntradayMomentumIndex *handle); + void wickra_intraday_momentum_index_reset(struct IntradayMomentumIndex *handle); void wickra_intraday_momentum_index_free(struct IntradayMomentumIndex *handle); @@ -5529,6 +6497,10 @@ void wickra_inverted_hammer_batch(struct InvertedHammer *handle, double *out, uintptr_t n); +uintptr_t wickra_inverted_hammer_warmup_period(struct InvertedHammer *handle); + +bool wickra_inverted_hammer_is_ready(struct InvertedHammer *handle); + void wickra_inverted_hammer_reset(struct InvertedHammer *handle); void wickra_inverted_hammer_free(struct InvertedHammer *handle); @@ -5553,6 +6525,10 @@ void wickra_kicking_batch(struct Kicking *handle, double *out, uintptr_t n); +uintptr_t wickra_kicking_warmup_period(struct Kicking *handle); + +bool wickra_kicking_is_ready(struct Kicking *handle); + void wickra_kicking_reset(struct Kicking *handle); void wickra_kicking_free(struct Kicking *handle); @@ -5577,6 +6553,10 @@ void wickra_kicking_by_length_batch(struct KickingByLength *handle, double *out, uintptr_t n); +uintptr_t wickra_kicking_by_length_warmup_period(struct KickingByLength *handle); + +bool wickra_kicking_by_length_is_ready(struct KickingByLength *handle); + void wickra_kicking_by_length_reset(struct KickingByLength *handle); void wickra_kicking_by_length_free(struct KickingByLength *handle); @@ -5601,6 +6581,10 @@ void wickra_kvo_batch(struct Kvo *handle, double *out, uintptr_t n); +uintptr_t wickra_kvo_warmup_period(struct Kvo *handle); + +bool wickra_kvo_is_ready(struct Kvo *handle); + void wickra_kvo_reset(struct Kvo *handle); void wickra_kvo_free(struct Kvo *handle); @@ -5625,6 +6609,10 @@ void wickra_ladder_bottom_batch(struct LadderBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_ladder_bottom_warmup_period(struct LadderBottom *handle); + +bool wickra_ladder_bottom_is_ready(struct LadderBottom *handle); + void wickra_ladder_bottom_reset(struct LadderBottom *handle); void wickra_ladder_bottom_free(struct LadderBottom *handle); @@ -5649,6 +6637,10 @@ void wickra_long_legged_doji_batch(struct LongLeggedDoji *handle, double *out, uintptr_t n); +uintptr_t wickra_long_legged_doji_warmup_period(struct LongLeggedDoji *handle); + +bool wickra_long_legged_doji_is_ready(struct LongLeggedDoji *handle); + void wickra_long_legged_doji_reset(struct LongLeggedDoji *handle); void wickra_long_legged_doji_free(struct LongLeggedDoji *handle); @@ -5673,6 +6665,10 @@ void wickra_long_line_batch(struct LongLine *handle, double *out, uintptr_t n); +uintptr_t wickra_long_line_warmup_period(struct LongLine *handle); + +bool wickra_long_line_is_ready(struct LongLine *handle); + void wickra_long_line_reset(struct LongLine *handle); void wickra_long_line_free(struct LongLine *handle); @@ -5697,6 +6693,10 @@ void wickra_market_facilitation_index_batch(struct MarketFacilitationIndex *hand double *out, uintptr_t n); +uintptr_t wickra_market_facilitation_index_warmup_period(struct MarketFacilitationIndex *handle); + +bool wickra_market_facilitation_index_is_ready(struct MarketFacilitationIndex *handle); + void wickra_market_facilitation_index_reset(struct MarketFacilitationIndex *handle); void wickra_market_facilitation_index_free(struct MarketFacilitationIndex *handle); @@ -5721,6 +6721,10 @@ void wickra_marubozu_batch(struct Marubozu *handle, double *out, uintptr_t n); +uintptr_t wickra_marubozu_warmup_period(struct Marubozu *handle); + +bool wickra_marubozu_is_ready(struct Marubozu *handle); + void wickra_marubozu_reset(struct Marubozu *handle); void wickra_marubozu_free(struct Marubozu *handle); @@ -5745,6 +6749,10 @@ void wickra_mass_index_batch(struct MassIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_mass_index_warmup_period(struct MassIndex *handle); + +bool wickra_mass_index_is_ready(struct MassIndex *handle); + void wickra_mass_index_reset(struct MassIndex *handle); void wickra_mass_index_free(struct MassIndex *handle); @@ -5769,6 +6777,10 @@ void wickra_mat_hold_batch(struct MatHold *handle, double *out, uintptr_t n); +uintptr_t wickra_mat_hold_warmup_period(struct MatHold *handle); + +bool wickra_mat_hold_is_ready(struct MatHold *handle); + void wickra_mat_hold_reset(struct MatHold *handle); void wickra_mat_hold_free(struct MatHold *handle); @@ -5793,6 +6805,10 @@ void wickra_matching_low_batch(struct MatchingLow *handle, double *out, uintptr_t n); +uintptr_t wickra_matching_low_warmup_period(struct MatchingLow *handle); + +bool wickra_matching_low_is_ready(struct MatchingLow *handle); + void wickra_matching_low_reset(struct MatchingLow *handle); void wickra_matching_low_free(struct MatchingLow *handle); @@ -5817,6 +6833,10 @@ void wickra_median_price_batch(struct MedianPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_median_price_warmup_period(struct MedianPrice *handle); + +bool wickra_median_price_is_ready(struct MedianPrice *handle); + void wickra_median_price_reset(struct MedianPrice *handle); void wickra_median_price_free(struct MedianPrice *handle); @@ -5841,6 +6861,10 @@ void wickra_mfi_batch(struct Mfi *handle, double *out, uintptr_t n); +uintptr_t wickra_mfi_warmup_period(struct Mfi *handle); + +bool wickra_mfi_is_ready(struct Mfi *handle); + void wickra_mfi_reset(struct Mfi *handle); void wickra_mfi_free(struct Mfi *handle); @@ -5865,6 +6889,10 @@ void wickra_mid_price_batch(struct MidPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_mid_price_warmup_period(struct MidPrice *handle); + +bool wickra_mid_price_is_ready(struct MidPrice *handle); + void wickra_mid_price_reset(struct MidPrice *handle); void wickra_mid_price_free(struct MidPrice *handle); @@ -5889,6 +6917,10 @@ void wickra_minus_di_batch(struct MinusDi *handle, double *out, uintptr_t n); +uintptr_t wickra_minus_di_warmup_period(struct MinusDi *handle); + +bool wickra_minus_di_is_ready(struct MinusDi *handle); + void wickra_minus_di_reset(struct MinusDi *handle); void wickra_minus_di_free(struct MinusDi *handle); @@ -5913,6 +6945,10 @@ void wickra_minus_dm_batch(struct MinusDm *handle, double *out, uintptr_t n); +uintptr_t wickra_minus_dm_warmup_period(struct MinusDm *handle); + +bool wickra_minus_dm_is_ready(struct MinusDm *handle); + void wickra_minus_dm_reset(struct MinusDm *handle); void wickra_minus_dm_free(struct MinusDm *handle); @@ -5937,6 +6973,10 @@ void wickra_morning_doji_star_batch(struct MorningDojiStar *handle, double *out, uintptr_t n); +uintptr_t wickra_morning_doji_star_warmup_period(struct MorningDojiStar *handle); + +bool wickra_morning_doji_star_is_ready(struct MorningDojiStar *handle); + void wickra_morning_doji_star_reset(struct MorningDojiStar *handle); void wickra_morning_doji_star_free(struct MorningDojiStar *handle); @@ -5961,6 +7001,10 @@ void wickra_morning_evening_star_batch(struct MorningEveningStar *handle, double *out, uintptr_t n); +uintptr_t wickra_morning_evening_star_warmup_period(struct MorningEveningStar *handle); + +bool wickra_morning_evening_star_is_ready(struct MorningEveningStar *handle); + void wickra_morning_evening_star_reset(struct MorningEveningStar *handle); void wickra_morning_evening_star_free(struct MorningEveningStar *handle); @@ -5985,6 +7029,10 @@ void wickra_naked_poc_batch(struct NakedPoc *handle, double *out, uintptr_t n); +uintptr_t wickra_naked_poc_warmup_period(struct NakedPoc *handle); + +bool wickra_naked_poc_is_ready(struct NakedPoc *handle); + void wickra_naked_poc_reset(struct NakedPoc *handle); void wickra_naked_poc_free(struct NakedPoc *handle); @@ -6009,6 +7057,10 @@ void wickra_natr_batch(struct Natr *handle, double *out, uintptr_t n); +uintptr_t wickra_natr_warmup_period(struct Natr *handle); + +bool wickra_natr_is_ready(struct Natr *handle); + void wickra_natr_reset(struct Natr *handle); void wickra_natr_free(struct Natr *handle); @@ -6033,6 +7085,10 @@ void wickra_new_price_lines_batch(struct NewPriceLines *handle, double *out, uintptr_t n); +uintptr_t wickra_new_price_lines_warmup_period(struct NewPriceLines *handle); + +bool wickra_new_price_lines_is_ready(struct NewPriceLines *handle); + void wickra_new_price_lines_reset(struct NewPriceLines *handle); void wickra_new_price_lines_free(struct NewPriceLines *handle); @@ -6057,6 +7113,10 @@ void wickra_nvi_batch(struct Nvi *handle, double *out, uintptr_t n); +uintptr_t wickra_nvi_warmup_period(struct Nvi *handle); + +bool wickra_nvi_is_ready(struct Nvi *handle); + void wickra_nvi_reset(struct Nvi *handle); void wickra_nvi_free(struct Nvi *handle); @@ -6081,6 +7141,10 @@ void wickra_obv_batch(struct Obv *handle, double *out, uintptr_t n); +uintptr_t wickra_obv_warmup_period(struct Obv *handle); + +bool wickra_obv_is_ready(struct Obv *handle); + void wickra_obv_reset(struct Obv *handle); void wickra_obv_free(struct Obv *handle); @@ -6105,6 +7169,10 @@ void wickra_on_neck_batch(struct OnNeck *handle, double *out, uintptr_t n); +uintptr_t wickra_on_neck_warmup_period(struct OnNeck *handle); + +bool wickra_on_neck_is_ready(struct OnNeck *handle); + void wickra_on_neck_reset(struct OnNeck *handle); void wickra_on_neck_free(struct OnNeck *handle); @@ -6129,6 +7197,10 @@ void wickra_opening_marubozu_batch(struct OpeningMarubozu *handle, double *out, uintptr_t n); +uintptr_t wickra_opening_marubozu_warmup_period(struct OpeningMarubozu *handle); + +bool wickra_opening_marubozu_is_ready(struct OpeningMarubozu *handle); + void wickra_opening_marubozu_reset(struct OpeningMarubozu *handle); void wickra_opening_marubozu_free(struct OpeningMarubozu *handle); @@ -6153,6 +7225,10 @@ void wickra_overnight_gap_batch(struct OvernightGap *handle, double *out, uintptr_t n); +uintptr_t wickra_overnight_gap_warmup_period(struct OvernightGap *handle); + +bool wickra_overnight_gap_is_ready(struct OvernightGap *handle); + void wickra_overnight_gap_reset(struct OvernightGap *handle); void wickra_overnight_gap_free(struct OvernightGap *handle); @@ -6178,6 +7254,10 @@ void wickra_parkinson_volatility_batch(struct ParkinsonVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_parkinson_volatility_warmup_period(struct ParkinsonVolatility *handle); + +bool wickra_parkinson_volatility_is_ready(struct ParkinsonVolatility *handle); + void wickra_parkinson_volatility_reset(struct ParkinsonVolatility *handle); void wickra_parkinson_volatility_free(struct ParkinsonVolatility *handle); @@ -6202,6 +7282,10 @@ void wickra_pgo_batch(struct Pgo *handle, double *out, uintptr_t n); +uintptr_t wickra_pgo_warmup_period(struct Pgo *handle); + +bool wickra_pgo_is_ready(struct Pgo *handle); + void wickra_pgo_reset(struct Pgo *handle); void wickra_pgo_free(struct Pgo *handle); @@ -6226,6 +7310,10 @@ void wickra_piercing_dark_cloud_batch(struct PiercingDarkCloud *handle, double *out, uintptr_t n); +uintptr_t wickra_piercing_dark_cloud_warmup_period(struct PiercingDarkCloud *handle); + +bool wickra_piercing_dark_cloud_is_ready(struct PiercingDarkCloud *handle); + void wickra_piercing_dark_cloud_reset(struct PiercingDarkCloud *handle); void wickra_piercing_dark_cloud_free(struct PiercingDarkCloud *handle); @@ -6250,6 +7338,10 @@ void wickra_pivot_reversal_batch(struct PivotReversal *handle, double *out, uintptr_t n); +uintptr_t wickra_pivot_reversal_warmup_period(struct PivotReversal *handle); + +bool wickra_pivot_reversal_is_ready(struct PivotReversal *handle); + void wickra_pivot_reversal_reset(struct PivotReversal *handle); void wickra_pivot_reversal_free(struct PivotReversal *handle); @@ -6274,6 +7366,10 @@ void wickra_plus_di_batch(struct PlusDi *handle, double *out, uintptr_t n); +uintptr_t wickra_plus_di_warmup_period(struct PlusDi *handle); + +bool wickra_plus_di_is_ready(struct PlusDi *handle); + void wickra_plus_di_reset(struct PlusDi *handle); void wickra_plus_di_free(struct PlusDi *handle); @@ -6298,6 +7394,10 @@ void wickra_plus_dm_batch(struct PlusDm *handle, double *out, uintptr_t n); +uintptr_t wickra_plus_dm_warmup_period(struct PlusDm *handle); + +bool wickra_plus_dm_is_ready(struct PlusDm *handle); + void wickra_plus_dm_reset(struct PlusDm *handle); void wickra_plus_dm_free(struct PlusDm *handle); @@ -6322,6 +7422,10 @@ void wickra_profile_shape_batch(struct ProfileShape *handle, double *out, uintptr_t n); +uintptr_t wickra_profile_shape_warmup_period(struct ProfileShape *handle); + +bool wickra_profile_shape_is_ready(struct ProfileShape *handle); + void wickra_profile_shape_reset(struct ProfileShape *handle); void wickra_profile_shape_free(struct ProfileShape *handle); @@ -6346,6 +7450,10 @@ void wickra_projection_oscillator_batch(struct ProjectionOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_projection_oscillator_warmup_period(struct ProjectionOscillator *handle); + +bool wickra_projection_oscillator_is_ready(struct ProjectionOscillator *handle); + void wickra_projection_oscillator_reset(struct ProjectionOscillator *handle); void wickra_projection_oscillator_free(struct ProjectionOscillator *handle); @@ -6370,6 +7478,10 @@ void wickra_psar_batch(struct Psar *handle, double *out, uintptr_t n); +uintptr_t wickra_psar_warmup_period(struct Psar *handle); + +bool wickra_psar_is_ready(struct Psar *handle); + void wickra_psar_reset(struct Psar *handle); void wickra_psar_free(struct Psar *handle); @@ -6394,6 +7506,10 @@ void wickra_pvi_batch(struct Pvi *handle, double *out, uintptr_t n); +uintptr_t wickra_pvi_warmup_period(struct Pvi *handle); + +bool wickra_pvi_is_ready(struct Pvi *handle); + void wickra_pvi_reset(struct Pvi *handle); void wickra_pvi_free(struct Pvi *handle); @@ -6418,6 +7534,10 @@ void wickra_qstick_batch(struct Qstick *handle, double *out, uintptr_t n); +uintptr_t wickra_qstick_warmup_period(struct Qstick *handle); + +bool wickra_qstick_is_ready(struct Qstick *handle); + void wickra_qstick_reset(struct Qstick *handle); void wickra_qstick_free(struct Qstick *handle); @@ -6442,6 +7562,10 @@ void wickra_rectangle_range_batch(struct RectangleRange *handle, double *out, uintptr_t n); +uintptr_t wickra_rectangle_range_warmup_period(struct RectangleRange *handle); + +bool wickra_rectangle_range_is_ready(struct RectangleRange *handle); + void wickra_rectangle_range_reset(struct RectangleRange *handle); void wickra_rectangle_range_free(struct RectangleRange *handle); @@ -6466,6 +7590,10 @@ void wickra_rickshaw_man_batch(struct RickshawMan *handle, double *out, uintptr_t n); +uintptr_t wickra_rickshaw_man_warmup_period(struct RickshawMan *handle); + +bool wickra_rickshaw_man_is_ready(struct RickshawMan *handle); + void wickra_rickshaw_man_reset(struct RickshawMan *handle); void wickra_rickshaw_man_free(struct RickshawMan *handle); @@ -6490,6 +7618,10 @@ void wickra_rising_three_methods_batch(struct RisingThreeMethods *handle, double *out, uintptr_t n); +uintptr_t wickra_rising_three_methods_warmup_period(struct RisingThreeMethods *handle); + +bool wickra_rising_three_methods_is_ready(struct RisingThreeMethods *handle); + void wickra_rising_three_methods_reset(struct RisingThreeMethods *handle); void wickra_rising_three_methods_free(struct RisingThreeMethods *handle); @@ -6515,6 +7647,10 @@ void wickra_rogers_satchell_volatility_batch(struct RogersSatchellVolatility *ha double *out, uintptr_t n); +uintptr_t wickra_rogers_satchell_volatility_warmup_period(struct RogersSatchellVolatility *handle); + +bool wickra_rogers_satchell_volatility_is_ready(struct RogersSatchellVolatility *handle); + void wickra_rogers_satchell_volatility_reset(struct RogersSatchellVolatility *handle); void wickra_rogers_satchell_volatility_free(struct RogersSatchellVolatility *handle); @@ -6539,6 +7675,10 @@ void wickra_rvi_batch(struct Rvi *handle, double *out, uintptr_t n); +uintptr_t wickra_rvi_warmup_period(struct Rvi *handle); + +bool wickra_rvi_is_ready(struct Rvi *handle); + void wickra_rvi_reset(struct Rvi *handle); void wickra_rvi_free(struct Rvi *handle); @@ -6570,6 +7710,10 @@ void wickra_sar_ext_batch(struct SarExt *handle, double *out, uintptr_t n); +uintptr_t wickra_sar_ext_warmup_period(struct SarExt *handle); + +bool wickra_sar_ext_is_ready(struct SarExt *handle); + void wickra_sar_ext_reset(struct SarExt *handle); void wickra_sar_ext_free(struct SarExt *handle); @@ -6594,6 +7738,10 @@ void wickra_seasonal_z_score_batch(struct SeasonalZScore *handle, double *out, uintptr_t n); +uintptr_t wickra_seasonal_z_score_warmup_period(struct SeasonalZScore *handle); + +bool wickra_seasonal_z_score_is_ready(struct SeasonalZScore *handle); + void wickra_seasonal_z_score_reset(struct SeasonalZScore *handle); void wickra_seasonal_z_score_free(struct SeasonalZScore *handle); @@ -6618,6 +7766,10 @@ void wickra_separating_lines_batch(struct SeparatingLines *handle, double *out, uintptr_t n); +uintptr_t wickra_separating_lines_warmup_period(struct SeparatingLines *handle); + +bool wickra_separating_lines_is_ready(struct SeparatingLines *handle); + void wickra_separating_lines_reset(struct SeparatingLines *handle); void wickra_separating_lines_free(struct SeparatingLines *handle); @@ -6642,6 +7794,10 @@ void wickra_session_vwap_batch(struct SessionVwap *handle, double *out, uintptr_t n); +uintptr_t wickra_session_vwap_warmup_period(struct SessionVwap *handle); + +bool wickra_session_vwap_is_ready(struct SessionVwap *handle); + void wickra_session_vwap_reset(struct SessionVwap *handle); void wickra_session_vwap_free(struct SessionVwap *handle); @@ -6666,6 +7822,10 @@ void wickra_shark_batch(struct Shark *handle, double *out, uintptr_t n); +uintptr_t wickra_shark_warmup_period(struct Shark *handle); + +bool wickra_shark_is_ready(struct Shark *handle); + void wickra_shark_reset(struct Shark *handle); void wickra_shark_free(struct Shark *handle); @@ -6690,6 +7850,10 @@ void wickra_shooting_star_batch(struct ShootingStar *handle, double *out, uintptr_t n); +uintptr_t wickra_shooting_star_warmup_period(struct ShootingStar *handle); + +bool wickra_shooting_star_is_ready(struct ShootingStar *handle); + void wickra_shooting_star_reset(struct ShootingStar *handle); void wickra_shooting_star_free(struct ShootingStar *handle); @@ -6714,6 +7878,10 @@ void wickra_short_line_batch(struct ShortLine *handle, double *out, uintptr_t n); +uintptr_t wickra_short_line_warmup_period(struct ShortLine *handle); + +bool wickra_short_line_is_ready(struct ShortLine *handle); + void wickra_short_line_reset(struct ShortLine *handle); void wickra_short_line_free(struct ShortLine *handle); @@ -6738,6 +7906,10 @@ void wickra_single_prints_batch(struct SinglePrints *handle, double *out, uintptr_t n); +uintptr_t wickra_single_prints_warmup_period(struct SinglePrints *handle); + +bool wickra_single_prints_is_ready(struct SinglePrints *handle); + void wickra_single_prints_reset(struct SinglePrints *handle); void wickra_single_prints_free(struct SinglePrints *handle); @@ -6762,6 +7934,10 @@ void wickra_smi_batch(struct Smi *handle, double *out, uintptr_t n); +uintptr_t wickra_smi_warmup_period(struct Smi *handle); + +bool wickra_smi_is_ready(struct Smi *handle); + void wickra_smi_reset(struct Smi *handle); void wickra_smi_free(struct Smi *handle); @@ -6786,6 +7962,10 @@ void wickra_spinning_top_batch(struct SpinningTop *handle, double *out, uintptr_t n); +uintptr_t wickra_spinning_top_warmup_period(struct SpinningTop *handle); + +bool wickra_spinning_top_is_ready(struct SpinningTop *handle); + void wickra_spinning_top_reset(struct SpinningTop *handle); void wickra_spinning_top_free(struct SpinningTop *handle); @@ -6810,6 +7990,10 @@ void wickra_stalled_pattern_batch(struct StalledPattern *handle, double *out, uintptr_t n); +uintptr_t wickra_stalled_pattern_warmup_period(struct StalledPattern *handle); + +bool wickra_stalled_pattern_is_ready(struct StalledPattern *handle); + void wickra_stalled_pattern_reset(struct StalledPattern *handle); void wickra_stalled_pattern_free(struct StalledPattern *handle); @@ -6834,6 +8018,10 @@ void wickra_stick_sandwich_batch(struct StickSandwich *handle, double *out, uintptr_t n); +uintptr_t wickra_stick_sandwich_warmup_period(struct StickSandwich *handle); + +bool wickra_stick_sandwich_is_ready(struct StickSandwich *handle); + void wickra_stick_sandwich_reset(struct StickSandwich *handle); void wickra_stick_sandwich_free(struct StickSandwich *handle); @@ -6858,6 +8046,10 @@ void wickra_stochastic_cci_batch(struct StochasticCci *handle, double *out, uintptr_t n); +uintptr_t wickra_stochastic_cci_warmup_period(struct StochasticCci *handle); + +bool wickra_stochastic_cci_is_ready(struct StochasticCci *handle); + void wickra_stochastic_cci_reset(struct StochasticCci *handle); void wickra_stochastic_cci_free(struct StochasticCci *handle); @@ -6882,6 +8074,10 @@ void wickra_takuri_batch(struct Takuri *handle, double *out, uintptr_t n); +uintptr_t wickra_takuri_warmup_period(struct Takuri *handle); + +bool wickra_takuri_is_ready(struct Takuri *handle); + void wickra_takuri_reset(struct Takuri *handle); void wickra_takuri_free(struct Takuri *handle); @@ -6906,6 +8102,10 @@ void wickra_tasuki_gap_batch(struct TasukiGap *handle, double *out, uintptr_t n); +uintptr_t wickra_tasuki_gap_warmup_period(struct TasukiGap *handle); + +bool wickra_tasuki_gap_is_ready(struct TasukiGap *handle); + void wickra_tasuki_gap_reset(struct TasukiGap *handle); void wickra_tasuki_gap_free(struct TasukiGap *handle); @@ -6930,6 +8130,10 @@ void wickra_td_camouflage_batch(struct TdCamouflage *handle, double *out, uintptr_t n); +uintptr_t wickra_td_camouflage_warmup_period(struct TdCamouflage *handle); + +bool wickra_td_camouflage_is_ready(struct TdCamouflage *handle); + void wickra_td_camouflage_reset(struct TdCamouflage *handle); void wickra_td_camouflage_free(struct TdCamouflage *handle); @@ -6954,6 +8158,10 @@ void wickra_td_clop_batch(struct TdClop *handle, double *out, uintptr_t n); +uintptr_t wickra_td_clop_warmup_period(struct TdClop *handle); + +bool wickra_td_clop_is_ready(struct TdClop *handle); + void wickra_td_clop_reset(struct TdClop *handle); void wickra_td_clop_free(struct TdClop *handle); @@ -6978,6 +8186,10 @@ void wickra_td_clopwin_batch(struct TdClopwin *handle, double *out, uintptr_t n); +uintptr_t wickra_td_clopwin_warmup_period(struct TdClopwin *handle); + +bool wickra_td_clopwin_is_ready(struct TdClopwin *handle); + void wickra_td_clopwin_reset(struct TdClopwin *handle); void wickra_td_clopwin_free(struct TdClopwin *handle); @@ -7005,6 +8217,10 @@ void wickra_td_combo_batch(struct TdCombo *handle, double *out, uintptr_t n); +uintptr_t wickra_td_combo_warmup_period(struct TdCombo *handle); + +bool wickra_td_combo_is_ready(struct TdCombo *handle); + void wickra_td_combo_reset(struct TdCombo *handle); void wickra_td_combo_free(struct TdCombo *handle); @@ -7032,6 +8248,10 @@ void wickra_td_countdown_batch(struct TdCountdown *handle, double *out, uintptr_t n); +uintptr_t wickra_td_countdown_warmup_period(struct TdCountdown *handle); + +bool wickra_td_countdown_is_ready(struct TdCountdown *handle); + void wickra_td_countdown_reset(struct TdCountdown *handle); void wickra_td_countdown_free(struct TdCountdown *handle); @@ -7056,6 +8276,10 @@ void wickra_td_de_marker_batch(struct TdDeMarker *handle, double *out, uintptr_t n); +uintptr_t wickra_td_de_marker_warmup_period(struct TdDeMarker *handle); + +bool wickra_td_de_marker_is_ready(struct TdDeMarker *handle); + void wickra_td_de_marker_reset(struct TdDeMarker *handle); void wickra_td_de_marker_free(struct TdDeMarker *handle); @@ -7080,6 +8304,10 @@ void wickra_td_differential_batch(struct TdDifferential *handle, double *out, uintptr_t n); +uintptr_t wickra_td_differential_warmup_period(struct TdDifferential *handle); + +bool wickra_td_differential_is_ready(struct TdDifferential *handle); + void wickra_td_differential_reset(struct TdDifferential *handle); void wickra_td_differential_free(struct TdDifferential *handle); @@ -7104,6 +8332,10 @@ void wickra_td_d_wave_batch(struct TdDWave *handle, double *out, uintptr_t n); +uintptr_t wickra_td_d_wave_warmup_period(struct TdDWave *handle); + +bool wickra_td_d_wave_is_ready(struct TdDWave *handle); + void wickra_td_d_wave_reset(struct TdDWave *handle); void wickra_td_d_wave_free(struct TdDWave *handle); @@ -7128,6 +8360,10 @@ void wickra_td_open_batch(struct TdOpen *handle, double *out, uintptr_t n); +uintptr_t wickra_td_open_warmup_period(struct TdOpen *handle); + +bool wickra_td_open_is_ready(struct TdOpen *handle); + void wickra_td_open_reset(struct TdOpen *handle); void wickra_td_open_free(struct TdOpen *handle); @@ -7152,6 +8388,10 @@ void wickra_td_pressure_batch(struct TdPressure *handle, double *out, uintptr_t n); +uintptr_t wickra_td_pressure_warmup_period(struct TdPressure *handle); + +bool wickra_td_pressure_is_ready(struct TdPressure *handle); + void wickra_td_pressure_reset(struct TdPressure *handle); void wickra_td_pressure_free(struct TdPressure *handle); @@ -7176,6 +8416,10 @@ void wickra_td_propulsion_batch(struct TdPropulsion *handle, double *out, uintptr_t n); +uintptr_t wickra_td_propulsion_warmup_period(struct TdPropulsion *handle); + +bool wickra_td_propulsion_is_ready(struct TdPropulsion *handle); + void wickra_td_propulsion_reset(struct TdPropulsion *handle); void wickra_td_propulsion_free(struct TdPropulsion *handle); @@ -7200,6 +8444,10 @@ void wickra_td_rei_batch(struct TdRei *handle, double *out, uintptr_t n); +uintptr_t wickra_td_rei_warmup_period(struct TdRei *handle); + +bool wickra_td_rei_is_ready(struct TdRei *handle); + void wickra_td_rei_reset(struct TdRei *handle); void wickra_td_rei_free(struct TdRei *handle); @@ -7224,6 +8472,10 @@ void wickra_td_setup_batch(struct TdSetup *handle, double *out, uintptr_t n); +uintptr_t wickra_td_setup_warmup_period(struct TdSetup *handle); + +bool wickra_td_setup_is_ready(struct TdSetup *handle); + void wickra_td_setup_reset(struct TdSetup *handle); void wickra_td_setup_free(struct TdSetup *handle); @@ -7248,6 +8500,10 @@ void wickra_td_trap_batch(struct TdTrap *handle, double *out, uintptr_t n); +uintptr_t wickra_td_trap_warmup_period(struct TdTrap *handle); + +bool wickra_td_trap_is_ready(struct TdTrap *handle); + void wickra_td_trap_reset(struct TdTrap *handle); void wickra_td_trap_free(struct TdTrap *handle); @@ -7272,6 +8528,10 @@ void wickra_three_drives_batch(struct ThreeDrives *handle, double *out, uintptr_t n); +uintptr_t wickra_three_drives_warmup_period(struct ThreeDrives *handle); + +bool wickra_three_drives_is_ready(struct ThreeDrives *handle); + void wickra_three_drives_reset(struct ThreeDrives *handle); void wickra_three_drives_free(struct ThreeDrives *handle); @@ -7296,6 +8556,10 @@ void wickra_three_inside_batch(struct ThreeInside *handle, double *out, uintptr_t n); +uintptr_t wickra_three_inside_warmup_period(struct ThreeInside *handle); + +bool wickra_three_inside_is_ready(struct ThreeInside *handle); + void wickra_three_inside_reset(struct ThreeInside *handle); void wickra_three_inside_free(struct ThreeInside *handle); @@ -7320,6 +8584,10 @@ void wickra_three_line_break_batch(struct ThreeLineBreak *handle, double *out, uintptr_t n); +uintptr_t wickra_three_line_break_warmup_period(struct ThreeLineBreak *handle); + +bool wickra_three_line_break_is_ready(struct ThreeLineBreak *handle); + void wickra_three_line_break_reset(struct ThreeLineBreak *handle); void wickra_three_line_break_free(struct ThreeLineBreak *handle); @@ -7344,6 +8612,10 @@ void wickra_three_line_strike_batch(struct ThreeLineStrike *handle, double *out, uintptr_t n); +uintptr_t wickra_three_line_strike_warmup_period(struct ThreeLineStrike *handle); + +bool wickra_three_line_strike_is_ready(struct ThreeLineStrike *handle); + void wickra_three_line_strike_reset(struct ThreeLineStrike *handle); void wickra_three_line_strike_free(struct ThreeLineStrike *handle); @@ -7368,6 +8640,10 @@ void wickra_three_outside_batch(struct ThreeOutside *handle, double *out, uintptr_t n); +uintptr_t wickra_three_outside_warmup_period(struct ThreeOutside *handle); + +bool wickra_three_outside_is_ready(struct ThreeOutside *handle); + void wickra_three_outside_reset(struct ThreeOutside *handle); void wickra_three_outside_free(struct ThreeOutside *handle); @@ -7392,6 +8668,10 @@ void wickra_three_soldiers_or_crows_batch(struct ThreeSoldiersOrCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_three_soldiers_or_crows_warmup_period(struct ThreeSoldiersOrCrows *handle); + +bool wickra_three_soldiers_or_crows_is_ready(struct ThreeSoldiersOrCrows *handle); + void wickra_three_soldiers_or_crows_reset(struct ThreeSoldiersOrCrows *handle); void wickra_three_soldiers_or_crows_free(struct ThreeSoldiersOrCrows *handle); @@ -7416,6 +8696,10 @@ void wickra_three_stars_in_south_batch(struct ThreeStarsInSouth *handle, double *out, uintptr_t n); +uintptr_t wickra_three_stars_in_south_warmup_period(struct ThreeStarsInSouth *handle); + +bool wickra_three_stars_in_south_is_ready(struct ThreeStarsInSouth *handle); + void wickra_three_stars_in_south_reset(struct ThreeStarsInSouth *handle); void wickra_three_stars_in_south_free(struct ThreeStarsInSouth *handle); @@ -7440,6 +8724,10 @@ void wickra_thrusting_batch(struct Thrusting *handle, double *out, uintptr_t n); +uintptr_t wickra_thrusting_warmup_period(struct Thrusting *handle); + +bool wickra_thrusting_is_ready(struct Thrusting *handle); + void wickra_thrusting_reset(struct Thrusting *handle); void wickra_thrusting_free(struct Thrusting *handle); @@ -7464,6 +8752,10 @@ void wickra_time_based_stop_batch(struct TimeBasedStop *handle, double *out, uintptr_t n); +uintptr_t wickra_time_based_stop_warmup_period(struct TimeBasedStop *handle); + +bool wickra_time_based_stop_is_ready(struct TimeBasedStop *handle); + void wickra_time_based_stop_reset(struct TimeBasedStop *handle); void wickra_time_based_stop_free(struct TimeBasedStop *handle); @@ -7488,6 +8780,10 @@ void wickra_tower_top_bottom_batch(struct TowerTopBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_tower_top_bottom_warmup_period(struct TowerTopBottom *handle); + +bool wickra_tower_top_bottom_is_ready(struct TowerTopBottom *handle); + void wickra_tower_top_bottom_reset(struct TowerTopBottom *handle); void wickra_tower_top_bottom_free(struct TowerTopBottom *handle); @@ -7512,6 +8808,10 @@ void wickra_trade_volume_index_batch(struct TradeVolumeIndex *handle, double *out, uintptr_t n); +uintptr_t wickra_trade_volume_index_warmup_period(struct TradeVolumeIndex *handle); + +bool wickra_trade_volume_index_is_ready(struct TradeVolumeIndex *handle); + void wickra_trade_volume_index_reset(struct TradeVolumeIndex *handle); void wickra_trade_volume_index_free(struct TradeVolumeIndex *handle); @@ -7536,6 +8836,10 @@ void wickra_triangle_batch(struct Triangle *handle, double *out, uintptr_t n); +uintptr_t wickra_triangle_warmup_period(struct Triangle *handle); + +bool wickra_triangle_is_ready(struct Triangle *handle); + void wickra_triangle_reset(struct Triangle *handle); void wickra_triangle_free(struct Triangle *handle); @@ -7560,6 +8864,10 @@ void wickra_triple_top_bottom_batch(struct TripleTopBottom *handle, double *out, uintptr_t n); +uintptr_t wickra_triple_top_bottom_warmup_period(struct TripleTopBottom *handle); + +bool wickra_triple_top_bottom_is_ready(struct TripleTopBottom *handle); + void wickra_triple_top_bottom_reset(struct TripleTopBottom *handle); void wickra_triple_top_bottom_free(struct TripleTopBottom *handle); @@ -7584,6 +8892,10 @@ void wickra_tristar_batch(struct Tristar *handle, double *out, uintptr_t n); +uintptr_t wickra_tristar_warmup_period(struct Tristar *handle); + +bool wickra_tristar_is_ready(struct Tristar *handle); + void wickra_tristar_reset(struct Tristar *handle); void wickra_tristar_free(struct Tristar *handle); @@ -7608,6 +8920,10 @@ void wickra_true_range_batch(struct TrueRange *handle, double *out, uintptr_t n); +uintptr_t wickra_true_range_warmup_period(struct TrueRange *handle); + +bool wickra_true_range_is_ready(struct TrueRange *handle); + void wickra_true_range_reset(struct TrueRange *handle); void wickra_true_range_free(struct TrueRange *handle); @@ -7632,6 +8948,10 @@ void wickra_tsv_batch(struct Tsv *handle, double *out, uintptr_t n); +uintptr_t wickra_tsv_warmup_period(struct Tsv *handle); + +bool wickra_tsv_is_ready(struct Tsv *handle); + void wickra_tsv_reset(struct Tsv *handle); void wickra_tsv_free(struct Tsv *handle); @@ -7656,6 +8976,10 @@ void wickra_ttm_trend_batch(struct TtmTrend *handle, double *out, uintptr_t n); +uintptr_t wickra_ttm_trend_warmup_period(struct TtmTrend *handle); + +bool wickra_ttm_trend_is_ready(struct TtmTrend *handle); + void wickra_ttm_trend_reset(struct TtmTrend *handle); void wickra_ttm_trend_free(struct TtmTrend *handle); @@ -7682,6 +9006,10 @@ void wickra_turn_of_month_batch(struct TurnOfMonth *handle, double *out, uintptr_t n); +uintptr_t wickra_turn_of_month_warmup_period(struct TurnOfMonth *handle); + +bool wickra_turn_of_month_is_ready(struct TurnOfMonth *handle); + void wickra_turn_of_month_reset(struct TurnOfMonth *handle); void wickra_turn_of_month_free(struct TurnOfMonth *handle); @@ -7706,6 +9034,10 @@ void wickra_tweezer_batch(struct Tweezer *handle, double *out, uintptr_t n); +uintptr_t wickra_tweezer_warmup_period(struct Tweezer *handle); + +bool wickra_tweezer_is_ready(struct Tweezer *handle); + void wickra_tweezer_reset(struct Tweezer *handle); void wickra_tweezer_free(struct Tweezer *handle); @@ -7730,6 +9062,10 @@ void wickra_twiggs_money_flow_batch(struct TwiggsMoneyFlow *handle, double *out, uintptr_t n); +uintptr_t wickra_twiggs_money_flow_warmup_period(struct TwiggsMoneyFlow *handle); + +bool wickra_twiggs_money_flow_is_ready(struct TwiggsMoneyFlow *handle); + void wickra_twiggs_money_flow_reset(struct TwiggsMoneyFlow *handle); void wickra_twiggs_money_flow_free(struct TwiggsMoneyFlow *handle); @@ -7754,6 +9090,10 @@ void wickra_two_crows_batch(struct TwoCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_two_crows_warmup_period(struct TwoCrows *handle); + +bool wickra_two_crows_is_ready(struct TwoCrows *handle); + void wickra_two_crows_reset(struct TwoCrows *handle); void wickra_two_crows_free(struct TwoCrows *handle); @@ -7778,6 +9118,10 @@ void wickra_typical_price_batch(struct TypicalPrice *handle, double *out, uintptr_t n); +uintptr_t wickra_typical_price_warmup_period(struct TypicalPrice *handle); + +bool wickra_typical_price_is_ready(struct TypicalPrice *handle); + void wickra_typical_price_reset(struct TypicalPrice *handle); void wickra_typical_price_free(struct TypicalPrice *handle); @@ -7804,6 +9148,10 @@ void wickra_ultimate_oscillator_batch(struct UltimateOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_ultimate_oscillator_warmup_period(struct UltimateOscillator *handle); + +bool wickra_ultimate_oscillator_is_ready(struct UltimateOscillator *handle); + void wickra_ultimate_oscillator_reset(struct UltimateOscillator *handle); void wickra_ultimate_oscillator_free(struct UltimateOscillator *handle); @@ -7828,6 +9176,10 @@ void wickra_unique_three_river_batch(struct UniqueThreeRiver *handle, double *out, uintptr_t n); +uintptr_t wickra_unique_three_river_warmup_period(struct UniqueThreeRiver *handle); + +bool wickra_unique_three_river_is_ready(struct UniqueThreeRiver *handle); + void wickra_unique_three_river_reset(struct UniqueThreeRiver *handle); void wickra_unique_three_river_free(struct UniqueThreeRiver *handle); @@ -7852,6 +9204,10 @@ void wickra_upside_gap_three_methods_batch(struct UpsideGapThreeMethods *handle, double *out, uintptr_t n); +uintptr_t wickra_upside_gap_three_methods_warmup_period(struct UpsideGapThreeMethods *handle); + +bool wickra_upside_gap_three_methods_is_ready(struct UpsideGapThreeMethods *handle); + void wickra_upside_gap_three_methods_reset(struct UpsideGapThreeMethods *handle); void wickra_upside_gap_three_methods_free(struct UpsideGapThreeMethods *handle); @@ -7876,6 +9232,10 @@ void wickra_upside_gap_two_crows_batch(struct UpsideGapTwoCrows *handle, double *out, uintptr_t n); +uintptr_t wickra_upside_gap_two_crows_warmup_period(struct UpsideGapTwoCrows *handle); + +bool wickra_upside_gap_two_crows_is_ready(struct UpsideGapTwoCrows *handle); + void wickra_upside_gap_two_crows_reset(struct UpsideGapTwoCrows *handle); void wickra_upside_gap_two_crows_free(struct UpsideGapTwoCrows *handle); @@ -7900,6 +9260,10 @@ void wickra_volatility_ratio_batch(struct VolatilityRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_volatility_ratio_warmup_period(struct VolatilityRatio *handle); + +bool wickra_volatility_ratio_is_ready(struct VolatilityRatio *handle); + void wickra_volatility_ratio_reset(struct VolatilityRatio *handle); void wickra_volatility_ratio_free(struct VolatilityRatio *handle); @@ -7924,6 +9288,10 @@ void wickra_volty_stop_batch(struct VoltyStop *handle, double *out, uintptr_t n); +uintptr_t wickra_volty_stop_warmup_period(struct VoltyStop *handle); + +bool wickra_volty_stop_is_ready(struct VoltyStop *handle); + void wickra_volty_stop_reset(struct VoltyStop *handle); void wickra_volty_stop_free(struct VoltyStop *handle); @@ -7948,6 +9316,10 @@ void wickra_volume_oscillator_batch(struct VolumeOscillator *handle, double *out, uintptr_t n); +uintptr_t wickra_volume_oscillator_warmup_period(struct VolumeOscillator *handle); + +bool wickra_volume_oscillator_is_ready(struct VolumeOscillator *handle); + void wickra_volume_oscillator_reset(struct VolumeOscillator *handle); void wickra_volume_oscillator_free(struct VolumeOscillator *handle); @@ -7972,6 +9344,10 @@ void wickra_volume_rsi_batch(struct VolumeRsi *handle, double *out, uintptr_t n); +uintptr_t wickra_volume_rsi_warmup_period(struct VolumeRsi *handle); + +bool wickra_volume_rsi_is_ready(struct VolumeRsi *handle); + void wickra_volume_rsi_reset(struct VolumeRsi *handle); void wickra_volume_rsi_free(struct VolumeRsi *handle); @@ -7996,6 +9372,10 @@ void wickra_volume_price_trend_batch(struct VolumePriceTrend *handle, double *out, uintptr_t n); +uintptr_t wickra_volume_price_trend_warmup_period(struct VolumePriceTrend *handle); + +bool wickra_volume_price_trend_is_ready(struct VolumePriceTrend *handle); + void wickra_volume_price_trend_reset(struct VolumePriceTrend *handle); void wickra_volume_price_trend_free(struct VolumePriceTrend *handle); @@ -8020,6 +9400,10 @@ void wickra_vwap_batch(struct Vwap *handle, double *out, uintptr_t n); +uintptr_t wickra_vwap_warmup_period(struct Vwap *handle); + +bool wickra_vwap_is_ready(struct Vwap *handle); + void wickra_vwap_reset(struct Vwap *handle); void wickra_vwap_free(struct Vwap *handle); @@ -8044,6 +9428,10 @@ void wickra_rolling_vwap_batch(struct RollingVwap *handle, double *out, uintptr_t n); +uintptr_t wickra_rolling_vwap_warmup_period(struct RollingVwap *handle); + +bool wickra_rolling_vwap_is_ready(struct RollingVwap *handle); + void wickra_rolling_vwap_reset(struct RollingVwap *handle); void wickra_rolling_vwap_free(struct RollingVwap *handle); @@ -8068,6 +9456,10 @@ void wickra_vwma_batch(struct Vwma *handle, double *out, uintptr_t n); +uintptr_t wickra_vwma_warmup_period(struct Vwma *handle); + +bool wickra_vwma_is_ready(struct Vwma *handle); + void wickra_vwma_reset(struct Vwma *handle); void wickra_vwma_free(struct Vwma *handle); @@ -8092,6 +9484,10 @@ void wickra_vzo_batch(struct Vzo *handle, double *out, uintptr_t n); +uintptr_t wickra_vzo_warmup_period(struct Vzo *handle); + +bool wickra_vzo_is_ready(struct Vzo *handle); + void wickra_vzo_reset(struct Vzo *handle); void wickra_vzo_free(struct Vzo *handle); @@ -8116,6 +9512,10 @@ void wickra_wad_batch(struct Wad *handle, double *out, uintptr_t n); +uintptr_t wickra_wad_warmup_period(struct Wad *handle); + +bool wickra_wad_is_ready(struct Wad *handle); + void wickra_wad_reset(struct Wad *handle); void wickra_wad_free(struct Wad *handle); @@ -8140,6 +9540,10 @@ void wickra_wedge_batch(struct Wedge *handle, double *out, uintptr_t n); +uintptr_t wickra_wedge_warmup_period(struct Wedge *handle); + +bool wickra_wedge_is_ready(struct Wedge *handle); + void wickra_wedge_reset(struct Wedge *handle); void wickra_wedge_free(struct Wedge *handle); @@ -8164,6 +9568,10 @@ void wickra_weighted_close_batch(struct WeightedClose *handle, double *out, uintptr_t n); +uintptr_t wickra_weighted_close_warmup_period(struct WeightedClose *handle); + +bool wickra_weighted_close_is_ready(struct WeightedClose *handle); + void wickra_weighted_close_reset(struct WeightedClose *handle); void wickra_weighted_close_free(struct WeightedClose *handle); @@ -8188,6 +9596,10 @@ void wickra_wick_ratio_batch(struct WickRatio *handle, double *out, uintptr_t n); +uintptr_t wickra_wick_ratio_warmup_period(struct WickRatio *handle); + +bool wickra_wick_ratio_is_ready(struct WickRatio *handle); + void wickra_wick_ratio_reset(struct WickRatio *handle); void wickra_wick_ratio_free(struct WickRatio *handle); @@ -8212,6 +9624,10 @@ void wickra_williams_r_batch(struct WilliamsR *handle, double *out, uintptr_t n); +uintptr_t wickra_williams_r_warmup_period(struct WilliamsR *handle); + +bool wickra_williams_r_is_ready(struct WilliamsR *handle); + void wickra_williams_r_reset(struct WilliamsR *handle); void wickra_williams_r_free(struct WilliamsR *handle); @@ -8237,6 +9653,10 @@ void wickra_yang_zhang_volatility_batch(struct YangZhangVolatility *handle, double *out, uintptr_t n); +uintptr_t wickra_yang_zhang_volatility_warmup_period(struct YangZhangVolatility *handle); + +bool wickra_yang_zhang_volatility_is_ready(struct YangZhangVolatility *handle); + void wickra_yang_zhang_volatility_reset(struct YangZhangVolatility *handle); void wickra_yang_zhang_volatility_free(struct YangZhangVolatility *handle); @@ -8261,6 +9681,10 @@ void wickra_yoyo_exit_batch(struct YoyoExit *handle, double *out, uintptr_t n); +uintptr_t wickra_yoyo_exit_warmup_period(struct YoyoExit *handle); + +bool wickra_yoyo_exit_is_ready(struct YoyoExit *handle); + void wickra_yoyo_exit_reset(struct YoyoExit *handle); void wickra_yoyo_exit_free(struct YoyoExit *handle); @@ -8273,6 +9697,10 @@ double wickra_amihud_illiquidity_update(struct AmihudIlliquidity *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_amihud_illiquidity_warmup_period(struct AmihudIlliquidity *handle); + +bool wickra_amihud_illiquidity_is_ready(struct AmihudIlliquidity *handle); + void wickra_amihud_illiquidity_reset(struct AmihudIlliquidity *handle); void wickra_amihud_illiquidity_free(struct AmihudIlliquidity *handle); @@ -8285,6 +9713,10 @@ double wickra_cumulative_volume_delta_update(struct CumulativeVolumeDelta *handl bool is_buy, int64_t timestamp); +uintptr_t wickra_cumulative_volume_delta_warmup_period(struct CumulativeVolumeDelta *handle); + +bool wickra_cumulative_volume_delta_is_ready(struct CumulativeVolumeDelta *handle); + void wickra_cumulative_volume_delta_reset(struct CumulativeVolumeDelta *handle); void wickra_cumulative_volume_delta_free(struct CumulativeVolumeDelta *handle); @@ -8297,6 +9729,10 @@ double wickra_pin_update(struct Pin *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_pin_warmup_period(struct Pin *handle); + +bool wickra_pin_is_ready(struct Pin *handle); + void wickra_pin_reset(struct Pin *handle); void wickra_pin_free(struct Pin *handle); @@ -8309,6 +9745,10 @@ double wickra_roll_measure_update(struct RollMeasure *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_roll_measure_warmup_period(struct RollMeasure *handle); + +bool wickra_roll_measure_is_ready(struct RollMeasure *handle); + void wickra_roll_measure_reset(struct RollMeasure *handle); void wickra_roll_measure_free(struct RollMeasure *handle); @@ -8321,6 +9761,10 @@ double wickra_signed_volume_update(struct SignedVolume *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_signed_volume_warmup_period(struct SignedVolume *handle); + +bool wickra_signed_volume_is_ready(struct SignedVolume *handle); + void wickra_signed_volume_reset(struct SignedVolume *handle); void wickra_signed_volume_free(struct SignedVolume *handle); @@ -8333,6 +9777,10 @@ double wickra_trade_imbalance_update(struct TradeImbalance *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_trade_imbalance_warmup_period(struct TradeImbalance *handle); + +bool wickra_trade_imbalance_is_ready(struct TradeImbalance *handle); + void wickra_trade_imbalance_reset(struct TradeImbalance *handle); void wickra_trade_imbalance_free(struct TradeImbalance *handle); @@ -8345,6 +9793,10 @@ double wickra_trade_sign_autocorrelation_update(struct TradeSignAutocorrelation bool is_buy, int64_t timestamp); +uintptr_t wickra_trade_sign_autocorrelation_warmup_period(struct TradeSignAutocorrelation *handle); + +bool wickra_trade_sign_autocorrelation_is_ready(struct TradeSignAutocorrelation *handle); + void wickra_trade_sign_autocorrelation_reset(struct TradeSignAutocorrelation *handle); void wickra_trade_sign_autocorrelation_free(struct TradeSignAutocorrelation *handle); @@ -8357,6 +9809,10 @@ double wickra_vpin_update(struct Vpin *handle, bool is_buy, int64_t timestamp); +uintptr_t wickra_vpin_warmup_period(struct Vpin *handle); + +bool wickra_vpin_is_ready(struct Vpin *handle); + void wickra_vpin_reset(struct Vpin *handle); void wickra_vpin_free(struct Vpin *handle); @@ -8370,6 +9826,10 @@ double wickra_effective_spread_update(struct EffectiveSpread *handle, int64_t timestamp, double mid); +uintptr_t wickra_effective_spread_warmup_period(struct EffectiveSpread *handle); + +bool wickra_effective_spread_is_ready(struct EffectiveSpread *handle); + void wickra_effective_spread_reset(struct EffectiveSpread *handle); void wickra_effective_spread_free(struct EffectiveSpread *handle); @@ -8383,6 +9843,10 @@ double wickra_kyles_lambda_update(struct KylesLambda *handle, int64_t timestamp, double mid); +uintptr_t wickra_kyles_lambda_warmup_period(struct KylesLambda *handle); + +bool wickra_kyles_lambda_is_ready(struct KylesLambda *handle); + void wickra_kyles_lambda_reset(struct KylesLambda *handle); void wickra_kyles_lambda_free(struct KylesLambda *handle); @@ -8396,6 +9860,10 @@ double wickra_realized_spread_update(struct RealizedSpread *handle, int64_t timestamp, double mid); +uintptr_t wickra_realized_spread_warmup_period(struct RealizedSpread *handle); + +bool wickra_realized_spread_is_ready(struct RealizedSpread *handle); + void wickra_realized_spread_reset(struct RealizedSpread *handle); void wickra_realized_spread_free(struct RealizedSpread *handle); @@ -8416,6 +9884,10 @@ double wickra_calendar_spread_update(struct CalendarSpread *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_calendar_spread_warmup_period(struct CalendarSpread *handle); + +bool wickra_calendar_spread_is_ready(struct CalendarSpread *handle); + void wickra_calendar_spread_reset(struct CalendarSpread *handle); void wickra_calendar_spread_free(struct CalendarSpread *handle); @@ -8436,6 +9908,10 @@ double wickra_estimated_leverage_ratio_update(struct EstimatedLeverageRatio *han double short_liquidation, int64_t timestamp); +uintptr_t wickra_estimated_leverage_ratio_warmup_period(struct EstimatedLeverageRatio *handle); + +bool wickra_estimated_leverage_ratio_is_ready(struct EstimatedLeverageRatio *handle); + void wickra_estimated_leverage_ratio_reset(struct EstimatedLeverageRatio *handle); void wickra_estimated_leverage_ratio_free(struct EstimatedLeverageRatio *handle); @@ -8456,6 +9932,10 @@ double wickra_funding_basis_update(struct FundingBasis *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_basis_warmup_period(struct FundingBasis *handle); + +bool wickra_funding_basis_is_ready(struct FundingBasis *handle); + void wickra_funding_basis_reset(struct FundingBasis *handle); void wickra_funding_basis_free(struct FundingBasis *handle); @@ -8476,6 +9956,10 @@ double wickra_funding_implied_apr_update(struct FundingImpliedApr *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_implied_apr_warmup_period(struct FundingImpliedApr *handle); + +bool wickra_funding_implied_apr_is_ready(struct FundingImpliedApr *handle); + void wickra_funding_implied_apr_reset(struct FundingImpliedApr *handle); void wickra_funding_implied_apr_free(struct FundingImpliedApr *handle); @@ -8496,6 +9980,10 @@ double wickra_funding_rate_update(struct FundingRate *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_rate_warmup_period(struct FundingRate *handle); + +bool wickra_funding_rate_is_ready(struct FundingRate *handle); + void wickra_funding_rate_reset(struct FundingRate *handle); void wickra_funding_rate_free(struct FundingRate *handle); @@ -8516,6 +10004,10 @@ double wickra_funding_rate_mean_update(struct FundingRateMean *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_rate_mean_warmup_period(struct FundingRateMean *handle); + +bool wickra_funding_rate_mean_is_ready(struct FundingRateMean *handle); + void wickra_funding_rate_mean_reset(struct FundingRateMean *handle); void wickra_funding_rate_mean_free(struct FundingRateMean *handle); @@ -8536,6 +10028,10 @@ double wickra_funding_rate_z_score_update(struct FundingRateZScore *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_funding_rate_z_score_warmup_period(struct FundingRateZScore *handle); + +bool wickra_funding_rate_z_score_is_ready(struct FundingRateZScore *handle); + void wickra_funding_rate_z_score_reset(struct FundingRateZScore *handle); void wickra_funding_rate_z_score_free(struct FundingRateZScore *handle); @@ -8556,6 +10052,10 @@ double wickra_long_short_ratio_update(struct LongShortRatio *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_long_short_ratio_warmup_period(struct LongShortRatio *handle); + +bool wickra_long_short_ratio_is_ready(struct LongShortRatio *handle); + void wickra_long_short_ratio_reset(struct LongShortRatio *handle); void wickra_long_short_ratio_free(struct LongShortRatio *handle); @@ -8576,6 +10076,10 @@ double wickra_open_interest_delta_update(struct OpenInterestDelta *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_open_interest_delta_warmup_period(struct OpenInterestDelta *handle); + +bool wickra_open_interest_delta_is_ready(struct OpenInterestDelta *handle); + void wickra_open_interest_delta_reset(struct OpenInterestDelta *handle); void wickra_open_interest_delta_free(struct OpenInterestDelta *handle); @@ -8596,6 +10100,10 @@ double wickra_oi_price_divergence_update(struct OIPriceDivergence *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_oi_price_divergence_warmup_period(struct OIPriceDivergence *handle); + +bool wickra_oi_price_divergence_is_ready(struct OIPriceDivergence *handle); + void wickra_oi_price_divergence_reset(struct OIPriceDivergence *handle); void wickra_oi_price_divergence_free(struct OIPriceDivergence *handle); @@ -8616,6 +10124,10 @@ double wickra_oi_to_volume_ratio_update(struct OiToVolumeRatio *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_oi_to_volume_ratio_warmup_period(struct OiToVolumeRatio *handle); + +bool wickra_oi_to_volume_ratio_is_ready(struct OiToVolumeRatio *handle); + void wickra_oi_to_volume_ratio_reset(struct OiToVolumeRatio *handle); void wickra_oi_to_volume_ratio_free(struct OiToVolumeRatio *handle); @@ -8636,6 +10148,10 @@ double wickra_oi_weighted_update(struct OIWeighted *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_oi_weighted_warmup_period(struct OIWeighted *handle); + +bool wickra_oi_weighted_is_ready(struct OIWeighted *handle); + void wickra_oi_weighted_reset(struct OIWeighted *handle); void wickra_oi_weighted_free(struct OIWeighted *handle); @@ -8656,6 +10172,10 @@ double wickra_open_interest_momentum_update(struct OpenInterestMomentum *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_open_interest_momentum_warmup_period(struct OpenInterestMomentum *handle); + +bool wickra_open_interest_momentum_is_ready(struct OpenInterestMomentum *handle); + void wickra_open_interest_momentum_reset(struct OpenInterestMomentum *handle); void wickra_open_interest_momentum_free(struct OpenInterestMomentum *handle); @@ -8676,6 +10196,10 @@ double wickra_perpetual_premium_index_update(struct PerpetualPremiumIndex *handl double short_liquidation, int64_t timestamp); +uintptr_t wickra_perpetual_premium_index_warmup_period(struct PerpetualPremiumIndex *handle); + +bool wickra_perpetual_premium_index_is_ready(struct PerpetualPremiumIndex *handle); + void wickra_perpetual_premium_index_reset(struct PerpetualPremiumIndex *handle); void wickra_perpetual_premium_index_free(struct PerpetualPremiumIndex *handle); @@ -8696,6 +10220,10 @@ double wickra_taker_buy_sell_ratio_update(struct TakerBuySellRatio *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_taker_buy_sell_ratio_warmup_period(struct TakerBuySellRatio *handle); + +bool wickra_taker_buy_sell_ratio_is_ready(struct TakerBuySellRatio *handle); + void wickra_taker_buy_sell_ratio_reset(struct TakerBuySellRatio *handle); void wickra_taker_buy_sell_ratio_free(struct TakerBuySellRatio *handle); @@ -8716,6 +10244,10 @@ double wickra_term_structure_basis_update(struct TermStructureBasis *handle, double short_liquidation, int64_t timestamp); +uintptr_t wickra_term_structure_basis_warmup_period(struct TermStructureBasis *handle); + +bool wickra_term_structure_basis_is_ready(struct TermStructureBasis *handle); + void wickra_term_structure_basis_reset(struct TermStructureBasis *handle); void wickra_term_structure_basis_free(struct TermStructureBasis *handle); @@ -8730,6 +10262,10 @@ double wickra_depth_slope_update(struct DepthSlope *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_depth_slope_warmup_period(struct DepthSlope *handle); + +bool wickra_depth_slope_is_ready(struct DepthSlope *handle); + void wickra_depth_slope_reset(struct DepthSlope *handle); void wickra_depth_slope_free(struct DepthSlope *handle); @@ -8744,6 +10280,10 @@ double wickra_microprice_update(struct Microprice *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_microprice_warmup_period(struct Microprice *handle); + +bool wickra_microprice_is_ready(struct Microprice *handle); + void wickra_microprice_reset(struct Microprice *handle); void wickra_microprice_free(struct Microprice *handle); @@ -8758,6 +10298,10 @@ double wickra_order_book_imbalance_full_update(struct OrderBookImbalanceFull *ha const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_book_imbalance_full_warmup_period(struct OrderBookImbalanceFull *handle); + +bool wickra_order_book_imbalance_full_is_ready(struct OrderBookImbalanceFull *handle); + void wickra_order_book_imbalance_full_reset(struct OrderBookImbalanceFull *handle); void wickra_order_book_imbalance_full_free(struct OrderBookImbalanceFull *handle); @@ -8772,6 +10316,10 @@ double wickra_order_book_imbalance_top1_update(struct OrderBookImbalanceTop1 *ha const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_book_imbalance_top1_warmup_period(struct OrderBookImbalanceTop1 *handle); + +bool wickra_order_book_imbalance_top1_is_ready(struct OrderBookImbalanceTop1 *handle); + void wickra_order_book_imbalance_top1_reset(struct OrderBookImbalanceTop1 *handle); void wickra_order_book_imbalance_top1_free(struct OrderBookImbalanceTop1 *handle); @@ -8786,6 +10334,10 @@ double wickra_order_book_imbalance_top_n_update(struct OrderBookImbalanceTopN *h const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_book_imbalance_top_n_warmup_period(struct OrderBookImbalanceTopN *handle); + +bool wickra_order_book_imbalance_top_n_is_ready(struct OrderBookImbalanceTopN *handle); + void wickra_order_book_imbalance_top_n_reset(struct OrderBookImbalanceTopN *handle); void wickra_order_book_imbalance_top_n_free(struct OrderBookImbalanceTopN *handle); @@ -8800,6 +10352,10 @@ double wickra_order_flow_imbalance_update(struct OrderFlowImbalance *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_order_flow_imbalance_warmup_period(struct OrderFlowImbalance *handle); + +bool wickra_order_flow_imbalance_is_ready(struct OrderFlowImbalance *handle); + void wickra_order_flow_imbalance_reset(struct OrderFlowImbalance *handle); void wickra_order_flow_imbalance_free(struct OrderFlowImbalance *handle); @@ -8814,6 +10370,10 @@ double wickra_quoted_spread_update(struct QuotedSpread *handle, const double *ask_size, uintptr_t n_asks); +uintptr_t wickra_quoted_spread_warmup_period(struct QuotedSpread *handle); + +bool wickra_quoted_spread_is_ready(struct QuotedSpread *handle); + void wickra_quoted_spread_reset(struct QuotedSpread *handle); void wickra_quoted_spread_free(struct QuotedSpread *handle); @@ -8830,6 +10390,10 @@ double wickra_absolute_breadth_index_update(struct AbsoluteBreadthIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_absolute_breadth_index_warmup_period(struct AbsoluteBreadthIndex *handle); + +bool wickra_absolute_breadth_index_is_ready(struct AbsoluteBreadthIndex *handle); + void wickra_absolute_breadth_index_reset(struct AbsoluteBreadthIndex *handle); void wickra_absolute_breadth_index_free(struct AbsoluteBreadthIndex *handle); @@ -8846,6 +10410,10 @@ double wickra_ad_volume_line_update(struct AdVolumeLine *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_ad_volume_line_warmup_period(struct AdVolumeLine *handle); + +bool wickra_ad_volume_line_is_ready(struct AdVolumeLine *handle); + void wickra_ad_volume_line_reset(struct AdVolumeLine *handle); void wickra_ad_volume_line_free(struct AdVolumeLine *handle); @@ -8862,6 +10430,10 @@ double wickra_advance_decline_update(struct AdvanceDecline *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_advance_decline_warmup_period(struct AdvanceDecline *handle); + +bool wickra_advance_decline_is_ready(struct AdvanceDecline *handle); + void wickra_advance_decline_reset(struct AdvanceDecline *handle); void wickra_advance_decline_free(struct AdvanceDecline *handle); @@ -8878,6 +10450,10 @@ double wickra_advance_decline_ratio_update(struct AdvanceDeclineRatio *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_advance_decline_ratio_warmup_period(struct AdvanceDeclineRatio *handle); + +bool wickra_advance_decline_ratio_is_ready(struct AdvanceDeclineRatio *handle); + void wickra_advance_decline_ratio_reset(struct AdvanceDeclineRatio *handle); void wickra_advance_decline_ratio_free(struct AdvanceDeclineRatio *handle); @@ -8894,6 +10470,10 @@ double wickra_breadth_thrust_update(struct BreadthThrust *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_breadth_thrust_warmup_period(struct BreadthThrust *handle); + +bool wickra_breadth_thrust_is_ready(struct BreadthThrust *handle); + void wickra_breadth_thrust_reset(struct BreadthThrust *handle); void wickra_breadth_thrust_free(struct BreadthThrust *handle); @@ -8910,6 +10490,10 @@ double wickra_bullish_percent_index_update(struct BullishPercentIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_bullish_percent_index_warmup_period(struct BullishPercentIndex *handle); + +bool wickra_bullish_percent_index_is_ready(struct BullishPercentIndex *handle); + void wickra_bullish_percent_index_reset(struct BullishPercentIndex *handle); void wickra_bullish_percent_index_free(struct BullishPercentIndex *handle); @@ -8926,6 +10510,10 @@ double wickra_cumulative_volume_index_update(struct CumulativeVolumeIndex *handl uintptr_t n, int64_t timestamp); +uintptr_t wickra_cumulative_volume_index_warmup_period(struct CumulativeVolumeIndex *handle); + +bool wickra_cumulative_volume_index_is_ready(struct CumulativeVolumeIndex *handle); + void wickra_cumulative_volume_index_reset(struct CumulativeVolumeIndex *handle); void wickra_cumulative_volume_index_free(struct CumulativeVolumeIndex *handle); @@ -8942,6 +10530,10 @@ double wickra_high_low_index_update(struct HighLowIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_high_low_index_warmup_period(struct HighLowIndex *handle); + +bool wickra_high_low_index_is_ready(struct HighLowIndex *handle); + void wickra_high_low_index_reset(struct HighLowIndex *handle); void wickra_high_low_index_free(struct HighLowIndex *handle); @@ -8958,6 +10550,10 @@ double wickra_mc_clellan_oscillator_update(struct McClellanOscillator *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_mc_clellan_oscillator_warmup_period(struct McClellanOscillator *handle); + +bool wickra_mc_clellan_oscillator_is_ready(struct McClellanOscillator *handle); + void wickra_mc_clellan_oscillator_reset(struct McClellanOscillator *handle); void wickra_mc_clellan_oscillator_free(struct McClellanOscillator *handle); @@ -8974,6 +10570,10 @@ double wickra_mc_clellan_summation_index_update(struct McClellanSummationIndex * uintptr_t n, int64_t timestamp); +uintptr_t wickra_mc_clellan_summation_index_warmup_period(struct McClellanSummationIndex *handle); + +bool wickra_mc_clellan_summation_index_is_ready(struct McClellanSummationIndex *handle); + void wickra_mc_clellan_summation_index_reset(struct McClellanSummationIndex *handle); void wickra_mc_clellan_summation_index_free(struct McClellanSummationIndex *handle); @@ -8990,6 +10590,10 @@ double wickra_new_highs_new_lows_update(struct NewHighsNewLows *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_new_highs_new_lows_warmup_period(struct NewHighsNewLows *handle); + +bool wickra_new_highs_new_lows_is_ready(struct NewHighsNewLows *handle); + void wickra_new_highs_new_lows_reset(struct NewHighsNewLows *handle); void wickra_new_highs_new_lows_free(struct NewHighsNewLows *handle); @@ -9006,6 +10610,10 @@ double wickra_percent_above_ma_update(struct PercentAboveMa *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_percent_above_ma_warmup_period(struct PercentAboveMa *handle); + +bool wickra_percent_above_ma_is_ready(struct PercentAboveMa *handle); + void wickra_percent_above_ma_reset(struct PercentAboveMa *handle); void wickra_percent_above_ma_free(struct PercentAboveMa *handle); @@ -9022,6 +10630,10 @@ double wickra_tick_index_update(struct TickIndex *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_tick_index_warmup_period(struct TickIndex *handle); + +bool wickra_tick_index_is_ready(struct TickIndex *handle); + void wickra_tick_index_reset(struct TickIndex *handle); void wickra_tick_index_free(struct TickIndex *handle); @@ -9038,6 +10650,10 @@ double wickra_trin_update(struct Trin *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_trin_warmup_period(struct Trin *handle); + +bool wickra_trin_is_ready(struct Trin *handle); + void wickra_trin_reset(struct Trin *handle); void wickra_trin_free(struct Trin *handle); @@ -9054,6 +10670,10 @@ double wickra_up_down_volume_ratio_update(struct UpDownVolumeRatio *handle, uintptr_t n, int64_t timestamp); +uintptr_t wickra_up_down_volume_ratio_warmup_period(struct UpDownVolumeRatio *handle); + +bool wickra_up_down_volume_ratio_is_ready(struct UpDownVolumeRatio *handle); + void wickra_up_down_volume_ratio_reset(struct UpDownVolumeRatio *handle); void wickra_up_down_volume_ratio_free(struct UpDownVolumeRatio *handle); @@ -9069,6 +10689,10 @@ bool wickra_acceleration_bands_update(struct AccelerationBands *handle, int64_t timestamp, struct WickraAccelerationBandsOutput *out); +uintptr_t wickra_acceleration_bands_warmup_period(struct AccelerationBands *handle); + +bool wickra_acceleration_bands_is_ready(struct AccelerationBands *handle); + void wickra_acceleration_bands_reset(struct AccelerationBands *handle); void wickra_acceleration_bands_free(struct AccelerationBands *handle); @@ -9084,6 +10708,10 @@ bool wickra_adx_update(struct Adx *handle, int64_t timestamp, struct WickraAdxOutput *out); +uintptr_t wickra_adx_warmup_period(struct Adx *handle); + +bool wickra_adx_is_ready(struct Adx *handle); + void wickra_adx_reset(struct Adx *handle); void wickra_adx_free(struct Adx *handle); @@ -9101,6 +10729,10 @@ bool wickra_alligator_update(struct Alligator *handle, int64_t timestamp, struct WickraAlligatorOutput *out); +uintptr_t wickra_alligator_warmup_period(struct Alligator *handle); + +bool wickra_alligator_is_ready(struct Alligator *handle); + void wickra_alligator_reset(struct Alligator *handle); void wickra_alligator_free(struct Alligator *handle); @@ -9116,6 +10748,10 @@ bool wickra_andrews_pitchfork_update(struct AndrewsPitchfork *handle, int64_t timestamp, struct WickraAndrewsPitchforkOutput *out); +uintptr_t wickra_andrews_pitchfork_warmup_period(struct AndrewsPitchfork *handle); + +bool wickra_andrews_pitchfork_is_ready(struct AndrewsPitchfork *handle); + void wickra_andrews_pitchfork_reset(struct AndrewsPitchfork *handle); void wickra_andrews_pitchfork_free(struct AndrewsPitchfork *handle); @@ -9131,6 +10767,10 @@ bool wickra_aroon_update(struct Aroon *handle, int64_t timestamp, struct WickraAroonOutput *out); +uintptr_t wickra_aroon_warmup_period(struct Aroon *handle); + +bool wickra_aroon_is_ready(struct Aroon *handle); + void wickra_aroon_reset(struct Aroon *handle); void wickra_aroon_free(struct Aroon *handle); @@ -9146,6 +10786,10 @@ bool wickra_atr_bands_update(struct AtrBands *handle, int64_t timestamp, struct WickraAtrBandsOutput *out); +uintptr_t wickra_atr_bands_warmup_period(struct AtrBands *handle); + +bool wickra_atr_bands_is_ready(struct AtrBands *handle); + void wickra_atr_bands_reset(struct AtrBands *handle); void wickra_atr_bands_free(struct AtrBands *handle); @@ -9163,6 +10807,10 @@ bool wickra_atr_ratchet_update(struct AtrRatchet *handle, int64_t timestamp, struct WickraAtrRatchetOutput *out); +uintptr_t wickra_atr_ratchet_warmup_period(struct AtrRatchet *handle); + +bool wickra_atr_ratchet_is_ready(struct AtrRatchet *handle); + void wickra_atr_ratchet_reset(struct AtrRatchet *handle); void wickra_atr_ratchet_free(struct AtrRatchet *handle); @@ -9178,6 +10826,10 @@ bool wickra_auto_fib_update(struct AutoFib *handle, int64_t timestamp, struct WickraAutoFibOutput *out); +uintptr_t wickra_auto_fib_warmup_period(struct AutoFib *handle); + +bool wickra_auto_fib_is_ready(struct AutoFib *handle); + void wickra_auto_fib_reset(struct AutoFib *handle); void wickra_auto_fib_free(struct AutoFib *handle); @@ -9188,6 +10840,10 @@ bool wickra_bollinger_bands_update(struct BollingerBands *handle, double value, struct WickraBollingerOutput *out); +uintptr_t wickra_bollinger_bands_warmup_period(struct BollingerBands *handle); + +bool wickra_bollinger_bands_is_ready(struct BollingerBands *handle); + void wickra_bollinger_bands_reset(struct BollingerBands *handle); void wickra_bollinger_bands_free(struct BollingerBands *handle); @@ -9198,6 +10854,10 @@ bool wickra_bomar_bands_update(struct BomarBands *handle, double value, struct WickraBomarBandsOutput *out); +uintptr_t wickra_bomar_bands_warmup_period(struct BomarBands *handle); + +bool wickra_bomar_bands_is_ready(struct BomarBands *handle); + void wickra_bomar_bands_reset(struct BomarBands *handle); void wickra_bomar_bands_free(struct BomarBands *handle); @@ -9213,6 +10873,10 @@ bool wickra_camarilla_update(struct Camarilla *handle, int64_t timestamp, struct WickraCamarillaPivotsOutput *out); +uintptr_t wickra_camarilla_warmup_period(struct Camarilla *handle); + +bool wickra_camarilla_is_ready(struct Camarilla *handle); + void wickra_camarilla_reset(struct Camarilla *handle); void wickra_camarilla_free(struct Camarilla *handle); @@ -9228,6 +10892,10 @@ bool wickra_candle_volume_update(struct CandleVolume *handle, int64_t timestamp, struct WickraCandleVolumeOutput *out); +uintptr_t wickra_candle_volume_warmup_period(struct CandleVolume *handle); + +bool wickra_candle_volume_is_ready(struct CandleVolume *handle); + void wickra_candle_volume_reset(struct CandleVolume *handle); void wickra_candle_volume_free(struct CandleVolume *handle); @@ -9243,6 +10911,10 @@ bool wickra_central_pivot_range_update(struct CentralPivotRange *handle, int64_t timestamp, struct WickraCentralPivotRangeOutput *out); +uintptr_t wickra_central_pivot_range_warmup_period(struct CentralPivotRange *handle); + +bool wickra_central_pivot_range_is_ready(struct CentralPivotRange *handle); + void wickra_central_pivot_range_reset(struct CentralPivotRange *handle); void wickra_central_pivot_range_free(struct CentralPivotRange *handle); @@ -9260,6 +10932,10 @@ bool wickra_chande_kroll_stop_update(struct ChandeKrollStop *handle, int64_t timestamp, struct WickraChandeKrollStopOutput *out); +uintptr_t wickra_chande_kroll_stop_warmup_period(struct ChandeKrollStop *handle); + +bool wickra_chande_kroll_stop_is_ready(struct ChandeKrollStop *handle); + void wickra_chande_kroll_stop_reset(struct ChandeKrollStop *handle); void wickra_chande_kroll_stop_free(struct ChandeKrollStop *handle); @@ -9275,6 +10951,10 @@ bool wickra_chandelier_exit_update(struct ChandelierExit *handle, int64_t timestamp, struct WickraChandelierExitOutput *out); +uintptr_t wickra_chandelier_exit_warmup_period(struct ChandelierExit *handle); + +bool wickra_chandelier_exit_is_ready(struct ChandelierExit *handle); + void wickra_chandelier_exit_reset(struct ChandelierExit *handle); void wickra_chandelier_exit_free(struct ChandelierExit *handle); @@ -9290,6 +10970,10 @@ bool wickra_classic_pivots_update(struct ClassicPivots *handle, int64_t timestamp, struct WickraClassicPivotsOutput *out); +uintptr_t wickra_classic_pivots_warmup_period(struct ClassicPivots *handle); + +bool wickra_classic_pivots_is_ready(struct ClassicPivots *handle); + void wickra_classic_pivots_reset(struct ClassicPivots *handle); void wickra_classic_pivots_free(struct ClassicPivots *handle); @@ -9301,6 +10985,10 @@ bool wickra_cointegration_update(struct Cointegration *handle, double y, struct WickraCointegrationOutput *out); +uintptr_t wickra_cointegration_warmup_period(struct Cointegration *handle); + +bool wickra_cointegration_is_ready(struct Cointegration *handle); + void wickra_cointegration_reset(struct Cointegration *handle); void wickra_cointegration_free(struct Cointegration *handle); @@ -9318,6 +11006,10 @@ bool wickra_composite_profile_update(struct CompositeProfile *handle, int64_t timestamp, struct WickraCompositeProfileOutput *out); +uintptr_t wickra_composite_profile_warmup_period(struct CompositeProfile *handle); + +bool wickra_composite_profile_is_ready(struct CompositeProfile *handle); + void wickra_composite_profile_reset(struct CompositeProfile *handle); void wickra_composite_profile_free(struct CompositeProfile *handle); @@ -9333,6 +11025,10 @@ bool wickra_demark_pivots_update(struct DemarkPivots *handle, int64_t timestamp, struct WickraDemarkPivotsOutput *out); +uintptr_t wickra_demark_pivots_warmup_period(struct DemarkPivots *handle); + +bool wickra_demark_pivots_is_ready(struct DemarkPivots *handle); + void wickra_demark_pivots_reset(struct DemarkPivots *handle); void wickra_demark_pivots_free(struct DemarkPivots *handle); @@ -9348,6 +11044,10 @@ bool wickra_donchian_update(struct Donchian *handle, int64_t timestamp, struct WickraDonchianOutput *out); +uintptr_t wickra_donchian_warmup_period(struct Donchian *handle); + +bool wickra_donchian_is_ready(struct Donchian *handle); + void wickra_donchian_reset(struct Donchian *handle); void wickra_donchian_free(struct Donchian *handle); @@ -9363,6 +11063,10 @@ bool wickra_donchian_stop_update(struct DonchianStop *handle, int64_t timestamp, struct WickraDonchianStopOutput *out); +uintptr_t wickra_donchian_stop_warmup_period(struct DonchianStop *handle); + +bool wickra_donchian_stop_is_ready(struct DonchianStop *handle); + void wickra_donchian_stop_reset(struct DonchianStop *handle); void wickra_donchian_stop_free(struct DonchianStop *handle); @@ -9375,6 +11079,10 @@ bool wickra_double_bollinger_update(struct DoubleBollinger *handle, double value, struct WickraDoubleBollingerOutput *out); +uintptr_t wickra_double_bollinger_warmup_period(struct DoubleBollinger *handle); + +bool wickra_double_bollinger_is_ready(struct DoubleBollinger *handle); + void wickra_double_bollinger_reset(struct DoubleBollinger *handle); void wickra_double_bollinger_free(struct DoubleBollinger *handle); @@ -9390,6 +11098,10 @@ bool wickra_elder_ray_update(struct ElderRay *handle, int64_t timestamp, struct WickraElderRayOutput *out); +uintptr_t wickra_elder_ray_warmup_period(struct ElderRay *handle); + +bool wickra_elder_ray_is_ready(struct ElderRay *handle); + void wickra_elder_ray_reset(struct ElderRay *handle); void wickra_elder_ray_free(struct ElderRay *handle); @@ -9405,6 +11117,10 @@ bool wickra_elder_safe_zone_update(struct ElderSafeZone *handle, int64_t timestamp, struct WickraElderSafeZoneOutput *out); +uintptr_t wickra_elder_safe_zone_warmup_period(struct ElderSafeZone *handle); + +bool wickra_elder_safe_zone_is_ready(struct ElderSafeZone *handle); + void wickra_elder_safe_zone_reset(struct ElderSafeZone *handle); void wickra_elder_safe_zone_free(struct ElderSafeZone *handle); @@ -9420,6 +11136,10 @@ bool wickra_equivolume_update(struct Equivolume *handle, int64_t timestamp, struct WickraEquivolumeOutput *out); +uintptr_t wickra_equivolume_warmup_period(struct Equivolume *handle); + +bool wickra_equivolume_is_ready(struct Equivolume *handle); + void wickra_equivolume_reset(struct Equivolume *handle); void wickra_equivolume_free(struct Equivolume *handle); @@ -9435,6 +11155,10 @@ bool wickra_fib_arcs_update(struct FibArcs *handle, int64_t timestamp, struct WickraFibArcsOutput *out); +uintptr_t wickra_fib_arcs_warmup_period(struct FibArcs *handle); + +bool wickra_fib_arcs_is_ready(struct FibArcs *handle); + void wickra_fib_arcs_reset(struct FibArcs *handle); void wickra_fib_arcs_free(struct FibArcs *handle); @@ -9450,6 +11174,10 @@ bool wickra_fib_channel_update(struct FibChannel *handle, int64_t timestamp, struct WickraFibChannelOutput *out); +uintptr_t wickra_fib_channel_warmup_period(struct FibChannel *handle); + +bool wickra_fib_channel_is_ready(struct FibChannel *handle); + void wickra_fib_channel_reset(struct FibChannel *handle); void wickra_fib_channel_free(struct FibChannel *handle); @@ -9465,6 +11193,10 @@ bool wickra_fib_confluence_update(struct FibConfluence *handle, int64_t timestamp, struct WickraFibConfluenceOutput *out); +uintptr_t wickra_fib_confluence_warmup_period(struct FibConfluence *handle); + +bool wickra_fib_confluence_is_ready(struct FibConfluence *handle); + void wickra_fib_confluence_reset(struct FibConfluence *handle); void wickra_fib_confluence_free(struct FibConfluence *handle); @@ -9480,6 +11212,10 @@ bool wickra_fib_extension_update(struct FibExtension *handle, int64_t timestamp, struct WickraFibExtensionOutput *out); +uintptr_t wickra_fib_extension_warmup_period(struct FibExtension *handle); + +bool wickra_fib_extension_is_ready(struct FibExtension *handle); + void wickra_fib_extension_reset(struct FibExtension *handle); void wickra_fib_extension_free(struct FibExtension *handle); @@ -9495,6 +11231,10 @@ bool wickra_fib_fan_update(struct FibFan *handle, int64_t timestamp, struct WickraFibFanOutput *out); +uintptr_t wickra_fib_fan_warmup_period(struct FibFan *handle); + +bool wickra_fib_fan_is_ready(struct FibFan *handle); + void wickra_fib_fan_reset(struct FibFan *handle); void wickra_fib_fan_free(struct FibFan *handle); @@ -9510,6 +11250,10 @@ bool wickra_fib_projection_update(struct FibProjection *handle, int64_t timestamp, struct WickraFibProjectionOutput *out); +uintptr_t wickra_fib_projection_warmup_period(struct FibProjection *handle); + +bool wickra_fib_projection_is_ready(struct FibProjection *handle); + void wickra_fib_projection_reset(struct FibProjection *handle); void wickra_fib_projection_free(struct FibProjection *handle); @@ -9525,6 +11269,10 @@ bool wickra_fib_retracement_update(struct FibRetracement *handle, int64_t timestamp, struct WickraFibRetracementOutput *out); +uintptr_t wickra_fib_retracement_warmup_period(struct FibRetracement *handle); + +bool wickra_fib_retracement_is_ready(struct FibRetracement *handle); + void wickra_fib_retracement_reset(struct FibRetracement *handle); void wickra_fib_retracement_free(struct FibRetracement *handle); @@ -9540,6 +11288,10 @@ bool wickra_fib_time_zones_update(struct FibTimeZones *handle, int64_t timestamp, struct WickraFibTimeZonesOutput *out); +uintptr_t wickra_fib_time_zones_warmup_period(struct FibTimeZones *handle); + +bool wickra_fib_time_zones_is_ready(struct FibTimeZones *handle); + void wickra_fib_time_zones_reset(struct FibTimeZones *handle); void wickra_fib_time_zones_free(struct FibTimeZones *handle); @@ -9555,6 +11307,10 @@ bool wickra_fibonacci_pivots_update(struct FibonacciPivots *handle, int64_t timestamp, struct WickraFibonacciPivotsOutput *out); +uintptr_t wickra_fibonacci_pivots_warmup_period(struct FibonacciPivots *handle); + +bool wickra_fibonacci_pivots_is_ready(struct FibonacciPivots *handle); + void wickra_fibonacci_pivots_reset(struct FibonacciPivots *handle); void wickra_fibonacci_pivots_free(struct FibonacciPivots *handle); @@ -9570,6 +11326,10 @@ bool wickra_fractal_chaos_bands_update(struct FractalChaosBands *handle, int64_t timestamp, struct WickraFractalChaosBandsOutput *out); +uintptr_t wickra_fractal_chaos_bands_warmup_period(struct FractalChaosBands *handle); + +bool wickra_fractal_chaos_bands_is_ready(struct FractalChaosBands *handle); + void wickra_fractal_chaos_bands_reset(struct FractalChaosBands *handle); void wickra_fractal_chaos_bands_free(struct FractalChaosBands *handle); @@ -9587,6 +11347,10 @@ bool wickra_gator_oscillator_update(struct GatorOscillator *handle, int64_t timestamp, struct WickraGatorOscillatorOutput *out); +uintptr_t wickra_gator_oscillator_warmup_period(struct GatorOscillator *handle); + +bool wickra_gator_oscillator_is_ready(struct GatorOscillator *handle); + void wickra_gator_oscillator_reset(struct GatorOscillator *handle); void wickra_gator_oscillator_free(struct GatorOscillator *handle); @@ -9602,6 +11366,10 @@ bool wickra_golden_pocket_update(struct GoldenPocket *handle, int64_t timestamp, struct WickraGoldenPocketOutput *out); +uintptr_t wickra_golden_pocket_warmup_period(struct GoldenPocket *handle); + +bool wickra_golden_pocket_is_ready(struct GoldenPocket *handle); + void wickra_golden_pocket_reset(struct GoldenPocket *handle); void wickra_golden_pocket_free(struct GoldenPocket *handle); @@ -9617,6 +11385,10 @@ bool wickra_heikin_ashi_update(struct HeikinAshi *handle, int64_t timestamp, struct WickraHeikinAshiOutput *out); +uintptr_t wickra_heikin_ashi_warmup_period(struct HeikinAshi *handle); + +bool wickra_heikin_ashi_is_ready(struct HeikinAshi *handle); + void wickra_heikin_ashi_reset(struct HeikinAshi *handle); void wickra_heikin_ashi_free(struct HeikinAshi *handle); @@ -9632,6 +11404,10 @@ bool wickra_high_low_volume_nodes_update(struct HighLowVolumeNodes *handle, int64_t timestamp, struct WickraHighLowVolumeNodesOutput *out); +uintptr_t wickra_high_low_volume_nodes_warmup_period(struct HighLowVolumeNodes *handle); + +bool wickra_high_low_volume_nodes_is_ready(struct HighLowVolumeNodes *handle); + void wickra_high_low_volume_nodes_reset(struct HighLowVolumeNodes *handle); void wickra_high_low_volume_nodes_free(struct HighLowVolumeNodes *handle); @@ -9642,6 +11418,10 @@ bool wickra_ht_phasor_update(struct HtPhasor *handle, double value, struct WickraHtPhasorOutput *out); +uintptr_t wickra_ht_phasor_warmup_period(struct HtPhasor *handle); + +bool wickra_ht_phasor_is_ready(struct HtPhasor *handle); + void wickra_ht_phasor_reset(struct HtPhasor *handle); void wickra_ht_phasor_free(struct HtPhasor *handle); @@ -9657,6 +11437,10 @@ bool wickra_hurst_channel_update(struct HurstChannel *handle, int64_t timestamp, struct WickraHurstChannelOutput *out); +uintptr_t wickra_hurst_channel_warmup_period(struct HurstChannel *handle); + +bool wickra_hurst_channel_is_ready(struct HurstChannel *handle); + void wickra_hurst_channel_reset(struct HurstChannel *handle); void wickra_hurst_channel_free(struct HurstChannel *handle); @@ -9675,6 +11459,10 @@ bool wickra_ichimoku_update(struct Ichimoku *handle, int64_t timestamp, struct WickraIchimokuOutput *out); +uintptr_t wickra_ichimoku_warmup_period(struct Ichimoku *handle); + +bool wickra_ichimoku_is_ready(struct Ichimoku *handle); + void wickra_ichimoku_reset(struct Ichimoku *handle); void wickra_ichimoku_free(struct Ichimoku *handle); @@ -9690,6 +11478,10 @@ bool wickra_initial_balance_update(struct InitialBalance *handle, int64_t timestamp, struct WickraInitialBalanceOutput *out); +uintptr_t wickra_initial_balance_warmup_period(struct InitialBalance *handle); + +bool wickra_initial_balance_is_ready(struct InitialBalance *handle); + void wickra_initial_balance_reset(struct InitialBalance *handle); void wickra_initial_balance_free(struct InitialBalance *handle); @@ -9701,6 +11493,10 @@ bool wickra_kalman_hedge_ratio_update(struct KalmanHedgeRatio *handle, double y, struct WickraKalmanHedgeRatioOutput *out); +uintptr_t wickra_kalman_hedge_ratio_warmup_period(struct KalmanHedgeRatio *handle); + +bool wickra_kalman_hedge_ratio_is_ready(struct KalmanHedgeRatio *handle); + void wickra_kalman_hedge_ratio_reset(struct KalmanHedgeRatio *handle); void wickra_kalman_hedge_ratio_free(struct KalmanHedgeRatio *handle); @@ -9716,6 +11512,10 @@ bool wickra_kase_dev_stop_update(struct KaseDevStop *handle, int64_t timestamp, struct WickraKaseDevStopOutput *out); +uintptr_t wickra_kase_dev_stop_warmup_period(struct KaseDevStop *handle); + +bool wickra_kase_dev_stop_is_ready(struct KaseDevStop *handle); + void wickra_kase_dev_stop_reset(struct KaseDevStop *handle); void wickra_kase_dev_stop_free(struct KaseDevStop *handle); @@ -9732,6 +11532,10 @@ bool wickra_kase_permission_stochastic_update(struct KasePermissionStochastic *h int64_t timestamp, struct WickraKasePermissionStochasticOutput *out); +uintptr_t wickra_kase_permission_stochastic_warmup_period(struct KasePermissionStochastic *handle); + +bool wickra_kase_permission_stochastic_is_ready(struct KasePermissionStochastic *handle); + void wickra_kase_permission_stochastic_reset(struct KasePermissionStochastic *handle); void wickra_kase_permission_stochastic_free(struct KasePermissionStochastic *handle); @@ -9747,6 +11551,10 @@ bool wickra_keltner_update(struct Keltner *handle, int64_t timestamp, struct WickraKeltnerOutput *out); +uintptr_t wickra_keltner_warmup_period(struct Keltner *handle); + +bool wickra_keltner_is_ready(struct Keltner *handle); + void wickra_keltner_reset(struct Keltner *handle); void wickra_keltner_free(struct Keltner *handle); @@ -9763,6 +11571,10 @@ struct Kst *wickra_kst_new(uintptr_t roc1, bool wickra_kst_update(struct Kst *handle, double value, struct WickraKstOutput *out); +uintptr_t wickra_kst_warmup_period(struct Kst *handle); + +bool wickra_kst_is_ready(struct Kst *handle); + void wickra_kst_reset(struct Kst *handle); void wickra_kst_free(struct Kst *handle); @@ -9775,6 +11587,10 @@ bool wickra_lead_lag_cross_correlation_update(struct LeadLagCrossCorrelation *ha double y, struct WickraLeadLagCrossCorrelationOutput *out); +uintptr_t wickra_lead_lag_cross_correlation_warmup_period(struct LeadLagCrossCorrelation *handle); + +bool wickra_lead_lag_cross_correlation_is_ready(struct LeadLagCrossCorrelation *handle); + void wickra_lead_lag_cross_correlation_reset(struct LeadLagCrossCorrelation *handle); void wickra_lead_lag_cross_correlation_free(struct LeadLagCrossCorrelation *handle); @@ -9785,6 +11601,10 @@ bool wickra_lin_reg_channel_update(struct LinRegChannel *handle, double value, struct WickraLinRegChannelOutput *out); +uintptr_t wickra_lin_reg_channel_warmup_period(struct LinRegChannel *handle); + +bool wickra_lin_reg_channel_is_ready(struct LinRegChannel *handle); + void wickra_lin_reg_channel_reset(struct LinRegChannel *handle); void wickra_lin_reg_channel_free(struct LinRegChannel *handle); @@ -9806,6 +11626,10 @@ bool wickra_liquidation_features_update(struct LiquidationFeatures *handle, int64_t timestamp, struct WickraLiquidationFeaturesOutput *out); +uintptr_t wickra_liquidation_features_warmup_period(struct LiquidationFeatures *handle); + +bool wickra_liquidation_features_is_ready(struct LiquidationFeatures *handle); + void wickra_liquidation_features_reset(struct LiquidationFeatures *handle); void wickra_liquidation_features_free(struct LiquidationFeatures *handle); @@ -9816,6 +11640,10 @@ bool wickra_ma_envelope_update(struct MaEnvelope *handle, double value, struct WickraMaEnvelopeOutput *out); +uintptr_t wickra_ma_envelope_warmup_period(struct MaEnvelope *handle); + +bool wickra_ma_envelope_is_ready(struct MaEnvelope *handle); + void wickra_ma_envelope_reset(struct MaEnvelope *handle); void wickra_ma_envelope_free(struct MaEnvelope *handle); @@ -9826,6 +11654,10 @@ bool wickra_macd_indicator_update(struct MacdIndicator *handle, double value, struct WickraMacdOutput *out); +uintptr_t wickra_macd_indicator_warmup_period(struct MacdIndicator *handle); + +bool wickra_macd_indicator_is_ready(struct MacdIndicator *handle); + void wickra_macd_indicator_reset(struct MacdIndicator *handle); void wickra_macd_indicator_free(struct MacdIndicator *handle); @@ -9834,6 +11666,10 @@ struct MacdFix *wickra_macd_fix_new(uintptr_t signal); bool wickra_macd_fix_update(struct MacdFix *handle, double value, struct WickraMacdOutput *out); +uintptr_t wickra_macd_fix_warmup_period(struct MacdFix *handle); + +bool wickra_macd_fix_is_ready(struct MacdFix *handle); + void wickra_macd_fix_reset(struct MacdFix *handle); void wickra_macd_fix_free(struct MacdFix *handle); @@ -9842,6 +11678,10 @@ struct Mama *wickra_mama_new(double fast_limit, double slow_limit); bool wickra_mama_update(struct Mama *handle, double value, struct WickraMamaOutput *out); +uintptr_t wickra_mama_warmup_period(struct Mama *handle); + +bool wickra_mama_is_ready(struct Mama *handle); + void wickra_mama_reset(struct Mama *handle); void wickra_mama_free(struct Mama *handle); @@ -9852,6 +11692,10 @@ bool wickra_median_channel_update(struct MedianChannel *handle, double value, struct WickraMedianChannelOutput *out); +uintptr_t wickra_median_channel_warmup_period(struct MedianChannel *handle); + +bool wickra_median_channel_is_ready(struct MedianChannel *handle); + void wickra_median_channel_reset(struct MedianChannel *handle); void wickra_median_channel_free(struct MedianChannel *handle); @@ -9867,6 +11711,10 @@ bool wickra_modified_ma_stop_update(struct ModifiedMaStop *handle, int64_t timestamp, struct WickraModifiedMaStopOutput *out); +uintptr_t wickra_modified_ma_stop_warmup_period(struct ModifiedMaStop *handle); + +bool wickra_modified_ma_stop_is_ready(struct ModifiedMaStop *handle); + void wickra_modified_ma_stop_reset(struct ModifiedMaStop *handle); void wickra_modified_ma_stop_free(struct ModifiedMaStop *handle); @@ -9882,6 +11730,10 @@ bool wickra_murrey_math_lines_update(struct MurreyMathLines *handle, int64_t timestamp, struct WickraMurreyMathLinesOutput *out); +uintptr_t wickra_murrey_math_lines_warmup_period(struct MurreyMathLines *handle); + +bool wickra_murrey_math_lines_is_ready(struct MurreyMathLines *handle); + void wickra_murrey_math_lines_reset(struct MurreyMathLines *handle); void wickra_murrey_math_lines_free(struct MurreyMathLines *handle); @@ -9897,6 +11749,10 @@ bool wickra_nrtr_update(struct Nrtr *handle, int64_t timestamp, struct WickraNrtrOutput *out); +uintptr_t wickra_nrtr_warmup_period(struct Nrtr *handle); + +bool wickra_nrtr_is_ready(struct Nrtr *handle); + void wickra_nrtr_reset(struct Nrtr *handle); void wickra_nrtr_free(struct Nrtr *handle); @@ -9912,6 +11768,10 @@ bool wickra_opening_range_update(struct OpeningRange *handle, int64_t timestamp, struct WickraOpeningRangeOutput *out); +uintptr_t wickra_opening_range_warmup_period(struct OpeningRange *handle); + +bool wickra_opening_range_is_ready(struct OpeningRange *handle); + void wickra_opening_range_reset(struct OpeningRange *handle); void wickra_opening_range_free(struct OpeningRange *handle); @@ -9927,6 +11787,10 @@ bool wickra_overnight_intraday_return_update(struct OvernightIntradayReturn *han int64_t timestamp, struct WickraOvernightIntradayReturnOutput *out); +uintptr_t wickra_overnight_intraday_return_warmup_period(struct OvernightIntradayReturn *handle); + +bool wickra_overnight_intraday_return_is_ready(struct OvernightIntradayReturn *handle); + void wickra_overnight_intraday_return_reset(struct OvernightIntradayReturn *handle); void wickra_overnight_intraday_return_free(struct OvernightIntradayReturn *handle); @@ -9942,6 +11806,10 @@ bool wickra_projection_bands_update(struct ProjectionBands *handle, int64_t timestamp, struct WickraProjectionBandsOutput *out); +uintptr_t wickra_projection_bands_warmup_period(struct ProjectionBands *handle); + +bool wickra_projection_bands_is_ready(struct ProjectionBands *handle); + void wickra_projection_bands_reset(struct ProjectionBands *handle); void wickra_projection_bands_free(struct ProjectionBands *handle); @@ -9950,6 +11818,10 @@ struct Qqe *wickra_qqe_new(uintptr_t rsi_period, uintptr_t smoothing, double fac bool wickra_qqe_update(struct Qqe *handle, double value, struct WickraQqeOutput *out); +uintptr_t wickra_qqe_warmup_period(struct Qqe *handle); + +bool wickra_qqe_is_ready(struct Qqe *handle); + void wickra_qqe_reset(struct Qqe *handle); void wickra_qqe_free(struct Qqe *handle); @@ -9960,6 +11832,10 @@ bool wickra_quartile_bands_update(struct QuartileBands *handle, double value, struct WickraQuartileBandsOutput *out); +uintptr_t wickra_quartile_bands_warmup_period(struct QuartileBands *handle); + +bool wickra_quartile_bands_is_ready(struct QuartileBands *handle); + void wickra_quartile_bands_reset(struct QuartileBands *handle); void wickra_quartile_bands_free(struct QuartileBands *handle); @@ -9972,6 +11848,10 @@ bool wickra_relative_strength_ab_update(struct RelativeStrengthAB *handle, double y, struct WickraRelativeStrengthOutput *out); +uintptr_t wickra_relative_strength_ab_warmup_period(struct RelativeStrengthAB *handle); + +bool wickra_relative_strength_ab_is_ready(struct RelativeStrengthAB *handle); + void wickra_relative_strength_ab_reset(struct RelativeStrengthAB *handle); void wickra_relative_strength_ab_free(struct RelativeStrengthAB *handle); @@ -9987,6 +11867,10 @@ bool wickra_rwi_update(struct Rwi *handle, int64_t timestamp, struct WickraRwiOutput *out); +uintptr_t wickra_rwi_warmup_period(struct Rwi *handle); + +bool wickra_rwi_is_ready(struct Rwi *handle); + void wickra_rwi_reset(struct Rwi *handle); void wickra_rwi_free(struct Rwi *handle); @@ -10002,6 +11886,10 @@ bool wickra_session_high_low_update(struct SessionHighLow *handle, int64_t timestamp, struct WickraSessionHighLowOutput *out); +uintptr_t wickra_session_high_low_warmup_period(struct SessionHighLow *handle); + +bool wickra_session_high_low_is_ready(struct SessionHighLow *handle); + void wickra_session_high_low_reset(struct SessionHighLow *handle); void wickra_session_high_low_free(struct SessionHighLow *handle); @@ -10017,6 +11905,10 @@ bool wickra_session_range_update(struct SessionRange *handle, int64_t timestamp, struct WickraSessionRangeOutput *out); +uintptr_t wickra_session_range_warmup_period(struct SessionRange *handle); + +bool wickra_session_range_is_ready(struct SessionRange *handle); + void wickra_session_range_reset(struct SessionRange *handle); void wickra_session_range_free(struct SessionRange *handle); @@ -10032,6 +11924,10 @@ bool wickra_smoothed_heikin_ashi_update(struct SmoothedHeikinAshi *handle, int64_t timestamp, struct WickraSmoothedHeikinAshiOutput *out); +uintptr_t wickra_smoothed_heikin_ashi_warmup_period(struct SmoothedHeikinAshi *handle); + +bool wickra_smoothed_heikin_ashi_is_ready(struct SmoothedHeikinAshi *handle); + void wickra_smoothed_heikin_ashi_reset(struct SmoothedHeikinAshi *handle); void wickra_smoothed_heikin_ashi_free(struct SmoothedHeikinAshi *handle); @@ -10043,6 +11939,10 @@ bool wickra_spread_bollinger_bands_update(struct SpreadBollingerBands *handle, double y, struct WickraSpreadBollingerBandsOutput *out); +uintptr_t wickra_spread_bollinger_bands_warmup_period(struct SpreadBollingerBands *handle); + +bool wickra_spread_bollinger_bands_is_ready(struct SpreadBollingerBands *handle); + void wickra_spread_bollinger_bands_reset(struct SpreadBollingerBands *handle); void wickra_spread_bollinger_bands_free(struct SpreadBollingerBands *handle); @@ -10053,6 +11953,10 @@ bool wickra_standard_error_bands_update(struct StandardErrorBands *handle, double value, struct WickraStandardErrorBandsOutput *out); +uintptr_t wickra_standard_error_bands_warmup_period(struct StandardErrorBands *handle); + +bool wickra_standard_error_bands_is_ready(struct StandardErrorBands *handle); + void wickra_standard_error_bands_reset(struct StandardErrorBands *handle); void wickra_standard_error_bands_free(struct StandardErrorBands *handle); @@ -10070,6 +11974,10 @@ bool wickra_starc_bands_update(struct StarcBands *handle, int64_t timestamp, struct WickraStarcBandsOutput *out); +uintptr_t wickra_starc_bands_warmup_period(struct StarcBands *handle); + +bool wickra_starc_bands_is_ready(struct StarcBands *handle); + void wickra_starc_bands_reset(struct StarcBands *handle); void wickra_starc_bands_free(struct StarcBands *handle); @@ -10085,6 +11993,10 @@ bool wickra_stochastic_update(struct Stochastic *handle, int64_t timestamp, struct WickraStochasticOutput *out); +uintptr_t wickra_stochastic_warmup_period(struct Stochastic *handle); + +bool wickra_stochastic_is_ready(struct Stochastic *handle); + void wickra_stochastic_reset(struct Stochastic *handle); void wickra_stochastic_free(struct Stochastic *handle); @@ -10100,6 +12012,10 @@ bool wickra_super_trend_update(struct SuperTrend *handle, int64_t timestamp, struct WickraSuperTrendOutput *out); +uintptr_t wickra_super_trend_warmup_period(struct SuperTrend *handle); + +bool wickra_super_trend_is_ready(struct SuperTrend *handle); + void wickra_super_trend_reset(struct SuperTrend *handle); void wickra_super_trend_free(struct SuperTrend *handle); @@ -10115,6 +12031,10 @@ bool wickra_td_lines_update(struct TdLines *handle, int64_t timestamp, struct WickraTdLinesOutput *out); +uintptr_t wickra_td_lines_warmup_period(struct TdLines *handle); + +bool wickra_td_lines_is_ready(struct TdLines *handle); + void wickra_td_lines_reset(struct TdLines *handle); void wickra_td_lines_free(struct TdLines *handle); @@ -10130,6 +12050,10 @@ bool wickra_td_moving_average_update(struct TdMovingAverage *handle, int64_t timestamp, struct WickraTdMovingAverageOutput *out); +uintptr_t wickra_td_moving_average_warmup_period(struct TdMovingAverage *handle); + +bool wickra_td_moving_average_is_ready(struct TdMovingAverage *handle); + void wickra_td_moving_average_reset(struct TdMovingAverage *handle); void wickra_td_moving_average_free(struct TdMovingAverage *handle); @@ -10145,6 +12069,10 @@ bool wickra_td_range_projection_update(struct TdRangeProjection *handle, int64_t timestamp, struct WickraTdRangeProjectionOutput *out); +uintptr_t wickra_td_range_projection_warmup_period(struct TdRangeProjection *handle); + +bool wickra_td_range_projection_is_ready(struct TdRangeProjection *handle); + void wickra_td_range_projection_reset(struct TdRangeProjection *handle); void wickra_td_range_projection_free(struct TdRangeProjection *handle); @@ -10160,6 +12088,10 @@ bool wickra_td_risk_level_update(struct TdRiskLevel *handle, int64_t timestamp, struct WickraTdRiskLevelOutput *out); +uintptr_t wickra_td_risk_level_warmup_period(struct TdRiskLevel *handle); + +bool wickra_td_risk_level_is_ready(struct TdRiskLevel *handle); + void wickra_td_risk_level_reset(struct TdRiskLevel *handle); void wickra_td_risk_level_free(struct TdRiskLevel *handle); @@ -10178,6 +12110,10 @@ bool wickra_td_sequential_update(struct TdSequential *handle, int64_t timestamp, struct WickraTdSequentialOutput *out); +uintptr_t wickra_td_sequential_warmup_period(struct TdSequential *handle); + +bool wickra_td_sequential_is_ready(struct TdSequential *handle); + void wickra_td_sequential_reset(struct TdSequential *handle); void wickra_td_sequential_free(struct TdSequential *handle); @@ -10193,6 +12129,10 @@ bool wickra_ttm_squeeze_update(struct TtmSqueeze *handle, int64_t timestamp, struct WickraTtmSqueezeOutput *out); +uintptr_t wickra_ttm_squeeze_warmup_period(struct TtmSqueeze *handle); + +bool wickra_ttm_squeeze_is_ready(struct TtmSqueeze *handle); + void wickra_ttm_squeeze_reset(struct TtmSqueeze *handle); void wickra_ttm_squeeze_free(struct TtmSqueeze *handle); @@ -10210,6 +12150,10 @@ bool wickra_value_area_update(struct ValueArea *handle, int64_t timestamp, struct WickraValueAreaOutput *out); +uintptr_t wickra_value_area_warmup_period(struct ValueArea *handle); + +bool wickra_value_area_is_ready(struct ValueArea *handle); + void wickra_value_area_reset(struct ValueArea *handle); void wickra_value_area_free(struct ValueArea *handle); @@ -10225,6 +12169,10 @@ bool wickra_volatility_cone_update(struct VolatilityCone *handle, int64_t timestamp, struct WickraVolatilityConeOutput *out); +uintptr_t wickra_volatility_cone_warmup_period(struct VolatilityCone *handle); + +bool wickra_volatility_cone_is_ready(struct VolatilityCone *handle); + void wickra_volatility_cone_reset(struct VolatilityCone *handle); void wickra_volatility_cone_free(struct VolatilityCone *handle); @@ -10242,6 +12190,10 @@ bool wickra_volume_weighted_macd_update(struct VolumeWeightedMacd *handle, int64_t timestamp, struct WickraVolumeWeightedMacdOutput *out); +uintptr_t wickra_volume_weighted_macd_warmup_period(struct VolumeWeightedMacd *handle); + +bool wickra_volume_weighted_macd_is_ready(struct VolumeWeightedMacd *handle); + void wickra_volume_weighted_macd_reset(struct VolumeWeightedMacd *handle); void wickra_volume_weighted_macd_free(struct VolumeWeightedMacd *handle); @@ -10257,6 +12209,10 @@ bool wickra_volume_weighted_sr_update(struct VolumeWeightedSr *handle, int64_t timestamp, struct WickraVolumeWeightedSrOutput *out); +uintptr_t wickra_volume_weighted_sr_warmup_period(struct VolumeWeightedSr *handle); + +bool wickra_volume_weighted_sr_is_ready(struct VolumeWeightedSr *handle); + void wickra_volume_weighted_sr_reset(struct VolumeWeightedSr *handle); void wickra_volume_weighted_sr_free(struct VolumeWeightedSr *handle); @@ -10272,6 +12228,10 @@ bool wickra_vortex_update(struct Vortex *handle, int64_t timestamp, struct WickraVortexOutput *out); +uintptr_t wickra_vortex_warmup_period(struct Vortex *handle); + +bool wickra_vortex_is_ready(struct Vortex *handle); + void wickra_vortex_reset(struct Vortex *handle); void wickra_vortex_free(struct Vortex *handle); @@ -10287,6 +12247,10 @@ bool wickra_vwap_std_dev_bands_update(struct VwapStdDevBands *handle, int64_t timestamp, struct WickraVwapStdDevBandsOutput *out); +uintptr_t wickra_vwap_std_dev_bands_warmup_period(struct VwapStdDevBands *handle); + +bool wickra_vwap_std_dev_bands_is_ready(struct VwapStdDevBands *handle); + void wickra_vwap_std_dev_bands_reset(struct VwapStdDevBands *handle); void wickra_vwap_std_dev_bands_free(struct VwapStdDevBands *handle); @@ -10304,6 +12268,10 @@ bool wickra_wave_trend_update(struct WaveTrend *handle, int64_t timestamp, struct WickraWaveTrendOutput *out); +uintptr_t wickra_wave_trend_warmup_period(struct WaveTrend *handle); + +bool wickra_wave_trend_is_ready(struct WaveTrend *handle); + void wickra_wave_trend_reset(struct WaveTrend *handle); void wickra_wave_trend_free(struct WaveTrend *handle); @@ -10319,6 +12287,10 @@ bool wickra_williams_fractals_update(struct WilliamsFractals *handle, int64_t timestamp, struct WickraWilliamsFractalsOutput *out); +uintptr_t wickra_williams_fractals_warmup_period(struct WilliamsFractals *handle); + +bool wickra_williams_fractals_is_ready(struct WilliamsFractals *handle); + void wickra_williams_fractals_reset(struct WilliamsFractals *handle); void wickra_williams_fractals_free(struct WilliamsFractals *handle); @@ -10334,6 +12306,10 @@ bool wickra_woodie_pivots_update(struct WoodiePivots *handle, int64_t timestamp, struct WickraWoodiePivotsOutput *out); +uintptr_t wickra_woodie_pivots_warmup_period(struct WoodiePivots *handle); + +bool wickra_woodie_pivots_is_ready(struct WoodiePivots *handle); + void wickra_woodie_pivots_reset(struct WoodiePivots *handle); void wickra_woodie_pivots_free(struct WoodiePivots *handle); @@ -10344,6 +12320,10 @@ bool wickra_zero_lag_macd_update(struct ZeroLagMacd *handle, double value, struct WickraZeroLagMacdOutput *out); +uintptr_t wickra_zero_lag_macd_warmup_period(struct ZeroLagMacd *handle); + +bool wickra_zero_lag_macd_is_ready(struct ZeroLagMacd *handle); + void wickra_zero_lag_macd_reset(struct ZeroLagMacd *handle); void wickra_zero_lag_macd_free(struct ZeroLagMacd *handle); @@ -10359,6 +12339,10 @@ bool wickra_zig_zag_update(struct ZigZag *handle, int64_t timestamp, struct WickraZigZagOutput *out); +uintptr_t wickra_zig_zag_warmup_period(struct ZigZag *handle); + +bool wickra_zig_zag_is_ready(struct ZigZag *handle); + void wickra_zig_zag_reset(struct ZigZag *handle); void wickra_zig_zag_free(struct ZigZag *handle); @@ -10375,6 +12359,10 @@ intptr_t wickra_day_of_week_profile_update(struct DayOfWeekProfile *handle, double *values, uintptr_t cap); +uintptr_t wickra_day_of_week_profile_warmup_period(struct DayOfWeekProfile *handle); + +bool wickra_day_of_week_profile_is_ready(struct DayOfWeekProfile *handle); + void wickra_day_of_week_profile_reset(struct DayOfWeekProfile *handle); void wickra_day_of_week_profile_free(struct DayOfWeekProfile *handle); @@ -10392,6 +12380,10 @@ intptr_t wickra_intraday_volatility_profile_update(struct IntradayVolatilityProf double *values, uintptr_t cap); +uintptr_t wickra_intraday_volatility_profile_warmup_period(struct IntradayVolatilityProfile *handle); + +bool wickra_intraday_volatility_profile_is_ready(struct IntradayVolatilityProfile *handle); + void wickra_intraday_volatility_profile_reset(struct IntradayVolatilityProfile *handle); void wickra_intraday_volatility_profile_free(struct IntradayVolatilityProfile *handle); @@ -10409,6 +12401,10 @@ intptr_t wickra_time_of_day_return_profile_update(struct TimeOfDayReturnProfile double *values, uintptr_t cap); +uintptr_t wickra_time_of_day_return_profile_warmup_period(struct TimeOfDayReturnProfile *handle); + +bool wickra_time_of_day_return_profile_is_ready(struct TimeOfDayReturnProfile *handle); + void wickra_time_of_day_return_profile_reset(struct TimeOfDayReturnProfile *handle); void wickra_time_of_day_return_profile_free(struct TimeOfDayReturnProfile *handle); @@ -10426,6 +12422,10 @@ intptr_t wickra_tpo_profile_update(struct TpoProfile *handle, double *values, uintptr_t cap); +uintptr_t wickra_tpo_profile_warmup_period(struct TpoProfile *handle); + +bool wickra_tpo_profile_is_ready(struct TpoProfile *handle); + void wickra_tpo_profile_reset(struct TpoProfile *handle); void wickra_tpo_profile_free(struct TpoProfile *handle); @@ -10443,6 +12443,10 @@ intptr_t wickra_volume_by_time_profile_update(struct VolumeByTimeProfile *handle double *values, uintptr_t cap); +uintptr_t wickra_volume_by_time_profile_warmup_period(struct VolumeByTimeProfile *handle); + +bool wickra_volume_by_time_profile_is_ready(struct VolumeByTimeProfile *handle); + void wickra_volume_by_time_profile_reset(struct VolumeByTimeProfile *handle); void wickra_volume_by_time_profile_free(struct VolumeByTimeProfile *handle); @@ -10460,6 +12464,10 @@ intptr_t wickra_volume_profile_update(struct VolumeProfile *handle, double *values, uintptr_t cap); +uintptr_t wickra_volume_profile_warmup_period(struct VolumeProfile *handle); + +bool wickra_volume_profile_is_ready(struct VolumeProfile *handle); + void wickra_volume_profile_reset(struct VolumeProfile *handle); void wickra_volume_profile_free(struct VolumeProfile *handle); @@ -10633,6 +12641,10 @@ struct MacdExt *wickra_macd_ext_new(uintptr_t fast, bool wickra_macd_ext_update(struct MacdExt *handle, double value, struct WickraMacdOutput *out); +uintptr_t wickra_macd_ext_warmup_period(struct MacdExt *handle); + +bool wickra_macd_ext_is_ready(struct MacdExt *handle); + void wickra_macd_ext_reset(struct MacdExt *handle); void wickra_macd_ext_free(struct MacdExt *handle); @@ -10647,6 +12659,10 @@ intptr_t wickra_footprint_update(struct Footprint *handle, struct WickraFootprintLevel *out, uintptr_t cap); +uintptr_t wickra_footprint_warmup_period(struct Footprint *handle); + +bool wickra_footprint_is_ready(struct Footprint *handle); + void wickra_footprint_reset(struct Footprint *handle); void wickra_footprint_free(struct Footprint *handle); diff --git a/bindings/go/indicators_gen.go b/bindings/go/indicators_gen.go index b2296ce4..7e76f499 100644 --- a/bindings/go/indicators_gen.go +++ b/bindings/go/indicators_gen.go @@ -775,6 +775,22 @@ func NewAbandonedBaby() (*AbandonedBaby, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AbandonedBaby) WarmupPeriod() int { + r := int(C.wickra_abandoned_baby_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AbandonedBaby) IsReady() bool { + r := bool(C.wickra_abandoned_baby_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AbandonedBaby) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -850,6 +866,22 @@ func NewAbcd() (*Abcd, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Abcd) WarmupPeriod() int { + r := int(C.wickra_abcd_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Abcd) IsReady() bool { + r := bool(C.wickra_abcd_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Abcd) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -925,6 +957,22 @@ func NewAbsoluteBreadthIndex() (*AbsoluteBreadthIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AbsoluteBreadthIndex) WarmupPeriod() int { + r := int(C.wickra_absolute_breadth_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AbsoluteBreadthIndex) IsReady() bool { + r := bool(C.wickra_absolute_breadth_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *AbsoluteBreadthIndex) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -987,6 +1035,22 @@ func NewAccelerationBands(period int, factor float64) (*AccelerationBands, error return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AccelerationBands) WarmupPeriod() int { + r := int(C.wickra_acceleration_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AccelerationBands) IsReady() bool { + r := bool(C.wickra_acceleration_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *AccelerationBands) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AccelerationBandsOutput, bool) { @@ -1032,6 +1096,22 @@ func NewAcceleratorOscillator(aoFast int, aoSlow int, signalPeriod int) (*Accele return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AcceleratorOscillator) WarmupPeriod() int { + r := int(C.wickra_accelerator_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AcceleratorOscillator) IsReady() bool { + r := bool(C.wickra_accelerator_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AcceleratorOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -1107,6 +1187,22 @@ func NewAdOscillator() (*AdOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdOscillator) WarmupPeriod() int { + r := int(C.wickra_ad_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdOscillator) IsReady() bool { + r := bool(C.wickra_ad_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AdOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -1182,6 +1278,22 @@ func NewAdVolumeLine() (*AdVolumeLine, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdVolumeLine) WarmupPeriod() int { + r := int(C.wickra_ad_volume_line_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdVolumeLine) IsReady() bool { + r := bool(C.wickra_ad_volume_line_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *AdVolumeLine) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -1244,6 +1356,22 @@ func NewAdaptiveCci(period int) (*AdaptiveCci, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdaptiveCci) WarmupPeriod() int { + r := int(C.wickra_adaptive_cci_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdaptiveCci) IsReady() bool { + r := bool(C.wickra_adaptive_cci_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AdaptiveCci) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -1319,6 +1447,22 @@ func NewAdaptiveCycle() (*AdaptiveCycle, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdaptiveCycle) WarmupPeriod() int { + r := int(C.wickra_adaptive_cycle_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdaptiveCycle) IsReady() bool { + r := bool(C.wickra_adaptive_cycle_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AdaptiveCycle) Update(value float64) float64 { @@ -1374,6 +1518,22 @@ func NewAdaptiveLaguerreFilter(period int) (*AdaptiveLaguerreFilter, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdaptiveLaguerreFilter) WarmupPeriod() int { + r := int(C.wickra_adaptive_laguerre_filter_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdaptiveLaguerreFilter) IsReady() bool { + r := bool(C.wickra_adaptive_laguerre_filter_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AdaptiveLaguerreFilter) Update(value float64) float64 { @@ -1429,6 +1589,22 @@ func NewAdaptiveRsi(period int) (*AdaptiveRsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdaptiveRsi) WarmupPeriod() int { + r := int(C.wickra_adaptive_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdaptiveRsi) IsReady() bool { + r := bool(C.wickra_adaptive_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AdaptiveRsi) Update(value float64) float64 { @@ -1484,6 +1660,22 @@ func NewAdl() (*Adl, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Adl) WarmupPeriod() int { + r := int(C.wickra_adl_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Adl) IsReady() bool { + r := bool(C.wickra_adl_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Adl) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -1559,6 +1751,22 @@ func NewAdvanceBlock() (*AdvanceBlock, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdvanceBlock) WarmupPeriod() int { + r := int(C.wickra_advance_block_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdvanceBlock) IsReady() bool { + r := bool(C.wickra_advance_block_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AdvanceBlock) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -1634,6 +1842,22 @@ func NewAdvanceDecline() (*AdvanceDecline, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdvanceDecline) WarmupPeriod() int { + r := int(C.wickra_advance_decline_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdvanceDecline) IsReady() bool { + r := bool(C.wickra_advance_decline_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *AdvanceDecline) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -1696,6 +1920,22 @@ func NewAdvanceDeclineRatio() (*AdvanceDeclineRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AdvanceDeclineRatio) WarmupPeriod() int { + r := int(C.wickra_advance_decline_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AdvanceDeclineRatio) IsReady() bool { + r := bool(C.wickra_advance_decline_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *AdvanceDeclineRatio) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -1758,6 +1998,22 @@ func NewAdx(period int) (*Adx, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Adx) WarmupPeriod() int { + r := int(C.wickra_adx_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Adx) IsReady() bool { + r := bool(C.wickra_adx_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Adx) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AdxOutput, bool) { @@ -1803,6 +2059,22 @@ func NewAdxr(period int) (*Adxr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Adxr) WarmupPeriod() int { + r := int(C.wickra_adxr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Adxr) IsReady() bool { + r := bool(C.wickra_adxr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Adxr) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -1878,6 +2150,22 @@ func NewAlligator(jawPeriod int, teethPeriod int, lipsPeriod int) (*Alligator, e return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Alligator) WarmupPeriod() int { + r := int(C.wickra_alligator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Alligator) IsReady() bool { + r := bool(C.wickra_alligator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Alligator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AlligatorOutput, bool) { @@ -1923,6 +2211,22 @@ func NewAlma(period int, offset float64, sigma float64) (*Alma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Alma) WarmupPeriod() int { + r := int(C.wickra_alma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Alma) IsReady() bool { + r := bool(C.wickra_alma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Alma) Update(value float64) float64 { @@ -1978,6 +2282,22 @@ func NewAlpha(period int, riskFree float64) (*Alpha, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Alpha) WarmupPeriod() int { + r := int(C.wickra_alpha_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Alpha) IsReady() bool { + r := bool(C.wickra_alpha_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Alpha) Update(x float64, y float64) float64 { @@ -2037,6 +2357,22 @@ func NewAmihudIlliquidity(period int) (*AmihudIlliquidity, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AmihudIlliquidity) WarmupPeriod() int { + r := int(C.wickra_amihud_illiquidity_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AmihudIlliquidity) IsReady() bool { + r := bool(C.wickra_amihud_illiquidity_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AmihudIlliquidity) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -2078,6 +2414,22 @@ func NewAnchoredRsi() (*AnchoredRsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AnchoredRsi) WarmupPeriod() int { + r := int(C.wickra_anchored_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AnchoredRsi) IsReady() bool { + r := bool(C.wickra_anchored_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AnchoredRsi) Update(value float64) float64 { @@ -2133,6 +2485,22 @@ func NewAnchoredVwap() (*AnchoredVwap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AnchoredVwap) WarmupPeriod() int { + r := int(C.wickra_anchored_vwap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AnchoredVwap) IsReady() bool { + r := bool(C.wickra_anchored_vwap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AnchoredVwap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -2208,6 +2576,22 @@ func NewAndrewsPitchfork(strength int) (*AndrewsPitchfork, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AndrewsPitchfork) WarmupPeriod() int { + r := int(C.wickra_andrews_pitchfork_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AndrewsPitchfork) IsReady() bool { + r := bool(C.wickra_andrews_pitchfork_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *AndrewsPitchfork) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AndrewsPitchforkOutput, bool) { @@ -2253,6 +2637,22 @@ func NewApo(fast int, slow int) (*Apo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Apo) WarmupPeriod() int { + r := int(C.wickra_apo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Apo) IsReady() bool { + r := bool(C.wickra_apo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Apo) Update(value float64) float64 { @@ -2308,6 +2708,22 @@ func NewAroon(period int) (*Aroon, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Aroon) WarmupPeriod() int { + r := int(C.wickra_aroon_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Aroon) IsReady() bool { + r := bool(C.wickra_aroon_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Aroon) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AroonOutput, bool) { @@ -2353,6 +2769,22 @@ func NewAroonOscillator(period int) (*AroonOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AroonOscillator) WarmupPeriod() int { + r := int(C.wickra_aroon_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AroonOscillator) IsReady() bool { + r := bool(C.wickra_aroon_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AroonOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -2428,6 +2860,22 @@ func NewAtr(period int) (*Atr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Atr) WarmupPeriod() int { + r := int(C.wickra_atr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Atr) IsReady() bool { + r := bool(C.wickra_atr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Atr) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -2503,6 +2951,22 @@ func NewAtrBands(period int, multiplier float64) (*AtrBands, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AtrBands) WarmupPeriod() int { + r := int(C.wickra_atr_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AtrBands) IsReady() bool { + r := bool(C.wickra_atr_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *AtrBands) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AtrBandsOutput, bool) { @@ -2548,6 +3012,22 @@ func NewAtrRatchet(atrPeriod int, startMult float64, increment float64) (*AtrRat return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AtrRatchet) WarmupPeriod() int { + r := int(C.wickra_atr_ratchet_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AtrRatchet) IsReady() bool { + r := bool(C.wickra_atr_ratchet_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *AtrRatchet) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AtrRatchetOutput, bool) { @@ -2593,6 +3073,22 @@ func NewAtrTrailingStop(atrPeriod int, multiplier float64) (*AtrTrailingStop, er return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AtrTrailingStop) WarmupPeriod() int { + r := int(C.wickra_atr_trailing_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AtrTrailingStop) IsReady() bool { + r := bool(C.wickra_atr_trailing_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AtrTrailingStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -2668,6 +3164,22 @@ func NewAutoFib() (*AutoFib, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AutoFib) WarmupPeriod() int { + r := int(C.wickra_auto_fib_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AutoFib) IsReady() bool { + r := bool(C.wickra_auto_fib_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *AutoFib) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (AutoFibOutput, bool) { @@ -2713,6 +3225,22 @@ func NewAutocorrelation(period int, lag int) (*Autocorrelation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Autocorrelation) WarmupPeriod() int { + r := int(C.wickra_autocorrelation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Autocorrelation) IsReady() bool { + r := bool(C.wickra_autocorrelation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Autocorrelation) Update(value float64) float64 { @@ -2768,6 +3296,22 @@ func NewAutocorrelationPeriodogram(minPeriod int, maxPeriod int) (*Autocorrelati return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AutocorrelationPeriodogram) WarmupPeriod() int { + r := int(C.wickra_autocorrelation_periodogram_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AutocorrelationPeriodogram) IsReady() bool { + r := bool(C.wickra_autocorrelation_periodogram_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AutocorrelationPeriodogram) Update(value float64) float64 { @@ -2823,6 +3367,22 @@ func NewAverageDailyRange(period int, utcOffsetMinutes int32) (*AverageDailyRang return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AverageDailyRange) WarmupPeriod() int { + r := int(C.wickra_average_daily_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AverageDailyRange) IsReady() bool { + r := bool(C.wickra_average_daily_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AverageDailyRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -2898,6 +3458,22 @@ func NewAverageDrawdown(period int) (*AverageDrawdown, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AverageDrawdown) WarmupPeriod() int { + r := int(C.wickra_average_drawdown_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AverageDrawdown) IsReady() bool { + r := bool(C.wickra_average_drawdown_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AverageDrawdown) Update(value float64) float64 { @@ -2953,6 +3529,22 @@ func NewAvgPrice() (*AvgPrice, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AvgPrice) WarmupPeriod() int { + r := int(C.wickra_avg_price_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AvgPrice) IsReady() bool { + r := bool(C.wickra_avg_price_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AvgPrice) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3028,6 +3620,22 @@ func NewAwesomeOscillator(fast int, slow int) (*AwesomeOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AwesomeOscillator) WarmupPeriod() int { + r := int(C.wickra_awesome_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AwesomeOscillator) IsReady() bool { + r := bool(C.wickra_awesome_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AwesomeOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3103,6 +3711,22 @@ func NewAwesomeOscillatorHistogram(fast int, slow int, smaPeriod int) (*AwesomeO return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *AwesomeOscillatorHistogram) WarmupPeriod() int { + r := int(C.wickra_awesome_oscillator_histogram_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *AwesomeOscillatorHistogram) IsReady() bool { + r := bool(C.wickra_awesome_oscillator_histogram_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *AwesomeOscillatorHistogram) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3178,6 +3802,22 @@ func NewBalanceOfPower() (*BalanceOfPower, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BalanceOfPower) WarmupPeriod() int { + r := int(C.wickra_balance_of_power_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BalanceOfPower) IsReady() bool { + r := bool(C.wickra_balance_of_power_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BalanceOfPower) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3253,6 +3893,22 @@ func NewBandpassFilter(period int, bandwidth float64) (*BandpassFilter, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BandpassFilter) WarmupPeriod() int { + r := int(C.wickra_bandpass_filter_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BandpassFilter) IsReady() bool { + r := bool(C.wickra_bandpass_filter_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BandpassFilter) Update(value float64) float64 { @@ -3308,6 +3964,22 @@ func NewBat() (*Bat, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Bat) WarmupPeriod() int { + r := int(C.wickra_bat_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Bat) IsReady() bool { + r := bool(C.wickra_bat_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Bat) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3383,6 +4055,22 @@ func NewBeltHold() (*BeltHold, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BeltHold) WarmupPeriod() int { + r := int(C.wickra_belt_hold_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BeltHold) IsReady() bool { + r := bool(C.wickra_belt_hold_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BeltHold) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3458,6 +4146,22 @@ func NewBeta(period int) (*Beta, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Beta) WarmupPeriod() int { + r := int(C.wickra_beta_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Beta) IsReady() bool { + r := bool(C.wickra_beta_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Beta) Update(x float64, y float64) float64 { @@ -3517,6 +4221,22 @@ func NewBetaNeutralSpread(period int) (*BetaNeutralSpread, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BetaNeutralSpread) WarmupPeriod() int { + r := int(C.wickra_beta_neutral_spread_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BetaNeutralSpread) IsReady() bool { + r := bool(C.wickra_beta_neutral_spread_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BetaNeutralSpread) Update(x float64, y float64) float64 { @@ -3576,6 +4296,22 @@ func NewBetterVolume(period int) (*BetterVolume, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BetterVolume) WarmupPeriod() int { + r := int(C.wickra_better_volume_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BetterVolume) IsReady() bool { + r := bool(C.wickra_better_volume_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BetterVolume) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3651,6 +4387,22 @@ func NewBipowerVariation(period int) (*BipowerVariation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BipowerVariation) WarmupPeriod() int { + r := int(C.wickra_bipower_variation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BipowerVariation) IsReady() bool { + r := bool(C.wickra_bipower_variation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BipowerVariation) Update(value float64) float64 { @@ -3706,6 +4458,22 @@ func NewBodySizePct() (*BodySizePct, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BodySizePct) WarmupPeriod() int { + r := int(C.wickra_body_size_pct_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BodySizePct) IsReady() bool { + r := bool(C.wickra_body_size_pct_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BodySizePct) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -3781,6 +4549,22 @@ func NewBollingerBands(period int, multiplier float64) (*BollingerBands, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BollingerBands) WarmupPeriod() int { + r := int(C.wickra_bollinger_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BollingerBands) IsReady() bool { + r := bool(C.wickra_bollinger_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *BollingerBands) Update(value float64) (BollingerOutput, bool) { @@ -3826,6 +4610,22 @@ func NewBollingerBandwidth(period int, multiplier float64) (*BollingerBandwidth, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BollingerBandwidth) WarmupPeriod() int { + r := int(C.wickra_bollinger_bandwidth_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BollingerBandwidth) IsReady() bool { + r := bool(C.wickra_bollinger_bandwidth_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BollingerBandwidth) Update(value float64) float64 { @@ -3881,6 +4681,22 @@ func NewBomarBands(period int, coverage float64) (*BomarBands, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BomarBands) WarmupPeriod() int { + r := int(C.wickra_bomar_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BomarBands) IsReady() bool { + r := bool(C.wickra_bomar_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *BomarBands) Update(value float64) (BomarBandsOutput, bool) { @@ -3926,6 +4742,22 @@ func NewBreadthThrust(period int) (*BreadthThrust, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BreadthThrust) WarmupPeriod() int { + r := int(C.wickra_breadth_thrust_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BreadthThrust) IsReady() bool { + r := bool(C.wickra_breadth_thrust_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *BreadthThrust) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -3988,6 +4820,22 @@ func NewBreakaway() (*Breakaway, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Breakaway) WarmupPeriod() int { + r := int(C.wickra_breakaway_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Breakaway) IsReady() bool { + r := bool(C.wickra_breakaway_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Breakaway) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -4063,6 +4911,22 @@ func NewBullishPercentIndex() (*BullishPercentIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BullishPercentIndex) WarmupPeriod() int { + r := int(C.wickra_bullish_percent_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BullishPercentIndex) IsReady() bool { + r := bool(C.wickra_bullish_percent_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *BullishPercentIndex) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -4125,6 +4989,22 @@ func NewBurkeRatio(period int) (*BurkeRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *BurkeRatio) WarmupPeriod() int { + r := int(C.wickra_burke_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *BurkeRatio) IsReady() bool { + r := bool(C.wickra_burke_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *BurkeRatio) Update(value float64) float64 { @@ -4180,6 +5060,22 @@ func NewButterfly() (*Butterfly, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Butterfly) WarmupPeriod() int { + r := int(C.wickra_butterfly_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Butterfly) IsReady() bool { + r := bool(C.wickra_butterfly_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Butterfly) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -4255,6 +5151,22 @@ func NewCalendarSpread() (*CalendarSpread, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CalendarSpread) WarmupPeriod() int { + r := int(C.wickra_calendar_spread_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CalendarSpread) IsReady() bool { + r := bool(C.wickra_calendar_spread_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CalendarSpread) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -4296,6 +5208,22 @@ func NewCalmarRatio(period int) (*CalmarRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CalmarRatio) WarmupPeriod() int { + r := int(C.wickra_calmar_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CalmarRatio) IsReady() bool { + r := bool(C.wickra_calmar_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CalmarRatio) Update(value float64) float64 { @@ -4351,6 +5279,22 @@ func NewCamarilla() (*Camarilla, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Camarilla) WarmupPeriod() int { + r := int(C.wickra_camarilla_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Camarilla) IsReady() bool { + r := bool(C.wickra_camarilla_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Camarilla) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (CamarillaPivotsOutput, bool) { @@ -4396,6 +5340,22 @@ func NewCandleVolume(period int) (*CandleVolume, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CandleVolume) WarmupPeriod() int { + r := int(C.wickra_candle_volume_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CandleVolume) IsReady() bool { + r := bool(C.wickra_candle_volume_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *CandleVolume) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (CandleVolumeOutput, bool) { @@ -4441,6 +5401,22 @@ func NewCci(period int) (*Cci, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Cci) WarmupPeriod() int { + r := int(C.wickra_cci_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Cci) IsReady() bool { + r := bool(C.wickra_cci_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Cci) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -4516,6 +5492,22 @@ func NewCenterOfGravity(period int) (*CenterOfGravity, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CenterOfGravity) WarmupPeriod() int { + r := int(C.wickra_center_of_gravity_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CenterOfGravity) IsReady() bool { + r := bool(C.wickra_center_of_gravity_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CenterOfGravity) Update(value float64) float64 { @@ -4571,6 +5563,22 @@ func NewCentralPivotRange() (*CentralPivotRange, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CentralPivotRange) WarmupPeriod() int { + r := int(C.wickra_central_pivot_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CentralPivotRange) IsReady() bool { + r := bool(C.wickra_central_pivot_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *CentralPivotRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (CentralPivotRangeOutput, bool) { @@ -4616,6 +5624,22 @@ func NewCfo(period int) (*Cfo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Cfo) WarmupPeriod() int { + r := int(C.wickra_cfo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Cfo) IsReady() bool { + r := bool(C.wickra_cfo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Cfo) Update(value float64) float64 { @@ -4671,6 +5695,22 @@ func NewChaikinMoneyFlow(period int) (*ChaikinMoneyFlow, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ChaikinMoneyFlow) WarmupPeriod() int { + r := int(C.wickra_chaikin_money_flow_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ChaikinMoneyFlow) IsReady() bool { + r := bool(C.wickra_chaikin_money_flow_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ChaikinMoneyFlow) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -4746,6 +5786,22 @@ func NewChaikinOscillator(fast int, slow int) (*ChaikinOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ChaikinOscillator) WarmupPeriod() int { + r := int(C.wickra_chaikin_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ChaikinOscillator) IsReady() bool { + r := bool(C.wickra_chaikin_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ChaikinOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -4821,6 +5877,22 @@ func NewChaikinVolatility(emaPeriod int, rocPeriod int) (*ChaikinVolatility, err return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ChaikinVolatility) WarmupPeriod() int { + r := int(C.wickra_chaikin_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ChaikinVolatility) IsReady() bool { + r := bool(C.wickra_chaikin_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ChaikinVolatility) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -4896,6 +5968,22 @@ func NewChandeKrollStop(atrPeriod int, atrMultiplier float64, stopPeriod int) (* return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ChandeKrollStop) WarmupPeriod() int { + r := int(C.wickra_chande_kroll_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ChandeKrollStop) IsReady() bool { + r := bool(C.wickra_chande_kroll_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ChandeKrollStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ChandeKrollStopOutput, bool) { @@ -4941,6 +6029,22 @@ func NewChandelierExit(period int, multiplier float64) (*ChandelierExit, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ChandelierExit) WarmupPeriod() int { + r := int(C.wickra_chandelier_exit_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ChandelierExit) IsReady() bool { + r := bool(C.wickra_chandelier_exit_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ChandelierExit) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ChandelierExitOutput, bool) { @@ -4986,6 +6090,22 @@ func NewChoppinessIndex(period int) (*ChoppinessIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ChoppinessIndex) WarmupPeriod() int { + r := int(C.wickra_choppiness_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ChoppinessIndex) IsReady() bool { + r := bool(C.wickra_choppiness_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ChoppinessIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -5061,6 +6181,22 @@ func NewClassicPivots() (*ClassicPivots, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ClassicPivots) WarmupPeriod() int { + r := int(C.wickra_classic_pivots_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ClassicPivots) IsReady() bool { + r := bool(C.wickra_classic_pivots_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ClassicPivots) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ClassicPivotsOutput, bool) { @@ -5106,6 +6242,22 @@ func NewCloseVsOpen() (*CloseVsOpen, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CloseVsOpen) WarmupPeriod() int { + r := int(C.wickra_close_vs_open_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CloseVsOpen) IsReady() bool { + r := bool(C.wickra_close_vs_open_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CloseVsOpen) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -5181,6 +6333,22 @@ func NewClosingMarubozu() (*ClosingMarubozu, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ClosingMarubozu) WarmupPeriod() int { + r := int(C.wickra_closing_marubozu_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ClosingMarubozu) IsReady() bool { + r := bool(C.wickra_closing_marubozu_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ClosingMarubozu) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -5256,6 +6424,22 @@ func NewCmo(period int) (*Cmo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Cmo) WarmupPeriod() int { + r := int(C.wickra_cmo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Cmo) IsReady() bool { + r := bool(C.wickra_cmo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Cmo) Update(value float64) float64 { @@ -5311,6 +6495,22 @@ func NewCoefficientOfVariation(period int) (*CoefficientOfVariation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CoefficientOfVariation) WarmupPeriod() int { + r := int(C.wickra_coefficient_of_variation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CoefficientOfVariation) IsReady() bool { + r := bool(C.wickra_coefficient_of_variation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CoefficientOfVariation) Update(value float64) float64 { @@ -5366,6 +6566,22 @@ func NewCointegration(period int, adfLags int) (*Cointegration, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Cointegration) WarmupPeriod() int { + r := int(C.wickra_cointegration_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Cointegration) IsReady() bool { + r := bool(C.wickra_cointegration_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Cointegration) Update(x float64, y float64) (CointegrationOutput, bool) { @@ -5411,6 +6627,22 @@ func NewCommonSenseRatio(period int) (*CommonSenseRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CommonSenseRatio) WarmupPeriod() int { + r := int(C.wickra_common_sense_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CommonSenseRatio) IsReady() bool { + r := bool(C.wickra_common_sense_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CommonSenseRatio) Update(value float64) float64 { @@ -5466,6 +6698,22 @@ func NewCompositeProfile(period int, bins int, valueAreaPct float64) (*Composite return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CompositeProfile) WarmupPeriod() int { + r := int(C.wickra_composite_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CompositeProfile) IsReady() bool { + r := bool(C.wickra_composite_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *CompositeProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (CompositeProfileOutput, bool) { @@ -5511,6 +6759,22 @@ func NewConcealingBabySwallow() (*ConcealingBabySwallow, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ConcealingBabySwallow) WarmupPeriod() int { + r := int(C.wickra_concealing_baby_swallow_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ConcealingBabySwallow) IsReady() bool { + r := bool(C.wickra_concealing_baby_swallow_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ConcealingBabySwallow) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -5586,6 +6850,22 @@ func NewConditionalValueAtRisk(period int, confidence float64) (*ConditionalValu return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ConditionalValueAtRisk) WarmupPeriod() int { + r := int(C.wickra_conditional_value_at_risk_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ConditionalValueAtRisk) IsReady() bool { + r := bool(C.wickra_conditional_value_at_risk_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ConditionalValueAtRisk) Update(value float64) float64 { @@ -5641,6 +6921,22 @@ func NewConnorsRsi(periodRsi int, periodStreak int, periodRank int) (*ConnorsRsi return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ConnorsRsi) WarmupPeriod() int { + r := int(C.wickra_connors_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ConnorsRsi) IsReady() bool { + r := bool(C.wickra_connors_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ConnorsRsi) Update(value float64) float64 { @@ -5696,6 +6992,22 @@ func NewCoppock(rocLongPeriod int, rocShortPeriod int, wmaPeriod int) (*Coppock, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Coppock) WarmupPeriod() int { + r := int(C.wickra_coppock_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Coppock) IsReady() bool { + r := bool(C.wickra_coppock_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Coppock) Update(value float64) float64 { @@ -5751,6 +7063,22 @@ func NewCorrelationTrendIndicator(period int) (*CorrelationTrendIndicator, error return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CorrelationTrendIndicator) WarmupPeriod() int { + r := int(C.wickra_correlation_trend_indicator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CorrelationTrendIndicator) IsReady() bool { + r := bool(C.wickra_correlation_trend_indicator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CorrelationTrendIndicator) Update(value float64) float64 { @@ -5806,6 +7134,22 @@ func NewCounterattack() (*Counterattack, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Counterattack) WarmupPeriod() int { + r := int(C.wickra_counterattack_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Counterattack) IsReady() bool { + r := bool(C.wickra_counterattack_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Counterattack) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -5881,6 +7225,22 @@ func NewCrab() (*Crab, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Crab) WarmupPeriod() int { + r := int(C.wickra_crab_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Crab) IsReady() bool { + r := bool(C.wickra_crab_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Crab) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -5956,6 +7316,22 @@ func NewCumulativeVolumeDelta() (*CumulativeVolumeDelta, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CumulativeVolumeDelta) WarmupPeriod() int { + r := int(C.wickra_cumulative_volume_delta_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CumulativeVolumeDelta) IsReady() bool { + r := bool(C.wickra_cumulative_volume_delta_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CumulativeVolumeDelta) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -5997,6 +7373,22 @@ func NewCumulativeVolumeIndex() (*CumulativeVolumeIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CumulativeVolumeIndex) WarmupPeriod() int { + r := int(C.wickra_cumulative_volume_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CumulativeVolumeIndex) IsReady() bool { + r := bool(C.wickra_cumulative_volume_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *CumulativeVolumeIndex) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -6059,6 +7451,22 @@ func NewCupAndHandle() (*CupAndHandle, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CupAndHandle) WarmupPeriod() int { + r := int(C.wickra_cup_and_handle_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CupAndHandle) IsReady() bool { + r := bool(C.wickra_cup_and_handle_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CupAndHandle) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -6134,6 +7542,22 @@ func NewCyberneticCycle(period int) (*CyberneticCycle, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *CyberneticCycle) WarmupPeriod() int { + r := int(C.wickra_cybernetic_cycle_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *CyberneticCycle) IsReady() bool { + r := bool(C.wickra_cybernetic_cycle_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *CyberneticCycle) Update(value float64) float64 { @@ -6189,6 +7613,22 @@ func NewCypher() (*Cypher, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Cypher) WarmupPeriod() int { + r := int(C.wickra_cypher_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Cypher) IsReady() bool { + r := bool(C.wickra_cypher_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Cypher) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -6266,6 +7706,22 @@ func NewDayOfWeekProfile(utcOffsetMinutes int32) (*DayOfWeekProfile, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DayOfWeekProfile) WarmupPeriod() int { + r := int(C.wickra_day_of_week_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DayOfWeekProfile) IsReady() bool { + r := bool(C.wickra_day_of_week_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the profile values // (ok is false during warmup). func (ind *DayOfWeekProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) ([]float64, bool) { @@ -6311,6 +7767,22 @@ func NewDecycler(period int) (*Decycler, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Decycler) WarmupPeriod() int { + r := int(C.wickra_decycler_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Decycler) IsReady() bool { + r := bool(C.wickra_decycler_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Decycler) Update(value float64) float64 { @@ -6366,6 +7838,22 @@ func NewDecyclerOscillator(fast int, slow int) (*DecyclerOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DecyclerOscillator) WarmupPeriod() int { + r := int(C.wickra_decycler_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DecyclerOscillator) IsReady() bool { + r := bool(C.wickra_decycler_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DecyclerOscillator) Update(value float64) float64 { @@ -6421,6 +7909,22 @@ func NewDema(period int) (*Dema, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Dema) WarmupPeriod() int { + r := int(C.wickra_dema_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Dema) IsReady() bool { + r := bool(C.wickra_dema_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Dema) Update(value float64) float64 { @@ -6476,6 +7980,22 @@ func NewDemandIndex(period int) (*DemandIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DemandIndex) WarmupPeriod() int { + r := int(C.wickra_demand_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DemandIndex) IsReady() bool { + r := bool(C.wickra_demand_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DemandIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -6551,6 +8071,22 @@ func NewDemarkPivots() (*DemarkPivots, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DemarkPivots) WarmupPeriod() int { + r := int(C.wickra_demark_pivots_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DemarkPivots) IsReady() bool { + r := bool(C.wickra_demark_pivots_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *DemarkPivots) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (DemarkPivotsOutput, bool) { @@ -6596,6 +8132,22 @@ func NewDepthSlope() (*DepthSlope, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DepthSlope) WarmupPeriod() int { + r := int(C.wickra_depth_slope_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DepthSlope) IsReady() bool { + r := bool(C.wickra_depth_slope_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *DepthSlope) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -6647,6 +8199,22 @@ func NewDerivativeOscillator(rsiPeriod int, smooth1 int, smooth2 int, signalPeri return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DerivativeOscillator) WarmupPeriod() int { + r := int(C.wickra_derivative_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DerivativeOscillator) IsReady() bool { + r := bool(C.wickra_derivative_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DerivativeOscillator) Update(value float64) float64 { @@ -6702,6 +8270,22 @@ func NewDetrendedStdDev(period int) (*DetrendedStdDev, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DetrendedStdDev) WarmupPeriod() int { + r := int(C.wickra_detrended_std_dev_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DetrendedStdDev) IsReady() bool { + r := bool(C.wickra_detrended_std_dev_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DetrendedStdDev) Update(value float64) float64 { @@ -6757,6 +8341,22 @@ func NewDisparityIndex(period int) (*DisparityIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DisparityIndex) WarmupPeriod() int { + r := int(C.wickra_disparity_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DisparityIndex) IsReady() bool { + r := bool(C.wickra_disparity_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DisparityIndex) Update(value float64) float64 { @@ -6812,6 +8412,22 @@ func NewDistanceSsd(period int) (*DistanceSsd, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DistanceSsd) WarmupPeriod() int { + r := int(C.wickra_distance_ssd_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DistanceSsd) IsReady() bool { + r := bool(C.wickra_distance_ssd_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DistanceSsd) Update(x float64, y float64) float64 { @@ -6871,6 +8487,22 @@ func NewDoji() (*Doji, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Doji) WarmupPeriod() int { + r := int(C.wickra_doji_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Doji) IsReady() bool { + r := bool(C.wickra_doji_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Doji) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -6946,6 +8578,22 @@ func NewDojiStar() (*DojiStar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DojiStar) WarmupPeriod() int { + r := int(C.wickra_doji_star_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DojiStar) IsReady() bool { + r := bool(C.wickra_doji_star_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DojiStar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7071,6 +8719,22 @@ func NewDonchian(period int) (*Donchian, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Donchian) WarmupPeriod() int { + r := int(C.wickra_donchian_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Donchian) IsReady() bool { + r := bool(C.wickra_donchian_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Donchian) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (DonchianOutput, bool) { @@ -7116,6 +8780,22 @@ func NewDonchianStop(period int) (*DonchianStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DonchianStop) WarmupPeriod() int { + r := int(C.wickra_donchian_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DonchianStop) IsReady() bool { + r := bool(C.wickra_donchian_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *DonchianStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (DonchianStopOutput, bool) { @@ -7161,6 +8841,22 @@ func NewDoubleBollinger(period int, kInner float64, kOuter float64) (*DoubleBoll return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DoubleBollinger) WarmupPeriod() int { + r := int(C.wickra_double_bollinger_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DoubleBollinger) IsReady() bool { + r := bool(C.wickra_double_bollinger_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *DoubleBollinger) Update(value float64) (DoubleBollingerOutput, bool) { @@ -7206,6 +8902,22 @@ func NewDoubleTopBottom() (*DoubleTopBottom, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DoubleTopBottom) WarmupPeriod() int { + r := int(C.wickra_double_top_bottom_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DoubleTopBottom) IsReady() bool { + r := bool(C.wickra_double_top_bottom_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DoubleTopBottom) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7281,6 +8993,22 @@ func NewDownsideGapThreeMethods() (*DownsideGapThreeMethods, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DownsideGapThreeMethods) WarmupPeriod() int { + r := int(C.wickra_downside_gap_three_methods_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DownsideGapThreeMethods) IsReady() bool { + r := bool(C.wickra_downside_gap_three_methods_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DownsideGapThreeMethods) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7356,6 +9084,22 @@ func NewDpo(period int) (*Dpo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Dpo) WarmupPeriod() int { + r := int(C.wickra_dpo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Dpo) IsReady() bool { + r := bool(C.wickra_dpo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Dpo) Update(value float64) float64 { @@ -7411,6 +9155,22 @@ func NewDragonflyDoji() (*DragonflyDoji, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DragonflyDoji) WarmupPeriod() int { + r := int(C.wickra_dragonfly_doji_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DragonflyDoji) IsReady() bool { + r := bool(C.wickra_dragonfly_doji_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DragonflyDoji) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7486,6 +9246,22 @@ func NewDrawdownDuration() (*DrawdownDuration, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DrawdownDuration) WarmupPeriod() int { + r := int(C.wickra_drawdown_duration_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DrawdownDuration) IsReady() bool { + r := bool(C.wickra_drawdown_duration_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DrawdownDuration) Update(value float64) float64 { @@ -7541,6 +9317,22 @@ func NewDumplingTop(period int) (*DumplingTop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DumplingTop) WarmupPeriod() int { + r := int(C.wickra_dumpling_top_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DumplingTop) IsReady() bool { + r := bool(C.wickra_dumpling_top_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DumplingTop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7616,6 +9408,22 @@ func NewDx(period int) (*Dx, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Dx) WarmupPeriod() int { + r := int(C.wickra_dx_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Dx) IsReady() bool { + r := bool(C.wickra_dx_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Dx) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7691,6 +9499,22 @@ func NewDynamicMomentumIndex(period int) (*DynamicMomentumIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *DynamicMomentumIndex) WarmupPeriod() int { + r := int(C.wickra_dynamic_momentum_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *DynamicMomentumIndex) IsReady() bool { + r := bool(C.wickra_dynamic_momentum_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *DynamicMomentumIndex) Update(value float64) float64 { @@ -7746,6 +9570,22 @@ func NewEaseOfMovement(period int) (*EaseOfMovement, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EaseOfMovement) WarmupPeriod() int { + r := int(C.wickra_ease_of_movement_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EaseOfMovement) IsReady() bool { + r := bool(C.wickra_ease_of_movement_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EaseOfMovement) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -7821,6 +9661,22 @@ func NewEffectiveSpread() (*EffectiveSpread, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EffectiveSpread) WarmupPeriod() int { + r := int(C.wickra_effective_spread_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EffectiveSpread) IsReady() bool { + r := bool(C.wickra_effective_spread_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EffectiveSpread) Update(price float64, size float64, isBuy bool, timestamp int64, mid float64) float64 { @@ -7862,6 +9718,22 @@ func NewEhlersStochastic(period int) (*EhlersStochastic, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EhlersStochastic) WarmupPeriod() int { + r := int(C.wickra_ehlers_stochastic_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EhlersStochastic) IsReady() bool { + r := bool(C.wickra_ehlers_stochastic_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EhlersStochastic) Update(value float64) float64 { @@ -7917,6 +9789,22 @@ func NewEhma(period int) (*Ehma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Ehma) WarmupPeriod() int { + r := int(C.wickra_ehma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Ehma) IsReady() bool { + r := bool(C.wickra_ehma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Ehma) Update(value float64) float64 { @@ -7972,6 +9860,22 @@ func NewElderImpulse(emaPeriod int, macdFast int, macdSlow int, macdSignal int) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ElderImpulse) WarmupPeriod() int { + r := int(C.wickra_elder_impulse_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ElderImpulse) IsReady() bool { + r := bool(C.wickra_elder_impulse_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ElderImpulse) Update(value float64) float64 { @@ -8027,6 +9931,22 @@ func NewElderRay(period int) (*ElderRay, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ElderRay) WarmupPeriod() int { + r := int(C.wickra_elder_ray_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ElderRay) IsReady() bool { + r := bool(C.wickra_elder_ray_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ElderRay) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ElderRayOutput, bool) { @@ -8072,6 +9992,22 @@ func NewElderSafeZone(period int, coeff float64) (*ElderSafeZone, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ElderSafeZone) WarmupPeriod() int { + r := int(C.wickra_elder_safe_zone_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ElderSafeZone) IsReady() bool { + r := bool(C.wickra_elder_safe_zone_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ElderSafeZone) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ElderSafeZoneOutput, bool) { @@ -8117,6 +10053,22 @@ func NewEma(period int) (*Ema, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Ema) WarmupPeriod() int { + r := int(C.wickra_ema_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Ema) IsReady() bool { + r := bool(C.wickra_ema_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Ema) Update(value float64) float64 { @@ -8172,6 +10124,22 @@ func NewEmpiricalModeDecomposition(period int, fraction float64) (*EmpiricalMode return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EmpiricalModeDecomposition) WarmupPeriod() int { + r := int(C.wickra_empirical_mode_decomposition_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EmpiricalModeDecomposition) IsReady() bool { + r := bool(C.wickra_empirical_mode_decomposition_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EmpiricalModeDecomposition) Update(value float64) float64 { @@ -8227,6 +10195,22 @@ func NewEngulfing() (*Engulfing, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Engulfing) WarmupPeriod() int { + r := int(C.wickra_engulfing_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Engulfing) IsReady() bool { + r := bool(C.wickra_engulfing_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Engulfing) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -8302,6 +10286,22 @@ func NewEquivolume(period int) (*Equivolume, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Equivolume) WarmupPeriod() int { + r := int(C.wickra_equivolume_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Equivolume) IsReady() bool { + r := bool(C.wickra_equivolume_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Equivolume) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (EquivolumeOutput, bool) { @@ -8347,6 +10347,22 @@ func NewEstimatedLeverageRatio() (*EstimatedLeverageRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EstimatedLeverageRatio) WarmupPeriod() int { + r := int(C.wickra_estimated_leverage_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EstimatedLeverageRatio) IsReady() bool { + r := bool(C.wickra_estimated_leverage_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EstimatedLeverageRatio) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -8388,6 +10404,22 @@ func NewEvenBetterSinewave(hpPeriod int, ssfLength int) (*EvenBetterSinewave, er return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EvenBetterSinewave) WarmupPeriod() int { + r := int(C.wickra_even_better_sinewave_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EvenBetterSinewave) IsReady() bool { + r := bool(C.wickra_even_better_sinewave_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EvenBetterSinewave) Update(value float64) float64 { @@ -8443,6 +10475,22 @@ func NewEveningDojiStar() (*EveningDojiStar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EveningDojiStar) WarmupPeriod() int { + r := int(C.wickra_evening_doji_star_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EveningDojiStar) IsReady() bool { + r := bool(C.wickra_evening_doji_star_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EveningDojiStar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -8518,6 +10566,22 @@ func NewEvwma(period int) (*Evwma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Evwma) WarmupPeriod() int { + r := int(C.wickra_evwma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Evwma) IsReady() bool { + r := bool(C.wickra_evwma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Evwma) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -8593,6 +10657,22 @@ func NewEwmaVolatility(lambda float64) (*EwmaVolatility, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *EwmaVolatility) WarmupPeriod() int { + r := int(C.wickra_ewma_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *EwmaVolatility) IsReady() bool { + r := bool(C.wickra_ewma_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *EwmaVolatility) Update(value float64) float64 { @@ -8648,6 +10728,22 @@ func NewExpectancy(period int) (*Expectancy, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Expectancy) WarmupPeriod() int { + r := int(C.wickra_expectancy_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Expectancy) IsReady() bool { + r := bool(C.wickra_expectancy_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Expectancy) Update(value float64) float64 { @@ -8703,6 +10799,22 @@ func NewFallingThreeMethods() (*FallingThreeMethods, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FallingThreeMethods) WarmupPeriod() int { + r := int(C.wickra_falling_three_methods_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FallingThreeMethods) IsReady() bool { + r := bool(C.wickra_falling_three_methods_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FallingThreeMethods) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -8778,6 +10890,22 @@ func NewFama(fastLimit float64, slowLimit float64) (*Fama, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Fama) WarmupPeriod() int { + r := int(C.wickra_fama_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Fama) IsReady() bool { + r := bool(C.wickra_fama_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Fama) Update(value float64) float64 { @@ -8833,6 +10961,22 @@ func NewFibArcs() (*FibArcs, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibArcs) WarmupPeriod() int { + r := int(C.wickra_fib_arcs_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibArcs) IsReady() bool { + r := bool(C.wickra_fib_arcs_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibArcs) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibArcsOutput, bool) { @@ -8878,6 +11022,22 @@ func NewFibChannel() (*FibChannel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibChannel) WarmupPeriod() int { + r := int(C.wickra_fib_channel_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibChannel) IsReady() bool { + r := bool(C.wickra_fib_channel_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibChannel) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibChannelOutput, bool) { @@ -8923,6 +11083,22 @@ func NewFibConfluence() (*FibConfluence, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibConfluence) WarmupPeriod() int { + r := int(C.wickra_fib_confluence_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibConfluence) IsReady() bool { + r := bool(C.wickra_fib_confluence_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibConfluence) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibConfluenceOutput, bool) { @@ -8968,6 +11144,22 @@ func NewFibExtension() (*FibExtension, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibExtension) WarmupPeriod() int { + r := int(C.wickra_fib_extension_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibExtension) IsReady() bool { + r := bool(C.wickra_fib_extension_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibExtension) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibExtensionOutput, bool) { @@ -9013,6 +11205,22 @@ func NewFibFan() (*FibFan, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibFan) WarmupPeriod() int { + r := int(C.wickra_fib_fan_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibFan) IsReady() bool { + r := bool(C.wickra_fib_fan_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibFan) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibFanOutput, bool) { @@ -9058,6 +11266,22 @@ func NewFibProjection() (*FibProjection, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibProjection) WarmupPeriod() int { + r := int(C.wickra_fib_projection_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibProjection) IsReady() bool { + r := bool(C.wickra_fib_projection_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibProjection) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibProjectionOutput, bool) { @@ -9103,6 +11327,22 @@ func NewFibRetracement() (*FibRetracement, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibRetracement) WarmupPeriod() int { + r := int(C.wickra_fib_retracement_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibRetracement) IsReady() bool { + r := bool(C.wickra_fib_retracement_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibRetracement) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibRetracementOutput, bool) { @@ -9148,6 +11388,22 @@ func NewFibTimeZones() (*FibTimeZones, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibTimeZones) WarmupPeriod() int { + r := int(C.wickra_fib_time_zones_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibTimeZones) IsReady() bool { + r := bool(C.wickra_fib_time_zones_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibTimeZones) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibTimeZonesOutput, bool) { @@ -9193,6 +11449,22 @@ func NewFibonacciPivots() (*FibonacciPivots, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FibonacciPivots) WarmupPeriod() int { + r := int(C.wickra_fibonacci_pivots_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FibonacciPivots) IsReady() bool { + r := bool(C.wickra_fibonacci_pivots_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FibonacciPivots) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FibonacciPivotsOutput, bool) { @@ -9238,6 +11510,22 @@ func NewFisherRsi(period int) (*FisherRsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FisherRsi) WarmupPeriod() int { + r := int(C.wickra_fisher_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FisherRsi) IsReady() bool { + r := bool(C.wickra_fisher_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FisherRsi) Update(value float64) float64 { @@ -9293,6 +11581,22 @@ func NewFisherTransform(period int) (*FisherTransform, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FisherTransform) WarmupPeriod() int { + r := int(C.wickra_fisher_transform_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FisherTransform) IsReady() bool { + r := bool(C.wickra_fisher_transform_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FisherTransform) Update(value float64) float64 { @@ -9348,6 +11652,22 @@ func NewFlagPennant() (*FlagPennant, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FlagPennant) WarmupPeriod() int { + r := int(C.wickra_flag_pennant_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FlagPennant) IsReady() bool { + r := bool(C.wickra_flag_pennant_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FlagPennant) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -9423,6 +11743,22 @@ func NewFootprint(tickSize float64) (*Footprint, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Footprint) WarmupPeriod() int { + r := int(C.wickra_footprint_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Footprint) IsReady() bool { + r := bool(C.wickra_footprint_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one candle and returns any bars completed by it // (a single candle may complete several). func (ind *Footprint) Update(price float64, size float64, isBuy bool, timestamp int64) []FootprintLevel { @@ -9473,6 +11809,22 @@ func NewForceIndex(period int) (*ForceIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ForceIndex) WarmupPeriod() int { + r := int(C.wickra_force_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ForceIndex) IsReady() bool { + r := bool(C.wickra_force_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ForceIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -9548,6 +11900,22 @@ func NewFractalChaosBands(k int) (*FractalChaosBands, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FractalChaosBands) WarmupPeriod() int { + r := int(C.wickra_fractal_chaos_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FractalChaosBands) IsReady() bool { + r := bool(C.wickra_fractal_chaos_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *FractalChaosBands) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (FractalChaosBandsOutput, bool) { @@ -9593,6 +11961,22 @@ func NewFrama(period int) (*Frama, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Frama) WarmupPeriod() int { + r := int(C.wickra_frama_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Frama) IsReady() bool { + r := bool(C.wickra_frama_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Frama) Update(value float64) float64 { @@ -9648,6 +12032,22 @@ func NewFryPanBottom(period int) (*FryPanBottom, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FryPanBottom) WarmupPeriod() int { + r := int(C.wickra_fry_pan_bottom_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FryPanBottom) IsReady() bool { + r := bool(C.wickra_fry_pan_bottom_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FryPanBottom) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -9723,6 +12123,22 @@ func NewFundingBasis() (*FundingBasis, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FundingBasis) WarmupPeriod() int { + r := int(C.wickra_funding_basis_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FundingBasis) IsReady() bool { + r := bool(C.wickra_funding_basis_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FundingBasis) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -9764,6 +12180,22 @@ func NewFundingImpliedApr(intervalsPerYear float64) (*FundingImpliedApr, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FundingImpliedApr) WarmupPeriod() int { + r := int(C.wickra_funding_implied_apr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FundingImpliedApr) IsReady() bool { + r := bool(C.wickra_funding_implied_apr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FundingImpliedApr) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -9805,6 +12237,22 @@ func NewFundingRate() (*FundingRate, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FundingRate) WarmupPeriod() int { + r := int(C.wickra_funding_rate_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FundingRate) IsReady() bool { + r := bool(C.wickra_funding_rate_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FundingRate) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -9846,6 +12294,22 @@ func NewFundingRateMean(window int) (*FundingRateMean, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FundingRateMean) WarmupPeriod() int { + r := int(C.wickra_funding_rate_mean_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FundingRateMean) IsReady() bool { + r := bool(C.wickra_funding_rate_mean_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FundingRateMean) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -9887,6 +12351,22 @@ func NewFundingRateZScore(window int) (*FundingRateZScore, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *FundingRateZScore) WarmupPeriod() int { + r := int(C.wickra_funding_rate_z_score_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *FundingRateZScore) IsReady() bool { + r := bool(C.wickra_funding_rate_z_score_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *FundingRateZScore) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -9928,6 +12408,22 @@ func NewGainLossRatio(period int) (*GainLossRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GainLossRatio) WarmupPeriod() int { + r := int(C.wickra_gain_loss_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GainLossRatio) IsReady() bool { + r := bool(C.wickra_gain_loss_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GainLossRatio) Update(value float64) float64 { @@ -9983,6 +12479,22 @@ func NewGainToPainRatio(period int) (*GainToPainRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GainToPainRatio) WarmupPeriod() int { + r := int(C.wickra_gain_to_pain_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GainToPainRatio) IsReady() bool { + r := bool(C.wickra_gain_to_pain_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GainToPainRatio) Update(value float64) float64 { @@ -10038,6 +12550,22 @@ func NewGapSideBySideWhite() (*GapSideBySideWhite, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GapSideBySideWhite) WarmupPeriod() int { + r := int(C.wickra_gap_side_by_side_white_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GapSideBySideWhite) IsReady() bool { + r := bool(C.wickra_gap_side_by_side_white_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GapSideBySideWhite) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10113,6 +12641,22 @@ func NewGarch11(omega float64, alpha float64, beta float64) (*Garch11, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Garch11) WarmupPeriod() int { + r := int(C.wickra_garch11_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Garch11) IsReady() bool { + r := bool(C.wickra_garch11_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Garch11) Update(value float64) float64 { @@ -10168,6 +12712,22 @@ func NewGarmanKlassVolatility(period int, tradingPeriods int) (*GarmanKlassVolat return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GarmanKlassVolatility) WarmupPeriod() int { + r := int(C.wickra_garman_klass_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GarmanKlassVolatility) IsReady() bool { + r := bool(C.wickra_garman_klass_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GarmanKlassVolatility) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10243,6 +12803,22 @@ func NewGartley() (*Gartley, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Gartley) WarmupPeriod() int { + r := int(C.wickra_gartley_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Gartley) IsReady() bool { + r := bool(C.wickra_gartley_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Gartley) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10318,6 +12894,22 @@ func NewGatorOscillator(jawPeriod int, teethPeriod int, lipsPeriod int) (*GatorO return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GatorOscillator) WarmupPeriod() int { + r := int(C.wickra_gator_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GatorOscillator) IsReady() bool { + r := bool(C.wickra_gator_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *GatorOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (GatorOscillatorOutput, bool) { @@ -10363,6 +12955,22 @@ func NewGeneralizedDema(period int, v float64) (*GeneralizedDema, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GeneralizedDema) WarmupPeriod() int { + r := int(C.wickra_generalized_dema_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GeneralizedDema) IsReady() bool { + r := bool(C.wickra_generalized_dema_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GeneralizedDema) Update(value float64) float64 { @@ -10418,6 +13026,22 @@ func NewGeometricMa(period int) (*GeometricMa, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GeometricMa) WarmupPeriod() int { + r := int(C.wickra_geometric_ma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GeometricMa) IsReady() bool { + r := bool(C.wickra_geometric_ma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GeometricMa) Update(value float64) float64 { @@ -10473,6 +13097,22 @@ func NewGoldenPocket() (*GoldenPocket, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GoldenPocket) WarmupPeriod() int { + r := int(C.wickra_golden_pocket_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GoldenPocket) IsReady() bool { + r := bool(C.wickra_golden_pocket_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *GoldenPocket) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (GoldenPocketOutput, bool) { @@ -10518,6 +13158,22 @@ func NewGrangerCausality(period int, lag int) (*GrangerCausality, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GrangerCausality) WarmupPeriod() int { + r := int(C.wickra_granger_causality_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GrangerCausality) IsReady() bool { + r := bool(C.wickra_granger_causality_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GrangerCausality) Update(x float64, y float64) float64 { @@ -10577,6 +13233,22 @@ func NewGravestoneDoji() (*GravestoneDoji, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *GravestoneDoji) WarmupPeriod() int { + r := int(C.wickra_gravestone_doji_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *GravestoneDoji) IsReady() bool { + r := bool(C.wickra_gravestone_doji_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *GravestoneDoji) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10652,6 +13324,22 @@ func NewHammer() (*Hammer, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Hammer) WarmupPeriod() int { + r := int(C.wickra_hammer_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Hammer) IsReady() bool { + r := bool(C.wickra_hammer_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Hammer) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10727,6 +13415,22 @@ func NewHangingMan() (*HangingMan, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HangingMan) WarmupPeriod() int { + r := int(C.wickra_hanging_man_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HangingMan) IsReady() bool { + r := bool(C.wickra_hanging_man_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HangingMan) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10802,6 +13506,22 @@ func NewHarami() (*Harami, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Harami) WarmupPeriod() int { + r := int(C.wickra_harami_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Harami) IsReady() bool { + r := bool(C.wickra_harami_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Harami) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10877,6 +13597,22 @@ func NewHaramiCross() (*HaramiCross, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HaramiCross) WarmupPeriod() int { + r := int(C.wickra_harami_cross_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HaramiCross) IsReady() bool { + r := bool(C.wickra_harami_cross_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HaramiCross) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -10952,6 +13688,22 @@ func NewHasbrouckInformationShare(period int) (*HasbrouckInformationShare, error return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HasbrouckInformationShare) WarmupPeriod() int { + r := int(C.wickra_hasbrouck_information_share_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HasbrouckInformationShare) IsReady() bool { + r := bool(C.wickra_hasbrouck_information_share_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HasbrouckInformationShare) Update(x float64, y float64) float64 { @@ -11011,6 +13763,22 @@ func NewHeadAndShoulders() (*HeadAndShoulders, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HeadAndShoulders) WarmupPeriod() int { + r := int(C.wickra_head_and_shoulders_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HeadAndShoulders) IsReady() bool { + r := bool(C.wickra_head_and_shoulders_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HeadAndShoulders) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11086,6 +13854,22 @@ func NewHeikinAshi() (*HeikinAshi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HeikinAshi) WarmupPeriod() int { + r := int(C.wickra_heikin_ashi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HeikinAshi) IsReady() bool { + r := bool(C.wickra_heikin_ashi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *HeikinAshi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (HeikinAshiOutput, bool) { @@ -11131,6 +13915,22 @@ func NewHeikinAshiOscillator(period int) (*HeikinAshiOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HeikinAshiOscillator) WarmupPeriod() int { + r := int(C.wickra_heikin_ashi_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HeikinAshiOscillator) IsReady() bool { + r := bool(C.wickra_heikin_ashi_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HeikinAshiOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11206,6 +14006,22 @@ func NewHiLoActivator(period int) (*HiLoActivator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HiLoActivator) WarmupPeriod() int { + r := int(C.wickra_hi_lo_activator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HiLoActivator) IsReady() bool { + r := bool(C.wickra_hi_lo_activator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HiLoActivator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11281,6 +14097,22 @@ func NewHighLowIndex(period int) (*HighLowIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HighLowIndex) WarmupPeriod() int { + r := int(C.wickra_high_low_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HighLowIndex) IsReady() bool { + r := bool(C.wickra_high_low_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *HighLowIndex) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -11343,6 +14175,22 @@ func NewHighLowRange() (*HighLowRange, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HighLowRange) WarmupPeriod() int { + r := int(C.wickra_high_low_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HighLowRange) IsReady() bool { + r := bool(C.wickra_high_low_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HighLowRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11418,6 +14266,22 @@ func NewHighLowVolumeNodes(period int, bins int) (*HighLowVolumeNodes, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HighLowVolumeNodes) WarmupPeriod() int { + r := int(C.wickra_high_low_volume_nodes_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HighLowVolumeNodes) IsReady() bool { + r := bool(C.wickra_high_low_volume_nodes_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *HighLowVolumeNodes) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (HighLowVolumeNodesOutput, bool) { @@ -11463,6 +14327,22 @@ func NewHighWave() (*HighWave, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HighWave) WarmupPeriod() int { + r := int(C.wickra_high_wave_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HighWave) IsReady() bool { + r := bool(C.wickra_high_wave_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HighWave) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11538,6 +14418,22 @@ func NewHighpassFilter(period int) (*HighpassFilter, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HighpassFilter) WarmupPeriod() int { + r := int(C.wickra_highpass_filter_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HighpassFilter) IsReady() bool { + r := bool(C.wickra_highpass_filter_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HighpassFilter) Update(value float64) float64 { @@ -11593,6 +14489,22 @@ func NewHikkake() (*Hikkake, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Hikkake) WarmupPeriod() int { + r := int(C.wickra_hikkake_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Hikkake) IsReady() bool { + r := bool(C.wickra_hikkake_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Hikkake) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11668,6 +14580,22 @@ func NewHikkakeModified() (*HikkakeModified, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HikkakeModified) WarmupPeriod() int { + r := int(C.wickra_hikkake_modified_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HikkakeModified) IsReady() bool { + r := bool(C.wickra_hikkake_modified_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HikkakeModified) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -11743,6 +14671,22 @@ func NewHilbertDominantCycle() (*HilbertDominantCycle, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HilbertDominantCycle) WarmupPeriod() int { + r := int(C.wickra_hilbert_dominant_cycle_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HilbertDominantCycle) IsReady() bool { + r := bool(C.wickra_hilbert_dominant_cycle_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HilbertDominantCycle) Update(value float64) float64 { @@ -11798,6 +14742,22 @@ func NewHistoricalVolatility(period int, tradingPeriods int) (*HistoricalVolatil return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HistoricalVolatility) WarmupPeriod() int { + r := int(C.wickra_historical_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HistoricalVolatility) IsReady() bool { + r := bool(C.wickra_historical_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HistoricalVolatility) Update(value float64) float64 { @@ -11853,6 +14813,22 @@ func NewHma(period int) (*Hma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Hma) WarmupPeriod() int { + r := int(C.wickra_hma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Hma) IsReady() bool { + r := bool(C.wickra_hma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Hma) Update(value float64) float64 { @@ -11908,6 +14884,22 @@ func NewHoltWinters(alpha float64, beta float64) (*HoltWinters, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HoltWinters) WarmupPeriod() int { + r := int(C.wickra_holt_winters_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HoltWinters) IsReady() bool { + r := bool(C.wickra_holt_winters_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HoltWinters) Update(value float64) float64 { @@ -11963,6 +14955,22 @@ func NewHomingPigeon() (*HomingPigeon, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HomingPigeon) WarmupPeriod() int { + r := int(C.wickra_homing_pigeon_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HomingPigeon) IsReady() bool { + r := bool(C.wickra_homing_pigeon_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HomingPigeon) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -12038,6 +15046,22 @@ func NewHtDcPhase() (*HtDcPhase, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HtDcPhase) WarmupPeriod() int { + r := int(C.wickra_ht_dc_phase_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HtDcPhase) IsReady() bool { + r := bool(C.wickra_ht_dc_phase_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HtDcPhase) Update(value float64) float64 { @@ -12093,6 +15117,22 @@ func NewHtPhasor() (*HtPhasor, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HtPhasor) WarmupPeriod() int { + r := int(C.wickra_ht_phasor_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HtPhasor) IsReady() bool { + r := bool(C.wickra_ht_phasor_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *HtPhasor) Update(value float64) (HtPhasorOutput, bool) { @@ -12138,6 +15178,22 @@ func NewHtTrendMode() (*HtTrendMode, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HtTrendMode) WarmupPeriod() int { + r := int(C.wickra_ht_trend_mode_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HtTrendMode) IsReady() bool { + r := bool(C.wickra_ht_trend_mode_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HtTrendMode) Update(value float64) float64 { @@ -12193,6 +15249,22 @@ func NewHurstChannel(period int, multiplier float64) (*HurstChannel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HurstChannel) WarmupPeriod() int { + r := int(C.wickra_hurst_channel_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HurstChannel) IsReady() bool { + r := bool(C.wickra_hurst_channel_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *HurstChannel) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (HurstChannelOutput, bool) { @@ -12238,6 +15310,22 @@ func NewHurstExponent(period int, chunks int) (*HurstExponent, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *HurstExponent) WarmupPeriod() int { + r := int(C.wickra_hurst_exponent_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *HurstExponent) IsReady() bool { + r := bool(C.wickra_hurst_exponent_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *HurstExponent) Update(value float64) float64 { @@ -12293,6 +15381,22 @@ func NewIchimoku(tenkanPeriod int, kijunPeriod int, senkouBPeriod int, displacem return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Ichimoku) WarmupPeriod() int { + r := int(C.wickra_ichimoku_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Ichimoku) IsReady() bool { + r := bool(C.wickra_ichimoku_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Ichimoku) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (IchimokuOutput, bool) { @@ -12338,6 +15442,22 @@ func NewIdenticalThreeCrows() (*IdenticalThreeCrows, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *IdenticalThreeCrows) WarmupPeriod() int { + r := int(C.wickra_identical_three_crows_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *IdenticalThreeCrows) IsReady() bool { + r := bool(C.wickra_identical_three_crows_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *IdenticalThreeCrows) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -12463,6 +15583,22 @@ func NewInNeck() (*InNeck, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *InNeck) WarmupPeriod() int { + r := int(C.wickra_in_neck_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *InNeck) IsReady() bool { + r := bool(C.wickra_in_neck_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *InNeck) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -12538,6 +15674,22 @@ func NewInertia(rviPeriod int, linregPeriod int) (*Inertia, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Inertia) WarmupPeriod() int { + r := int(C.wickra_inertia_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Inertia) IsReady() bool { + r := bool(C.wickra_inertia_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Inertia) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -12613,6 +15765,22 @@ func NewInformationRatio(period int) (*InformationRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *InformationRatio) WarmupPeriod() int { + r := int(C.wickra_information_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *InformationRatio) IsReady() bool { + r := bool(C.wickra_information_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *InformationRatio) Update(x float64, y float64) float64 { @@ -12672,6 +15840,22 @@ func NewInitialBalance(period int) (*InitialBalance, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *InitialBalance) WarmupPeriod() int { + r := int(C.wickra_initial_balance_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *InitialBalance) IsReady() bool { + r := bool(C.wickra_initial_balance_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *InitialBalance) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (InitialBalanceOutput, bool) { @@ -12717,6 +15901,22 @@ func NewInstantaneousTrendline(period int) (*InstantaneousTrendline, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *InstantaneousTrendline) WarmupPeriod() int { + r := int(C.wickra_instantaneous_trendline_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *InstantaneousTrendline) IsReady() bool { + r := bool(C.wickra_instantaneous_trendline_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *InstantaneousTrendline) Update(value float64) float64 { @@ -12772,6 +15972,22 @@ func NewIntradayIntensity() (*IntradayIntensity, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *IntradayIntensity) WarmupPeriod() int { + r := int(C.wickra_intraday_intensity_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *IntradayIntensity) IsReady() bool { + r := bool(C.wickra_intraday_intensity_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *IntradayIntensity) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -12847,6 +16063,22 @@ func NewIntradayMomentumIndex(period int) (*IntradayMomentumIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *IntradayMomentumIndex) WarmupPeriod() int { + r := int(C.wickra_intraday_momentum_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *IntradayMomentumIndex) IsReady() bool { + r := bool(C.wickra_intraday_momentum_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *IntradayMomentumIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -12924,6 +16156,22 @@ func NewIntradayVolatilityProfile(buckets int, utcOffsetMinutes int32) (*Intrada return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *IntradayVolatilityProfile) WarmupPeriod() int { + r := int(C.wickra_intraday_volatility_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *IntradayVolatilityProfile) IsReady() bool { + r := bool(C.wickra_intraday_volatility_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the profile values // (ok is false during warmup). func (ind *IntradayVolatilityProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) ([]float64, bool) { @@ -12969,6 +16217,22 @@ func NewInverseFisherTransform(scale float64) (*InverseFisherTransform, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *InverseFisherTransform) WarmupPeriod() int { + r := int(C.wickra_inverse_fisher_transform_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *InverseFisherTransform) IsReady() bool { + r := bool(C.wickra_inverse_fisher_transform_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *InverseFisherTransform) Update(value float64) float64 { @@ -13024,6 +16288,22 @@ func NewInvertedHammer() (*InvertedHammer, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *InvertedHammer) WarmupPeriod() int { + r := int(C.wickra_inverted_hammer_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *InvertedHammer) IsReady() bool { + r := bool(C.wickra_inverted_hammer_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *InvertedHammer) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -13099,6 +16379,22 @@ func NewJarqueBera(period int) (*JarqueBera, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *JarqueBera) WarmupPeriod() int { + r := int(C.wickra_jarque_bera_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *JarqueBera) IsReady() bool { + r := bool(C.wickra_jarque_bera_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *JarqueBera) Update(value float64) float64 { @@ -13154,6 +16450,22 @@ func NewJma(period int, phase float64, power uint32) (*Jma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Jma) WarmupPeriod() int { + r := int(C.wickra_jma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Jma) IsReady() bool { + r := bool(C.wickra_jma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Jma) Update(value float64) float64 { @@ -13209,6 +16521,22 @@ func NewJumpIndicator(period int, threshold float64) (*JumpIndicator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *JumpIndicator) WarmupPeriod() int { + r := int(C.wickra_jump_indicator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *JumpIndicator) IsReady() bool { + r := bool(C.wickra_jump_indicator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *JumpIndicator) Update(value float64) float64 { @@ -13264,6 +16592,22 @@ func NewKRatio(period int) (*KRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KRatio) WarmupPeriod() int { + r := int(C.wickra_k_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KRatio) IsReady() bool { + r := bool(C.wickra_k_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *KRatio) Update(value float64) float64 { @@ -13369,6 +16713,22 @@ func NewKalmanHedgeRatio(delta float64, observationVar float64) (*KalmanHedgeRat return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KalmanHedgeRatio) WarmupPeriod() int { + r := int(C.wickra_kalman_hedge_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KalmanHedgeRatio) IsReady() bool { + r := bool(C.wickra_kalman_hedge_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *KalmanHedgeRatio) Update(x float64, y float64) (KalmanHedgeRatioOutput, bool) { @@ -13414,6 +16774,22 @@ func NewKama(erPeriod int, fast int, slow int) (*Kama, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Kama) WarmupPeriod() int { + r := int(C.wickra_kama_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Kama) IsReady() bool { + r := bool(C.wickra_kama_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Kama) Update(value float64) float64 { @@ -13469,6 +16845,22 @@ func NewKaseDevStop(period int, dev float64) (*KaseDevStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KaseDevStop) WarmupPeriod() int { + r := int(C.wickra_kase_dev_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KaseDevStop) IsReady() bool { + r := bool(C.wickra_kase_dev_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *KaseDevStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (KaseDevStopOutput, bool) { @@ -13514,6 +16906,22 @@ func NewKasePermissionStochastic(length int, smooth int) (*KasePermissionStochas return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KasePermissionStochastic) WarmupPeriod() int { + r := int(C.wickra_kase_permission_stochastic_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KasePermissionStochastic) IsReady() bool { + r := bool(C.wickra_kase_permission_stochastic_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *KasePermissionStochastic) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (KasePermissionStochasticOutput, bool) { @@ -13559,6 +16967,22 @@ func NewKellyCriterion(period int) (*KellyCriterion, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KellyCriterion) WarmupPeriod() int { + r := int(C.wickra_kelly_criterion_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KellyCriterion) IsReady() bool { + r := bool(C.wickra_kelly_criterion_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *KellyCriterion) Update(value float64) float64 { @@ -13614,6 +17038,22 @@ func NewKeltner(emaPeriod int, atrPeriod int, multiplier float64) (*Keltner, err return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Keltner) WarmupPeriod() int { + r := int(C.wickra_keltner_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Keltner) IsReady() bool { + r := bool(C.wickra_keltner_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Keltner) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (KeltnerOutput, bool) { @@ -13659,6 +17099,22 @@ func NewKendallTau(period int) (*KendallTau, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KendallTau) WarmupPeriod() int { + r := int(C.wickra_kendall_tau_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KendallTau) IsReady() bool { + r := bool(C.wickra_kendall_tau_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *KendallTau) Update(x float64, y float64) float64 { @@ -13718,6 +17174,22 @@ func NewKicking() (*Kicking, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Kicking) WarmupPeriod() int { + r := int(C.wickra_kicking_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Kicking) IsReady() bool { + r := bool(C.wickra_kicking_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Kicking) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -13793,6 +17265,22 @@ func NewKickingByLength() (*KickingByLength, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KickingByLength) WarmupPeriod() int { + r := int(C.wickra_kicking_by_length_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KickingByLength) IsReady() bool { + r := bool(C.wickra_kicking_by_length_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *KickingByLength) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -13868,6 +17356,22 @@ func NewKst(roc1 int, roc2 int, roc3 int, roc4 int, sma1 int, sma2 int, sma3 int return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Kst) WarmupPeriod() int { + r := int(C.wickra_kst_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Kst) IsReady() bool { + r := bool(C.wickra_kst_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Kst) Update(value float64) (KstOutput, bool) { @@ -13913,6 +17417,22 @@ func NewKurtosis(period int) (*Kurtosis, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Kurtosis) WarmupPeriod() int { + r := int(C.wickra_kurtosis_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Kurtosis) IsReady() bool { + r := bool(C.wickra_kurtosis_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Kurtosis) Update(value float64) float64 { @@ -13968,6 +17488,22 @@ func NewKvo(fast int, slow int) (*Kvo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Kvo) WarmupPeriod() int { + r := int(C.wickra_kvo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Kvo) IsReady() bool { + r := bool(C.wickra_kvo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Kvo) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -14043,6 +17579,22 @@ func NewKylesLambda(window int) (*KylesLambda, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *KylesLambda) WarmupPeriod() int { + r := int(C.wickra_kyles_lambda_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *KylesLambda) IsReady() bool { + r := bool(C.wickra_kyles_lambda_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *KylesLambda) Update(price float64, size float64, isBuy bool, timestamp int64, mid float64) float64 { @@ -14084,6 +17636,22 @@ func NewLadderBottom() (*LadderBottom, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LadderBottom) WarmupPeriod() int { + r := int(C.wickra_ladder_bottom_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LadderBottom) IsReady() bool { + r := bool(C.wickra_ladder_bottom_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LadderBottom) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -14159,6 +17727,22 @@ func NewLaguerreRsi(gamma float64) (*LaguerreRsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LaguerreRsi) WarmupPeriod() int { + r := int(C.wickra_laguerre_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LaguerreRsi) IsReady() bool { + r := bool(C.wickra_laguerre_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LaguerreRsi) Update(value float64) float64 { @@ -14214,6 +17798,22 @@ func NewLeadLagCrossCorrelation(window int, maxLag int) (*LeadLagCrossCorrelatio return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LeadLagCrossCorrelation) WarmupPeriod() int { + r := int(C.wickra_lead_lag_cross_correlation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LeadLagCrossCorrelation) IsReady() bool { + r := bool(C.wickra_lead_lag_cross_correlation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *LeadLagCrossCorrelation) Update(x float64, y float64) (LeadLagCrossCorrelationOutput, bool) { @@ -14259,6 +17859,22 @@ func NewLinRegAngle(period int) (*LinRegAngle, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LinRegAngle) WarmupPeriod() int { + r := int(C.wickra_lin_reg_angle_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LinRegAngle) IsReady() bool { + r := bool(C.wickra_lin_reg_angle_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LinRegAngle) Update(value float64) float64 { @@ -14314,6 +17930,22 @@ func NewLinRegChannel(period int, multiplier float64) (*LinRegChannel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LinRegChannel) WarmupPeriod() int { + r := int(C.wickra_lin_reg_channel_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LinRegChannel) IsReady() bool { + r := bool(C.wickra_lin_reg_channel_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *LinRegChannel) Update(value float64) (LinRegChannelOutput, bool) { @@ -14359,6 +17991,22 @@ func NewLinRegIntercept(period int) (*LinRegIntercept, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LinRegIntercept) WarmupPeriod() int { + r := int(C.wickra_lin_reg_intercept_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LinRegIntercept) IsReady() bool { + r := bool(C.wickra_lin_reg_intercept_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LinRegIntercept) Update(value float64) float64 { @@ -14414,6 +18062,22 @@ func NewLinRegSlope(period int) (*LinRegSlope, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LinRegSlope) WarmupPeriod() int { + r := int(C.wickra_lin_reg_slope_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LinRegSlope) IsReady() bool { + r := bool(C.wickra_lin_reg_slope_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LinRegSlope) Update(value float64) float64 { @@ -14469,6 +18133,22 @@ func NewLinearRegression(period int) (*LinearRegression, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LinearRegression) WarmupPeriod() int { + r := int(C.wickra_linear_regression_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LinearRegression) IsReady() bool { + r := bool(C.wickra_linear_regression_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LinearRegression) Update(value float64) float64 { @@ -14524,6 +18204,22 @@ func NewLiquidationFeatures() (*LiquidationFeatures, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LiquidationFeatures) WarmupPeriod() int { + r := int(C.wickra_liquidation_features_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LiquidationFeatures) IsReady() bool { + r := bool(C.wickra_liquidation_features_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *LiquidationFeatures) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) (LiquidationFeaturesOutput, bool) { @@ -14569,6 +18265,22 @@ func NewLogReturn(period int) (*LogReturn, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LogReturn) WarmupPeriod() int { + r := int(C.wickra_log_return_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LogReturn) IsReady() bool { + r := bool(C.wickra_log_return_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LogReturn) Update(value float64) float64 { @@ -14624,6 +18336,22 @@ func NewLongLeggedDoji() (*LongLeggedDoji, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LongLeggedDoji) WarmupPeriod() int { + r := int(C.wickra_long_legged_doji_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LongLeggedDoji) IsReady() bool { + r := bool(C.wickra_long_legged_doji_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LongLeggedDoji) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -14699,6 +18427,22 @@ func NewLongLine() (*LongLine, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LongLine) WarmupPeriod() int { + r := int(C.wickra_long_line_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LongLine) IsReady() bool { + r := bool(C.wickra_long_line_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LongLine) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -14774,6 +18518,22 @@ func NewLongShortRatio() (*LongShortRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *LongShortRatio) WarmupPeriod() int { + r := int(C.wickra_long_short_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *LongShortRatio) IsReady() bool { + r := bool(C.wickra_long_short_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *LongShortRatio) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -14815,6 +18575,22 @@ func NewM2Measure(period int, riskFree float64, benchmarkStddev float64) (*M2Mea return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *M2Measure) WarmupPeriod() int { + r := int(C.wickra_m2_measure_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *M2Measure) IsReady() bool { + r := bool(C.wickra_m2_measure_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *M2Measure) Update(value float64) float64 { @@ -14870,6 +18646,22 @@ func NewMaEnvelope(period int, percent float64) (*MaEnvelope, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MaEnvelope) WarmupPeriod() int { + r := int(C.wickra_ma_envelope_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MaEnvelope) IsReady() bool { + r := bool(C.wickra_ma_envelope_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *MaEnvelope) Update(value float64) (MaEnvelopeOutput, bool) { @@ -14915,6 +18707,22 @@ func NewMacdExt(fast int, fastType uint8, slow int, slowType uint8, signal int, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MacdExt) WarmupPeriod() int { + r := int(C.wickra_macd_ext_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MacdExt) IsReady() bool { + r := bool(C.wickra_macd_ext_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *MacdExt) Update(value float64) (MacdOutput, bool) { @@ -14960,6 +18768,22 @@ func NewMacdFix(signal int) (*MacdFix, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MacdFix) WarmupPeriod() int { + r := int(C.wickra_macd_fix_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MacdFix) IsReady() bool { + r := bool(C.wickra_macd_fix_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *MacdFix) Update(value float64) (MacdOutput, bool) { @@ -15005,6 +18829,22 @@ func NewMacdHistogram(fast int, slow int, signal int) (*MacdHistogram, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MacdHistogram) WarmupPeriod() int { + r := int(C.wickra_macd_histogram_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MacdHistogram) IsReady() bool { + r := bool(C.wickra_macd_histogram_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MacdHistogram) Update(value float64) float64 { @@ -15060,6 +18900,22 @@ func NewMacdIndicator(fast int, slow int, signal int) (*MacdIndicator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MacdIndicator) WarmupPeriod() int { + r := int(C.wickra_macd_indicator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MacdIndicator) IsReady() bool { + r := bool(C.wickra_macd_indicator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *MacdIndicator) Update(value float64) (MacdOutput, bool) { @@ -15105,6 +18961,22 @@ func NewMama(fastLimit float64, slowLimit float64) (*Mama, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Mama) WarmupPeriod() int { + r := int(C.wickra_mama_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Mama) IsReady() bool { + r := bool(C.wickra_mama_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Mama) Update(value float64) (MamaOutput, bool) { @@ -15150,6 +19022,22 @@ func NewMarketFacilitationIndex() (*MarketFacilitationIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MarketFacilitationIndex) WarmupPeriod() int { + r := int(C.wickra_market_facilitation_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MarketFacilitationIndex) IsReady() bool { + r := bool(C.wickra_market_facilitation_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MarketFacilitationIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -15225,6 +19113,22 @@ func NewMartinRatio(period int) (*MartinRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MartinRatio) WarmupPeriod() int { + r := int(C.wickra_martin_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MartinRatio) IsReady() bool { + r := bool(C.wickra_martin_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MartinRatio) Update(value float64) float64 { @@ -15280,6 +19184,22 @@ func NewMarubozu() (*Marubozu, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Marubozu) WarmupPeriod() int { + r := int(C.wickra_marubozu_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Marubozu) IsReady() bool { + r := bool(C.wickra_marubozu_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Marubozu) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -15355,6 +19275,22 @@ func NewMassIndex(emaPeriod int, sumPeriod int) (*MassIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MassIndex) WarmupPeriod() int { + r := int(C.wickra_mass_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MassIndex) IsReady() bool { + r := bool(C.wickra_mass_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MassIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -15430,6 +19366,22 @@ func NewMatHold() (*MatHold, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MatHold) WarmupPeriod() int { + r := int(C.wickra_mat_hold_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MatHold) IsReady() bool { + r := bool(C.wickra_mat_hold_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MatHold) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -15505,6 +19457,22 @@ func NewMatchingLow() (*MatchingLow, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MatchingLow) WarmupPeriod() int { + r := int(C.wickra_matching_low_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MatchingLow) IsReady() bool { + r := bool(C.wickra_matching_low_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MatchingLow) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -15580,6 +19548,22 @@ func NewMaxDrawdown(period int) (*MaxDrawdown, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MaxDrawdown) WarmupPeriod() int { + r := int(C.wickra_max_drawdown_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MaxDrawdown) IsReady() bool { + r := bool(C.wickra_max_drawdown_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MaxDrawdown) Update(value float64) float64 { @@ -15635,6 +19619,22 @@ func NewMcClellanOscillator() (*McClellanOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *McClellanOscillator) WarmupPeriod() int { + r := int(C.wickra_mc_clellan_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *McClellanOscillator) IsReady() bool { + r := bool(C.wickra_mc_clellan_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *McClellanOscillator) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -15697,6 +19697,22 @@ func NewMcClellanSummationIndex() (*McClellanSummationIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *McClellanSummationIndex) WarmupPeriod() int { + r := int(C.wickra_mc_clellan_summation_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *McClellanSummationIndex) IsReady() bool { + r := bool(C.wickra_mc_clellan_summation_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *McClellanSummationIndex) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -15759,6 +19775,22 @@ func NewMcGinleyDynamic(period int) (*McGinleyDynamic, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *McGinleyDynamic) WarmupPeriod() int { + r := int(C.wickra_mc_ginley_dynamic_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *McGinleyDynamic) IsReady() bool { + r := bool(C.wickra_mc_ginley_dynamic_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *McGinleyDynamic) Update(value float64) float64 { @@ -15814,6 +19846,22 @@ func NewMedianAbsoluteDeviation(period int) (*MedianAbsoluteDeviation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MedianAbsoluteDeviation) WarmupPeriod() int { + r := int(C.wickra_median_absolute_deviation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MedianAbsoluteDeviation) IsReady() bool { + r := bool(C.wickra_median_absolute_deviation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MedianAbsoluteDeviation) Update(value float64) float64 { @@ -15869,6 +19917,22 @@ func NewMedianChannel(period int, multiplier float64) (*MedianChannel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MedianChannel) WarmupPeriod() int { + r := int(C.wickra_median_channel_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MedianChannel) IsReady() bool { + r := bool(C.wickra_median_channel_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *MedianChannel) Update(value float64) (MedianChannelOutput, bool) { @@ -15914,6 +19978,22 @@ func NewMedianMa(period int) (*MedianMa, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MedianMa) WarmupPeriod() int { + r := int(C.wickra_median_ma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MedianMa) IsReady() bool { + r := bool(C.wickra_median_ma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MedianMa) Update(value float64) float64 { @@ -15969,6 +20049,22 @@ func NewMedianPrice() (*MedianPrice, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MedianPrice) WarmupPeriod() int { + r := int(C.wickra_median_price_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MedianPrice) IsReady() bool { + r := bool(C.wickra_median_price_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MedianPrice) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16044,6 +20140,22 @@ func NewMfi(period int) (*Mfi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Mfi) WarmupPeriod() int { + r := int(C.wickra_mfi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Mfi) IsReady() bool { + r := bool(C.wickra_mfi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Mfi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16119,6 +20231,22 @@ func NewMicroprice() (*Microprice, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Microprice) WarmupPeriod() int { + r := int(C.wickra_microprice_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Microprice) IsReady() bool { + r := bool(C.wickra_microprice_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *Microprice) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -16170,6 +20298,22 @@ func NewMidPoint(period int) (*MidPoint, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MidPoint) WarmupPeriod() int { + r := int(C.wickra_mid_point_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MidPoint) IsReady() bool { + r := bool(C.wickra_mid_point_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MidPoint) Update(value float64) float64 { @@ -16225,6 +20369,22 @@ func NewMidPrice(period int) (*MidPrice, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MidPrice) WarmupPeriod() int { + r := int(C.wickra_mid_price_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MidPrice) IsReady() bool { + r := bool(C.wickra_mid_price_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MidPrice) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16300,6 +20460,22 @@ func NewMinusDi(period int) (*MinusDi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MinusDi) WarmupPeriod() int { + r := int(C.wickra_minus_di_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MinusDi) IsReady() bool { + r := bool(C.wickra_minus_di_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MinusDi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16375,6 +20551,22 @@ func NewMinusDm(period int) (*MinusDm, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MinusDm) WarmupPeriod() int { + r := int(C.wickra_minus_dm_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MinusDm) IsReady() bool { + r := bool(C.wickra_minus_dm_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MinusDm) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16450,6 +20642,22 @@ func NewModifiedMaStop(period int) (*ModifiedMaStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ModifiedMaStop) WarmupPeriod() int { + r := int(C.wickra_modified_ma_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ModifiedMaStop) IsReady() bool { + r := bool(C.wickra_modified_ma_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ModifiedMaStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ModifiedMaStopOutput, bool) { @@ -16495,6 +20703,22 @@ func NewMom(period int) (*Mom, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Mom) WarmupPeriod() int { + r := int(C.wickra_mom_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Mom) IsReady() bool { + r := bool(C.wickra_mom_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Mom) Update(value float64) float64 { @@ -16550,6 +20774,22 @@ func NewMorningDojiStar() (*MorningDojiStar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MorningDojiStar) WarmupPeriod() int { + r := int(C.wickra_morning_doji_star_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MorningDojiStar) IsReady() bool { + r := bool(C.wickra_morning_doji_star_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MorningDojiStar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16625,6 +20865,22 @@ func NewMorningEveningStar() (*MorningEveningStar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MorningEveningStar) WarmupPeriod() int { + r := int(C.wickra_morning_evening_star_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MorningEveningStar) IsReady() bool { + r := bool(C.wickra_morning_evening_star_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *MorningEveningStar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16700,6 +20956,22 @@ func NewMurreyMathLines(period int) (*MurreyMathLines, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *MurreyMathLines) WarmupPeriod() int { + r := int(C.wickra_murrey_math_lines_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *MurreyMathLines) IsReady() bool { + r := bool(C.wickra_murrey_math_lines_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *MurreyMathLines) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (MurreyMathLinesOutput, bool) { @@ -16745,6 +21017,22 @@ func NewNakedPoc(sessionLen int, bins int) (*NakedPoc, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *NakedPoc) WarmupPeriod() int { + r := int(C.wickra_naked_poc_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *NakedPoc) IsReady() bool { + r := bool(C.wickra_naked_poc_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *NakedPoc) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16820,6 +21108,22 @@ func NewNatr(period int) (*Natr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Natr) WarmupPeriod() int { + r := int(C.wickra_natr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Natr) IsReady() bool { + r := bool(C.wickra_natr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Natr) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -16895,6 +21199,22 @@ func NewNewHighsNewLows() (*NewHighsNewLows, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *NewHighsNewLows) WarmupPeriod() int { + r := int(C.wickra_new_highs_new_lows_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *NewHighsNewLows) IsReady() bool { + r := bool(C.wickra_new_highs_new_lows_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *NewHighsNewLows) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -16957,6 +21277,22 @@ func NewNewPriceLines(count int) (*NewPriceLines, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *NewPriceLines) WarmupPeriod() int { + r := int(C.wickra_new_price_lines_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *NewPriceLines) IsReady() bool { + r := bool(C.wickra_new_price_lines_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *NewPriceLines) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -17032,6 +21368,22 @@ func NewNrtr(pct float64) (*Nrtr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Nrtr) WarmupPeriod() int { + r := int(C.wickra_nrtr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Nrtr) IsReady() bool { + r := bool(C.wickra_nrtr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Nrtr) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (NrtrOutput, bool) { @@ -17077,6 +21429,22 @@ func NewNvi() (*Nvi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Nvi) WarmupPeriod() int { + r := int(C.wickra_nvi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Nvi) IsReady() bool { + r := bool(C.wickra_nvi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Nvi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -17152,6 +21520,22 @@ func NewObv() (*Obv, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Obv) WarmupPeriod() int { + r := int(C.wickra_obv_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Obv) IsReady() bool { + r := bool(C.wickra_obv_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Obv) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -17227,6 +21611,22 @@ func NewOIPriceDivergence(window int) (*OIPriceDivergence, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OIPriceDivergence) WarmupPeriod() int { + r := int(C.wickra_oi_price_divergence_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OIPriceDivergence) IsReady() bool { + r := bool(C.wickra_oi_price_divergence_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OIPriceDivergence) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -17268,6 +21668,22 @@ func NewOiToVolumeRatio() (*OiToVolumeRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OiToVolumeRatio) WarmupPeriod() int { + r := int(C.wickra_oi_to_volume_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OiToVolumeRatio) IsReady() bool { + r := bool(C.wickra_oi_to_volume_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OiToVolumeRatio) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -17309,6 +21725,22 @@ func NewOIWeighted() (*OIWeighted, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OIWeighted) WarmupPeriod() int { + r := int(C.wickra_oi_weighted_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OIWeighted) IsReady() bool { + r := bool(C.wickra_oi_weighted_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OIWeighted) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -17350,6 +21782,22 @@ func NewOmegaRatio(period int, threshold float64) (*OmegaRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OmegaRatio) WarmupPeriod() int { + r := int(C.wickra_omega_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OmegaRatio) IsReady() bool { + r := bool(C.wickra_omega_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OmegaRatio) Update(value float64) float64 { @@ -17405,6 +21853,22 @@ func NewOnNeck() (*OnNeck, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OnNeck) WarmupPeriod() int { + r := int(C.wickra_on_neck_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OnNeck) IsReady() bool { + r := bool(C.wickra_on_neck_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OnNeck) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -17480,6 +21944,22 @@ func NewOpenInterestDelta() (*OpenInterestDelta, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OpenInterestDelta) WarmupPeriod() int { + r := int(C.wickra_open_interest_delta_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OpenInterestDelta) IsReady() bool { + r := bool(C.wickra_open_interest_delta_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OpenInterestDelta) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -17521,6 +22001,22 @@ func NewOpenInterestMomentum(period int) (*OpenInterestMomentum, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OpenInterestMomentum) WarmupPeriod() int { + r := int(C.wickra_open_interest_momentum_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OpenInterestMomentum) IsReady() bool { + r := bool(C.wickra_open_interest_momentum_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OpenInterestMomentum) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -17562,6 +22058,22 @@ func NewOpeningMarubozu() (*OpeningMarubozu, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OpeningMarubozu) WarmupPeriod() int { + r := int(C.wickra_opening_marubozu_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OpeningMarubozu) IsReady() bool { + r := bool(C.wickra_opening_marubozu_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OpeningMarubozu) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -17637,6 +22149,22 @@ func NewOpeningRange(period int) (*OpeningRange, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OpeningRange) WarmupPeriod() int { + r := int(C.wickra_opening_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OpeningRange) IsReady() bool { + r := bool(C.wickra_opening_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *OpeningRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (OpeningRangeOutput, bool) { @@ -17682,6 +22210,22 @@ func NewOrderBookImbalanceFull() (*OrderBookImbalanceFull, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OrderBookImbalanceFull) WarmupPeriod() int { + r := int(C.wickra_order_book_imbalance_full_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OrderBookImbalanceFull) IsReady() bool { + r := bool(C.wickra_order_book_imbalance_full_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *OrderBookImbalanceFull) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -17733,6 +22277,22 @@ func NewOrderBookImbalanceTop1() (*OrderBookImbalanceTop1, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OrderBookImbalanceTop1) WarmupPeriod() int { + r := int(C.wickra_order_book_imbalance_top1_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OrderBookImbalanceTop1) IsReady() bool { + r := bool(C.wickra_order_book_imbalance_top1_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *OrderBookImbalanceTop1) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -17784,6 +22344,22 @@ func NewOrderBookImbalanceTopN(levels int) (*OrderBookImbalanceTopN, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OrderBookImbalanceTopN) WarmupPeriod() int { + r := int(C.wickra_order_book_imbalance_top_n_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OrderBookImbalanceTopN) IsReady() bool { + r := bool(C.wickra_order_book_imbalance_top_n_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *OrderBookImbalanceTopN) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -17835,6 +22411,22 @@ func NewOrderFlowImbalance(period int) (*OrderFlowImbalance, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OrderFlowImbalance) WarmupPeriod() int { + r := int(C.wickra_order_flow_imbalance_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OrderFlowImbalance) IsReady() bool { + r := bool(C.wickra_order_flow_imbalance_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *OrderFlowImbalance) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -17886,6 +22478,22 @@ func NewOuHalfLife(period int) (*OuHalfLife, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OuHalfLife) WarmupPeriod() int { + r := int(C.wickra_ou_half_life_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OuHalfLife) IsReady() bool { + r := bool(C.wickra_ou_half_life_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OuHalfLife) Update(x float64, y float64) float64 { @@ -17945,6 +22553,22 @@ func NewOvernightGap(utcOffsetMinutes int32) (*OvernightGap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OvernightGap) WarmupPeriod() int { + r := int(C.wickra_overnight_gap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OvernightGap) IsReady() bool { + r := bool(C.wickra_overnight_gap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *OvernightGap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -18020,6 +22644,22 @@ func NewOvernightIntradayReturn(utcOffsetMinutes int32) (*OvernightIntradayRetur return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *OvernightIntradayReturn) WarmupPeriod() int { + r := int(C.wickra_overnight_intraday_return_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *OvernightIntradayReturn) IsReady() bool { + r := bool(C.wickra_overnight_intraday_return_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *OvernightIntradayReturn) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (OvernightIntradayReturnOutput, bool) { @@ -18065,6 +22705,22 @@ func NewPainIndex(period int) (*PainIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PainIndex) WarmupPeriod() int { + r := int(C.wickra_pain_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PainIndex) IsReady() bool { + r := bool(C.wickra_pain_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PainIndex) Update(value float64) float64 { @@ -18120,6 +22776,22 @@ func NewPairSpreadZScore(betaPeriod int, zPeriod int) (*PairSpreadZScore, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PairSpreadZScore) WarmupPeriod() int { + r := int(C.wickra_pair_spread_z_score_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PairSpreadZScore) IsReady() bool { + r := bool(C.wickra_pair_spread_z_score_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PairSpreadZScore) Update(x float64, y float64) float64 { @@ -18179,6 +22851,22 @@ func NewPairwiseBeta(period int) (*PairwiseBeta, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PairwiseBeta) WarmupPeriod() int { + r := int(C.wickra_pairwise_beta_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PairwiseBeta) IsReady() bool { + r := bool(C.wickra_pairwise_beta_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PairwiseBeta) Update(x float64, y float64) float64 { @@ -18238,6 +22926,22 @@ func NewParkinsonVolatility(period int, tradingPeriods int) (*ParkinsonVolatilit return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ParkinsonVolatility) WarmupPeriod() int { + r := int(C.wickra_parkinson_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ParkinsonVolatility) IsReady() bool { + r := bool(C.wickra_parkinson_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ParkinsonVolatility) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -18313,6 +23017,22 @@ func NewPearsonCorrelation(period int) (*PearsonCorrelation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PearsonCorrelation) WarmupPeriod() int { + r := int(C.wickra_pearson_correlation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PearsonCorrelation) IsReady() bool { + r := bool(C.wickra_pearson_correlation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PearsonCorrelation) Update(x float64, y float64) float64 { @@ -18372,6 +23092,22 @@ func NewPercentAboveMa() (*PercentAboveMa, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PercentAboveMa) WarmupPeriod() int { + r := int(C.wickra_percent_above_ma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PercentAboveMa) IsReady() bool { + r := bool(C.wickra_percent_above_ma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *PercentAboveMa) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -18434,6 +23170,22 @@ func NewPercentB(period int, multiplier float64) (*PercentB, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PercentB) WarmupPeriod() int { + r := int(C.wickra_percent_b_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PercentB) IsReady() bool { + r := bool(C.wickra_percent_b_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PercentB) Update(value float64) float64 { @@ -18489,6 +23241,22 @@ func NewPercentageTrailingStop(percent float64) (*PercentageTrailingStop, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PercentageTrailingStop) WarmupPeriod() int { + r := int(C.wickra_percentage_trailing_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PercentageTrailingStop) IsReady() bool { + r := bool(C.wickra_percentage_trailing_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PercentageTrailingStop) Update(value float64) float64 { @@ -18544,6 +23312,22 @@ func NewPerpetualPremiumIndex() (*PerpetualPremiumIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PerpetualPremiumIndex) WarmupPeriod() int { + r := int(C.wickra_perpetual_premium_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PerpetualPremiumIndex) IsReady() bool { + r := bool(C.wickra_perpetual_premium_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PerpetualPremiumIndex) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -18585,6 +23369,22 @@ func NewPgo(period int) (*Pgo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Pgo) WarmupPeriod() int { + r := int(C.wickra_pgo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Pgo) IsReady() bool { + r := bool(C.wickra_pgo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Pgo) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -18660,6 +23460,22 @@ func NewPiercingDarkCloud() (*PiercingDarkCloud, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PiercingDarkCloud) WarmupPeriod() int { + r := int(C.wickra_piercing_dark_cloud_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PiercingDarkCloud) IsReady() bool { + r := bool(C.wickra_piercing_dark_cloud_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PiercingDarkCloud) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -18735,6 +23551,22 @@ func NewPin(window int) (*Pin, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Pin) WarmupPeriod() int { + r := int(C.wickra_pin_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Pin) IsReady() bool { + r := bool(C.wickra_pin_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Pin) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -18776,6 +23608,22 @@ func NewPivotReversal(left int, right int) (*PivotReversal, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PivotReversal) WarmupPeriod() int { + r := int(C.wickra_pivot_reversal_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PivotReversal) IsReady() bool { + r := bool(C.wickra_pivot_reversal_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PivotReversal) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -18851,6 +23699,22 @@ func NewPlusDi(period int) (*PlusDi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PlusDi) WarmupPeriod() int { + r := int(C.wickra_plus_di_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PlusDi) IsReady() bool { + r := bool(C.wickra_plus_di_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PlusDi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -18926,6 +23790,22 @@ func NewPlusDm(period int) (*PlusDm, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PlusDm) WarmupPeriod() int { + r := int(C.wickra_plus_dm_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PlusDm) IsReady() bool { + r := bool(C.wickra_plus_dm_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PlusDm) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -19001,6 +23881,22 @@ func NewPmo(smoothing1 int, smoothing2 int) (*Pmo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Pmo) WarmupPeriod() int { + r := int(C.wickra_pmo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Pmo) IsReady() bool { + r := bool(C.wickra_pmo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Pmo) Update(value float64) float64 { @@ -19106,6 +24002,22 @@ func NewPolarizedFractalEfficiency(period int, smoothing int) (*PolarizedFractal return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PolarizedFractalEfficiency) WarmupPeriod() int { + r := int(C.wickra_polarized_fractal_efficiency_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PolarizedFractalEfficiency) IsReady() bool { + r := bool(C.wickra_polarized_fractal_efficiency_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PolarizedFractalEfficiency) Update(value float64) float64 { @@ -19161,6 +24073,22 @@ func NewPpo(fast int, slow int) (*Ppo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Ppo) WarmupPeriod() int { + r := int(C.wickra_ppo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Ppo) IsReady() bool { + r := bool(C.wickra_ppo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Ppo) Update(value float64) float64 { @@ -19216,6 +24144,22 @@ func NewPpoHistogram(fast int, slow int, signal int) (*PpoHistogram, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *PpoHistogram) WarmupPeriod() int { + r := int(C.wickra_ppo_histogram_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *PpoHistogram) IsReady() bool { + r := bool(C.wickra_ppo_histogram_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *PpoHistogram) Update(value float64) float64 { @@ -19271,6 +24215,22 @@ func NewProfileShape(period int, bins int) (*ProfileShape, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ProfileShape) WarmupPeriod() int { + r := int(C.wickra_profile_shape_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ProfileShape) IsReady() bool { + r := bool(C.wickra_profile_shape_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ProfileShape) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -19346,6 +24306,22 @@ func NewProfitFactor(period int) (*ProfitFactor, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ProfitFactor) WarmupPeriod() int { + r := int(C.wickra_profit_factor_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ProfitFactor) IsReady() bool { + r := bool(C.wickra_profit_factor_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ProfitFactor) Update(value float64) float64 { @@ -19401,6 +24377,22 @@ func NewProjectionBands(period int) (*ProjectionBands, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ProjectionBands) WarmupPeriod() int { + r := int(C.wickra_projection_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ProjectionBands) IsReady() bool { + r := bool(C.wickra_projection_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ProjectionBands) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ProjectionBandsOutput, bool) { @@ -19446,6 +24438,22 @@ func NewProjectionOscillator(period int) (*ProjectionOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ProjectionOscillator) WarmupPeriod() int { + r := int(C.wickra_projection_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ProjectionOscillator) IsReady() bool { + r := bool(C.wickra_projection_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ProjectionOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -19521,6 +24529,22 @@ func NewPsar(afStart float64, afStep float64, afMax float64) (*Psar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Psar) WarmupPeriod() int { + r := int(C.wickra_psar_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Psar) IsReady() bool { + r := bool(C.wickra_psar_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Psar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -19596,6 +24620,22 @@ func NewPvi() (*Pvi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Pvi) WarmupPeriod() int { + r := int(C.wickra_pvi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Pvi) IsReady() bool { + r := bool(C.wickra_pvi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Pvi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -19671,6 +24711,22 @@ func NewQqe(rsiPeriod int, smoothing int, factor float64) (*Qqe, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Qqe) WarmupPeriod() int { + r := int(C.wickra_qqe_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Qqe) IsReady() bool { + r := bool(C.wickra_qqe_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Qqe) Update(value float64) (QqeOutput, bool) { @@ -19716,6 +24772,22 @@ func NewQstick(period int) (*Qstick, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Qstick) WarmupPeriod() int { + r := int(C.wickra_qstick_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Qstick) IsReady() bool { + r := bool(C.wickra_qstick_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Qstick) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -19791,6 +24863,22 @@ func NewQuartileBands(period int) (*QuartileBands, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *QuartileBands) WarmupPeriod() int { + r := int(C.wickra_quartile_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *QuartileBands) IsReady() bool { + r := bool(C.wickra_quartile_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *QuartileBands) Update(value float64) (QuartileBandsOutput, bool) { @@ -19836,6 +24924,22 @@ func NewQuotedSpread() (*QuotedSpread, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *QuotedSpread) WarmupPeriod() int { + r := int(C.wickra_quoted_spread_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *QuotedSpread) IsReady() bool { + r := bool(C.wickra_quoted_spread_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *QuotedSpread) Update(bidPrice []float64, bidSize []float64, askPrice []float64, askSize []float64) float64 { @@ -19887,6 +24991,22 @@ func NewRSquared(period int) (*RSquared, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RSquared) WarmupPeriod() int { + r := int(C.wickra_r_squared_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RSquared) IsReady() bool { + r := bool(C.wickra_r_squared_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RSquared) Update(value float64) float64 { @@ -19992,6 +25112,22 @@ func NewRealizedSpread(horizon int) (*RealizedSpread, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RealizedSpread) WarmupPeriod() int { + r := int(C.wickra_realized_spread_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RealizedSpread) IsReady() bool { + r := bool(C.wickra_realized_spread_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RealizedSpread) Update(price float64, size float64, isBuy bool, timestamp int64, mid float64) float64 { @@ -20033,6 +25169,22 @@ func NewRealizedVolatility(period int) (*RealizedVolatility, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RealizedVolatility) WarmupPeriod() int { + r := int(C.wickra_realized_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RealizedVolatility) IsReady() bool { + r := bool(C.wickra_realized_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RealizedVolatility) Update(value float64) float64 { @@ -20088,6 +25240,22 @@ func NewRecoveryFactor() (*RecoveryFactor, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RecoveryFactor) WarmupPeriod() int { + r := int(C.wickra_recovery_factor_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RecoveryFactor) IsReady() bool { + r := bool(C.wickra_recovery_factor_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RecoveryFactor) Update(value float64) float64 { @@ -20143,6 +25311,22 @@ func NewRectangleRange() (*RectangleRange, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RectangleRange) WarmupPeriod() int { + r := int(C.wickra_rectangle_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RectangleRange) IsReady() bool { + r := bool(C.wickra_rectangle_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RectangleRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -20218,6 +25402,22 @@ func NewReflex(period int) (*Reflex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Reflex) WarmupPeriod() int { + r := int(C.wickra_reflex_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Reflex) IsReady() bool { + r := bool(C.wickra_reflex_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Reflex) Update(value float64) float64 { @@ -20273,6 +25473,22 @@ func NewRegimeLabel(volPeriod int, lookback int) (*RegimeLabel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RegimeLabel) WarmupPeriod() int { + r := int(C.wickra_regime_label_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RegimeLabel) IsReady() bool { + r := bool(C.wickra_regime_label_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RegimeLabel) Update(value float64) float64 { @@ -20328,6 +25544,22 @@ func NewRelativeStrengthAB(maPeriod int, rsiPeriod int) (*RelativeStrengthAB, er return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RelativeStrengthAB) WarmupPeriod() int { + r := int(C.wickra_relative_strength_ab_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RelativeStrengthAB) IsReady() bool { + r := bool(C.wickra_relative_strength_ab_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *RelativeStrengthAB) Update(x float64, y float64) (RelativeStrengthOutput, bool) { @@ -20423,6 +25655,22 @@ func NewRenkoTrailingStop(blockSize float64) (*RenkoTrailingStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RenkoTrailingStop) WarmupPeriod() int { + r := int(C.wickra_renko_trailing_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RenkoTrailingStop) IsReady() bool { + r := bool(C.wickra_renko_trailing_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RenkoTrailingStop) Update(value float64) float64 { @@ -20478,6 +25726,22 @@ func NewRickshawMan() (*RickshawMan, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RickshawMan) WarmupPeriod() int { + r := int(C.wickra_rickshaw_man_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RickshawMan) IsReady() bool { + r := bool(C.wickra_rickshaw_man_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RickshawMan) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -20553,6 +25817,22 @@ func NewRisingThreeMethods() (*RisingThreeMethods, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RisingThreeMethods) WarmupPeriod() int { + r := int(C.wickra_rising_three_methods_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RisingThreeMethods) IsReady() bool { + r := bool(C.wickra_rising_three_methods_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RisingThreeMethods) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -20628,6 +25908,22 @@ func NewRmi(period int, momentum int) (*Rmi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rmi) WarmupPeriod() int { + r := int(C.wickra_rmi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rmi) IsReady() bool { + r := bool(C.wickra_rmi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rmi) Update(value float64) float64 { @@ -20683,6 +25979,22 @@ func NewRoc(period int) (*Roc, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Roc) WarmupPeriod() int { + r := int(C.wickra_roc_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Roc) IsReady() bool { + r := bool(C.wickra_roc_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Roc) Update(value float64) float64 { @@ -20738,6 +26050,22 @@ func NewRocp(period int) (*Rocp, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rocp) WarmupPeriod() int { + r := int(C.wickra_rocp_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rocp) IsReady() bool { + r := bool(C.wickra_rocp_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rocp) Update(value float64) float64 { @@ -20793,6 +26121,22 @@ func NewRocr(period int) (*Rocr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rocr) WarmupPeriod() int { + r := int(C.wickra_rocr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rocr) IsReady() bool { + r := bool(C.wickra_rocr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rocr) Update(value float64) float64 { @@ -20848,6 +26192,22 @@ func NewRocr100(period int) (*Rocr100, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rocr100) WarmupPeriod() int { + r := int(C.wickra_rocr100_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rocr100) IsReady() bool { + r := bool(C.wickra_rocr100_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rocr100) Update(value float64) float64 { @@ -20903,6 +26263,22 @@ func NewRogersSatchellVolatility(period int, tradingPeriods int) (*RogersSatchel return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RogersSatchellVolatility) WarmupPeriod() int { + r := int(C.wickra_rogers_satchell_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RogersSatchellVolatility) IsReady() bool { + r := bool(C.wickra_rogers_satchell_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RogersSatchellVolatility) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -20978,6 +26354,22 @@ func NewRollMeasure(period int) (*RollMeasure, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollMeasure) WarmupPeriod() int { + r := int(C.wickra_roll_measure_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollMeasure) IsReady() bool { + r := bool(C.wickra_roll_measure_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollMeasure) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -21019,6 +26411,22 @@ func NewRollingCorrelation(period int) (*RollingCorrelation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingCorrelation) WarmupPeriod() int { + r := int(C.wickra_rolling_correlation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingCorrelation) IsReady() bool { + r := bool(C.wickra_rolling_correlation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingCorrelation) Update(x float64, y float64) float64 { @@ -21078,6 +26486,22 @@ func NewRollingCovariance(period int) (*RollingCovariance, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingCovariance) WarmupPeriod() int { + r := int(C.wickra_rolling_covariance_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingCovariance) IsReady() bool { + r := bool(C.wickra_rolling_covariance_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingCovariance) Update(x float64, y float64) float64 { @@ -21137,6 +26561,22 @@ func NewRollingIqr(period int) (*RollingIqr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingIqr) WarmupPeriod() int { + r := int(C.wickra_rolling_iqr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingIqr) IsReady() bool { + r := bool(C.wickra_rolling_iqr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingIqr) Update(value float64) float64 { @@ -21192,6 +26632,22 @@ func NewRollingMinMaxScaler(period int) (*RollingMinMaxScaler, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingMinMaxScaler) WarmupPeriod() int { + r := int(C.wickra_rolling_min_max_scaler_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingMinMaxScaler) IsReady() bool { + r := bool(C.wickra_rolling_min_max_scaler_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingMinMaxScaler) Update(value float64) float64 { @@ -21247,6 +26703,22 @@ func NewRollingPercentileRank(period int) (*RollingPercentileRank, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingPercentileRank) WarmupPeriod() int { + r := int(C.wickra_rolling_percentile_rank_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingPercentileRank) IsReady() bool { + r := bool(C.wickra_rolling_percentile_rank_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingPercentileRank) Update(value float64) float64 { @@ -21302,6 +26774,22 @@ func NewRollingQuantile(period int, quantile float64) (*RollingQuantile, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingQuantile) WarmupPeriod() int { + r := int(C.wickra_rolling_quantile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingQuantile) IsReady() bool { + r := bool(C.wickra_rolling_quantile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingQuantile) Update(value float64) float64 { @@ -21357,6 +26845,22 @@ func NewRollingVwap(period int) (*RollingVwap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RollingVwap) WarmupPeriod() int { + r := int(C.wickra_rolling_vwap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RollingVwap) IsReady() bool { + r := bool(C.wickra_rolling_vwap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RollingVwap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -21432,6 +26936,22 @@ func NewRoofingFilter(lpPeriod int, hpPeriod int) (*RoofingFilter, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RoofingFilter) WarmupPeriod() int { + r := int(C.wickra_roofing_filter_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RoofingFilter) IsReady() bool { + r := bool(C.wickra_roofing_filter_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RoofingFilter) Update(value float64) float64 { @@ -21487,6 +27007,22 @@ func NewRsi(period int) (*Rsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rsi) WarmupPeriod() int { + r := int(C.wickra_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rsi) IsReady() bool { + r := bool(C.wickra_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rsi) Update(value float64) float64 { @@ -21542,6 +27078,22 @@ func NewRsx(length int) (*Rsx, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rsx) WarmupPeriod() int { + r := int(C.wickra_rsx_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rsx) IsReady() bool { + r := bool(C.wickra_rsx_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rsx) Update(value float64) float64 { @@ -21647,6 +27199,22 @@ func NewRvi(period int) (*Rvi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rvi) WarmupPeriod() int { + r := int(C.wickra_rvi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rvi) IsReady() bool { + r := bool(C.wickra_rvi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Rvi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -21722,6 +27290,22 @@ func NewRviVolatility(period int) (*RviVolatility, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *RviVolatility) WarmupPeriod() int { + r := int(C.wickra_rvi_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *RviVolatility) IsReady() bool { + r := bool(C.wickra_rvi_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *RviVolatility) Update(value float64) float64 { @@ -21777,6 +27361,22 @@ func NewRwi(period int) (*Rwi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Rwi) WarmupPeriod() int { + r := int(C.wickra_rwi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Rwi) IsReady() bool { + r := bool(C.wickra_rwi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Rwi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (RwiOutput, bool) { @@ -21822,6 +27422,22 @@ func NewSampleEntropy(period int, m int, rFactor float64) (*SampleEntropy, error return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SampleEntropy) WarmupPeriod() int { + r := int(C.wickra_sample_entropy_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SampleEntropy) IsReady() bool { + r := bool(C.wickra_sample_entropy_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SampleEntropy) Update(value float64) float64 { @@ -21877,6 +27493,22 @@ func NewSarExt(startValue float64, offsetOnReverse float64, accelInitLong float6 return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SarExt) WarmupPeriod() int { + r := int(C.wickra_sar_ext_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SarExt) IsReady() bool { + r := bool(C.wickra_sar_ext_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SarExt) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -21952,6 +27584,22 @@ func NewSeasonalZScore(utcOffsetMinutes int32) (*SeasonalZScore, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SeasonalZScore) WarmupPeriod() int { + r := int(C.wickra_seasonal_z_score_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SeasonalZScore) IsReady() bool { + r := bool(C.wickra_seasonal_z_score_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SeasonalZScore) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22027,6 +27675,22 @@ func NewSeparatingLines() (*SeparatingLines, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SeparatingLines) WarmupPeriod() int { + r := int(C.wickra_separating_lines_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SeparatingLines) IsReady() bool { + r := bool(C.wickra_separating_lines_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SeparatingLines) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22102,6 +27766,22 @@ func NewSessionHighLow(utcOffsetMinutes int32) (*SessionHighLow, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SessionHighLow) WarmupPeriod() int { + r := int(C.wickra_session_high_low_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SessionHighLow) IsReady() bool { + r := bool(C.wickra_session_high_low_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *SessionHighLow) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (SessionHighLowOutput, bool) { @@ -22147,6 +27827,22 @@ func NewSessionRange(utcOffsetMinutes int32) (*SessionRange, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SessionRange) WarmupPeriod() int { + r := int(C.wickra_session_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SessionRange) IsReady() bool { + r := bool(C.wickra_session_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *SessionRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (SessionRangeOutput, bool) { @@ -22192,6 +27888,22 @@ func NewSessionVwap(utcOffsetMinutes int32) (*SessionVwap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SessionVwap) WarmupPeriod() int { + r := int(C.wickra_session_vwap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SessionVwap) IsReady() bool { + r := bool(C.wickra_session_vwap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SessionVwap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22267,6 +27979,22 @@ func NewShannonEntropy(period int, bins int) (*ShannonEntropy, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ShannonEntropy) WarmupPeriod() int { + r := int(C.wickra_shannon_entropy_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ShannonEntropy) IsReady() bool { + r := bool(C.wickra_shannon_entropy_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ShannonEntropy) Update(value float64) float64 { @@ -22322,6 +28050,22 @@ func NewShark() (*Shark, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Shark) WarmupPeriod() int { + r := int(C.wickra_shark_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Shark) IsReady() bool { + r := bool(C.wickra_shark_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Shark) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22397,6 +28141,22 @@ func NewSharpeRatio(period int, riskFree float64) (*SharpeRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SharpeRatio) WarmupPeriod() int { + r := int(C.wickra_sharpe_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SharpeRatio) IsReady() bool { + r := bool(C.wickra_sharpe_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SharpeRatio) Update(value float64) float64 { @@ -22452,6 +28212,22 @@ func NewShootingStar() (*ShootingStar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ShootingStar) WarmupPeriod() int { + r := int(C.wickra_shooting_star_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ShootingStar) IsReady() bool { + r := bool(C.wickra_shooting_star_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ShootingStar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22527,6 +28303,22 @@ func NewShortLine() (*ShortLine, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ShortLine) WarmupPeriod() int { + r := int(C.wickra_short_line_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ShortLine) IsReady() bool { + r := bool(C.wickra_short_line_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ShortLine) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22602,6 +28394,22 @@ func NewSignedVolume() (*SignedVolume, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SignedVolume) WarmupPeriod() int { + r := int(C.wickra_signed_volume_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SignedVolume) IsReady() bool { + r := bool(C.wickra_signed_volume_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SignedVolume) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -22643,6 +28451,22 @@ func NewSineWave() (*SineWave, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SineWave) WarmupPeriod() int { + r := int(C.wickra_sine_wave_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SineWave) IsReady() bool { + r := bool(C.wickra_sine_wave_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SineWave) Update(value float64) float64 { @@ -22698,6 +28522,22 @@ func NewSineWeightedMa(period int) (*SineWeightedMa, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SineWeightedMa) WarmupPeriod() int { + r := int(C.wickra_sine_weighted_ma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SineWeightedMa) IsReady() bool { + r := bool(C.wickra_sine_weighted_ma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SineWeightedMa) Update(value float64) float64 { @@ -22753,6 +28593,22 @@ func NewSinglePrints(period int, bins int) (*SinglePrints, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SinglePrints) WarmupPeriod() int { + r := int(C.wickra_single_prints_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SinglePrints) IsReady() bool { + r := bool(C.wickra_single_prints_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SinglePrints) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -22828,6 +28684,22 @@ func NewSkewness(period int) (*Skewness, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Skewness) WarmupPeriod() int { + r := int(C.wickra_skewness_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Skewness) IsReady() bool { + r := bool(C.wickra_skewness_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Skewness) Update(value float64) float64 { @@ -22883,6 +28755,22 @@ func NewSma(period int) (*Sma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Sma) WarmupPeriod() int { + r := int(C.wickra_sma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Sma) IsReady() bool { + r := bool(C.wickra_sma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Sma) Update(value float64) float64 { @@ -22938,6 +28826,22 @@ func NewSmi(period int, dPeriod int, d2Period int) (*Smi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Smi) WarmupPeriod() int { + r := int(C.wickra_smi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Smi) IsReady() bool { + r := bool(C.wickra_smi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Smi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -23013,6 +28917,22 @@ func NewSmma(period int) (*Smma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Smma) WarmupPeriod() int { + r := int(C.wickra_smma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Smma) IsReady() bool { + r := bool(C.wickra_smma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Smma) Update(value float64) float64 { @@ -23068,6 +28988,22 @@ func NewSmoothedHeikinAshi(period int) (*SmoothedHeikinAshi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SmoothedHeikinAshi) WarmupPeriod() int { + r := int(C.wickra_smoothed_heikin_ashi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SmoothedHeikinAshi) IsReady() bool { + r := bool(C.wickra_smoothed_heikin_ashi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *SmoothedHeikinAshi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (SmoothedHeikinAshiOutput, bool) { @@ -23113,6 +29049,22 @@ func NewSortinoRatio(period int, mar float64) (*SortinoRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SortinoRatio) WarmupPeriod() int { + r := int(C.wickra_sortino_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SortinoRatio) IsReady() bool { + r := bool(C.wickra_sortino_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SortinoRatio) Update(value float64) float64 { @@ -23168,6 +29120,22 @@ func NewSpearmanCorrelation(period int) (*SpearmanCorrelation, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SpearmanCorrelation) WarmupPeriod() int { + r := int(C.wickra_spearman_correlation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SpearmanCorrelation) IsReady() bool { + r := bool(C.wickra_spearman_correlation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SpearmanCorrelation) Update(x float64, y float64) float64 { @@ -23227,6 +29195,22 @@ func NewSpinningTop() (*SpinningTop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SpinningTop) WarmupPeriod() int { + r := int(C.wickra_spinning_top_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SpinningTop) IsReady() bool { + r := bool(C.wickra_spinning_top_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SpinningTop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -23302,6 +29286,22 @@ func NewSpreadAr1Coefficient(period int) (*SpreadAr1Coefficient, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SpreadAr1Coefficient) WarmupPeriod() int { + r := int(C.wickra_spread_ar1_coefficient_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SpreadAr1Coefficient) IsReady() bool { + r := bool(C.wickra_spread_ar1_coefficient_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SpreadAr1Coefficient) Update(x float64, y float64) float64 { @@ -23361,6 +29361,22 @@ func NewSpreadBollingerBands(period int, numStd float64) (*SpreadBollingerBands, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SpreadBollingerBands) WarmupPeriod() int { + r := int(C.wickra_spread_bollinger_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SpreadBollingerBands) IsReady() bool { + r := bool(C.wickra_spread_bollinger_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *SpreadBollingerBands) Update(x float64, y float64) (SpreadBollingerBandsOutput, bool) { @@ -23406,6 +29422,22 @@ func NewSpreadHurst(period int) (*SpreadHurst, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SpreadHurst) WarmupPeriod() int { + r := int(C.wickra_spread_hurst_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SpreadHurst) IsReady() bool { + r := bool(C.wickra_spread_hurst_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SpreadHurst) Update(x float64, y float64) float64 { @@ -23465,6 +29497,22 @@ func NewStalledPattern() (*StalledPattern, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StalledPattern) WarmupPeriod() int { + r := int(C.wickra_stalled_pattern_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StalledPattern) IsReady() bool { + r := bool(C.wickra_stalled_pattern_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StalledPattern) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -23540,6 +29588,22 @@ func NewStandardError(period int) (*StandardError, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StandardError) WarmupPeriod() int { + r := int(C.wickra_standard_error_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StandardError) IsReady() bool { + r := bool(C.wickra_standard_error_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StandardError) Update(value float64) float64 { @@ -23595,6 +29659,22 @@ func NewStandardErrorBands(period int, multiplier float64) (*StandardErrorBands, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StandardErrorBands) WarmupPeriod() int { + r := int(C.wickra_standard_error_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StandardErrorBands) IsReady() bool { + r := bool(C.wickra_standard_error_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *StandardErrorBands) Update(value float64) (StandardErrorBandsOutput, bool) { @@ -23640,6 +29720,22 @@ func NewStarcBands(smaPeriod int, atrPeriod int, multiplier float64) (*StarcBand return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StarcBands) WarmupPeriod() int { + r := int(C.wickra_starc_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StarcBands) IsReady() bool { + r := bool(C.wickra_starc_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *StarcBands) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (StarcBandsOutput, bool) { @@ -23685,6 +29781,22 @@ func NewStc(fast int, slow int, schaffPeriod int, factor float64) (*Stc, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Stc) WarmupPeriod() int { + r := int(C.wickra_stc_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Stc) IsReady() bool { + r := bool(C.wickra_stc_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Stc) Update(value float64) float64 { @@ -23740,6 +29852,22 @@ func NewStdDev(period int) (*StdDev, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StdDev) WarmupPeriod() int { + r := int(C.wickra_std_dev_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StdDev) IsReady() bool { + r := bool(C.wickra_std_dev_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StdDev) Update(value float64) float64 { @@ -23795,6 +29923,22 @@ func NewStepTrailingStop(stepSize float64) (*StepTrailingStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StepTrailingStop) WarmupPeriod() int { + r := int(C.wickra_step_trailing_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StepTrailingStop) IsReady() bool { + r := bool(C.wickra_step_trailing_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StepTrailingStop) Update(value float64) float64 { @@ -23850,6 +29994,22 @@ func NewSterlingRatio(period int) (*SterlingRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SterlingRatio) WarmupPeriod() int { + r := int(C.wickra_sterling_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SterlingRatio) IsReady() bool { + r := bool(C.wickra_sterling_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SterlingRatio) Update(value float64) float64 { @@ -23905,6 +30065,22 @@ func NewStickSandwich() (*StickSandwich, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StickSandwich) WarmupPeriod() int { + r := int(C.wickra_stick_sandwich_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StickSandwich) IsReady() bool { + r := bool(C.wickra_stick_sandwich_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StickSandwich) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -23980,6 +30156,22 @@ func NewStochRsi(rsiPeriod int, stochPeriod int) (*StochRsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StochRsi) WarmupPeriod() int { + r := int(C.wickra_stoch_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StochRsi) IsReady() bool { + r := bool(C.wickra_stoch_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StochRsi) Update(value float64) float64 { @@ -24035,6 +30227,22 @@ func NewStochastic(kPeriod int, dPeriod int) (*Stochastic, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Stochastic) WarmupPeriod() int { + r := int(C.wickra_stochastic_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Stochastic) IsReady() bool { + r := bool(C.wickra_stochastic_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Stochastic) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (StochasticOutput, bool) { @@ -24080,6 +30288,22 @@ func NewStochasticCci(period int) (*StochasticCci, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *StochasticCci) WarmupPeriod() int { + r := int(C.wickra_stochastic_cci_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *StochasticCci) IsReady() bool { + r := bool(C.wickra_stochastic_cci_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *StochasticCci) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24155,6 +30379,22 @@ func NewSuperSmoother(period int) (*SuperSmoother, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SuperSmoother) WarmupPeriod() int { + r := int(C.wickra_super_smoother_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SuperSmoother) IsReady() bool { + r := bool(C.wickra_super_smoother_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *SuperSmoother) Update(value float64) float64 { @@ -24210,6 +30450,22 @@ func NewSuperTrend(atrPeriod int, multiplier float64) (*SuperTrend, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *SuperTrend) WarmupPeriod() int { + r := int(C.wickra_super_trend_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *SuperTrend) IsReady() bool { + r := bool(C.wickra_super_trend_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *SuperTrend) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (SuperTrendOutput, bool) { @@ -24255,6 +30511,22 @@ func NewT3(period int, v float64) (*T3, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *T3) WarmupPeriod() int { + r := int(C.wickra_t3_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *T3) IsReady() bool { + r := bool(C.wickra_t3_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *T3) Update(value float64) float64 { @@ -24310,6 +30582,22 @@ func NewTailRatio(period int) (*TailRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TailRatio) WarmupPeriod() int { + r := int(C.wickra_tail_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TailRatio) IsReady() bool { + r := bool(C.wickra_tail_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TailRatio) Update(value float64) float64 { @@ -24365,6 +30653,22 @@ func NewTakerBuySellRatio() (*TakerBuySellRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TakerBuySellRatio) WarmupPeriod() int { + r := int(C.wickra_taker_buy_sell_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TakerBuySellRatio) IsReady() bool { + r := bool(C.wickra_taker_buy_sell_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TakerBuySellRatio) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -24406,6 +30710,22 @@ func NewTakuri() (*Takuri, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Takuri) WarmupPeriod() int { + r := int(C.wickra_takuri_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Takuri) IsReady() bool { + r := bool(C.wickra_takuri_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Takuri) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24481,6 +30801,22 @@ func NewTasukiGap() (*TasukiGap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TasukiGap) WarmupPeriod() int { + r := int(C.wickra_tasuki_gap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TasukiGap) IsReady() bool { + r := bool(C.wickra_tasuki_gap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TasukiGap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24556,6 +30892,22 @@ func NewTdCamouflage() (*TdCamouflage, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdCamouflage) WarmupPeriod() int { + r := int(C.wickra_td_camouflage_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdCamouflage) IsReady() bool { + r := bool(C.wickra_td_camouflage_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdCamouflage) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24631,6 +30983,22 @@ func NewTdClop() (*TdClop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdClop) WarmupPeriod() int { + r := int(C.wickra_td_clop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdClop) IsReady() bool { + r := bool(C.wickra_td_clop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdClop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24706,6 +31074,22 @@ func NewTdClopwin() (*TdClopwin, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdClopwin) WarmupPeriod() int { + r := int(C.wickra_td_clopwin_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdClopwin) IsReady() bool { + r := bool(C.wickra_td_clopwin_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdClopwin) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24781,6 +31165,22 @@ func NewTdCombo(setupLookback int, setupTarget int, countdownLookback int, count return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdCombo) WarmupPeriod() int { + r := int(C.wickra_td_combo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdCombo) IsReady() bool { + r := bool(C.wickra_td_combo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdCombo) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24856,6 +31256,22 @@ func NewTdCountdown(setupLookback int, setupTarget int, countdownLookback int, c return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdCountdown) WarmupPeriod() int { + r := int(C.wickra_td_countdown_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdCountdown) IsReady() bool { + r := bool(C.wickra_td_countdown_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdCountdown) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -24931,6 +31347,22 @@ func NewTdDWave(strength int) (*TdDWave, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdDWave) WarmupPeriod() int { + r := int(C.wickra_td_d_wave_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdDWave) IsReady() bool { + r := bool(C.wickra_td_d_wave_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdDWave) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25006,6 +31438,22 @@ func NewTdDeMarker(period int) (*TdDeMarker, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdDeMarker) WarmupPeriod() int { + r := int(C.wickra_td_de_marker_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdDeMarker) IsReady() bool { + r := bool(C.wickra_td_de_marker_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdDeMarker) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25081,6 +31529,22 @@ func NewTdDifferential() (*TdDifferential, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdDifferential) WarmupPeriod() int { + r := int(C.wickra_td_differential_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdDifferential) IsReady() bool { + r := bool(C.wickra_td_differential_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdDifferential) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25156,6 +31620,22 @@ func NewTdLines(lookback int, target int) (*TdLines, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdLines) WarmupPeriod() int { + r := int(C.wickra_td_lines_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdLines) IsReady() bool { + r := bool(C.wickra_td_lines_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *TdLines) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TdLinesOutput, bool) { @@ -25201,6 +31681,22 @@ func NewTdMovingAverage(periodSt1 int, periodSt2 int) (*TdMovingAverage, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdMovingAverage) WarmupPeriod() int { + r := int(C.wickra_td_moving_average_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdMovingAverage) IsReady() bool { + r := bool(C.wickra_td_moving_average_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *TdMovingAverage) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TdMovingAverageOutput, bool) { @@ -25246,6 +31742,22 @@ func NewTdOpen() (*TdOpen, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdOpen) WarmupPeriod() int { + r := int(C.wickra_td_open_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdOpen) IsReady() bool { + r := bool(C.wickra_td_open_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdOpen) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25321,6 +31833,22 @@ func NewTdPressure(period int) (*TdPressure, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdPressure) WarmupPeriod() int { + r := int(C.wickra_td_pressure_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdPressure) IsReady() bool { + r := bool(C.wickra_td_pressure_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdPressure) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25396,6 +31924,22 @@ func NewTdPropulsion() (*TdPropulsion, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdPropulsion) WarmupPeriod() int { + r := int(C.wickra_td_propulsion_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdPropulsion) IsReady() bool { + r := bool(C.wickra_td_propulsion_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdPropulsion) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25471,6 +32015,22 @@ func NewTdRangeProjection() (*TdRangeProjection, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdRangeProjection) WarmupPeriod() int { + r := int(C.wickra_td_range_projection_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdRangeProjection) IsReady() bool { + r := bool(C.wickra_td_range_projection_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *TdRangeProjection) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TdRangeProjectionOutput, bool) { @@ -25516,6 +32076,22 @@ func NewTdRei(period int) (*TdRei, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdRei) WarmupPeriod() int { + r := int(C.wickra_td_rei_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdRei) IsReady() bool { + r := bool(C.wickra_td_rei_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdRei) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25591,6 +32167,22 @@ func NewTdRiskLevel(lookback int, target int) (*TdRiskLevel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdRiskLevel) WarmupPeriod() int { + r := int(C.wickra_td_risk_level_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdRiskLevel) IsReady() bool { + r := bool(C.wickra_td_risk_level_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *TdRiskLevel) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TdRiskLevelOutput, bool) { @@ -25636,6 +32228,22 @@ func NewTdSequential(setupLookback int, setupTarget int, countdownLookback int, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdSequential) WarmupPeriod() int { + r := int(C.wickra_td_sequential_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdSequential) IsReady() bool { + r := bool(C.wickra_td_sequential_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *TdSequential) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TdSequentialOutput, bool) { @@ -25681,6 +32289,22 @@ func NewTdSetup(lookback int, target int) (*TdSetup, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdSetup) WarmupPeriod() int { + r := int(C.wickra_td_setup_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdSetup) IsReady() bool { + r := bool(C.wickra_td_setup_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdSetup) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25756,6 +32380,22 @@ func NewTdTrap() (*TdTrap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TdTrap) WarmupPeriod() int { + r := int(C.wickra_td_trap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TdTrap) IsReady() bool { + r := bool(C.wickra_td_trap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TdTrap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -25831,6 +32471,22 @@ func NewTema(period int) (*Tema, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tema) WarmupPeriod() int { + r := int(C.wickra_tema_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tema) IsReady() bool { + r := bool(C.wickra_tema_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tema) Update(value float64) float64 { @@ -25886,6 +32542,22 @@ func NewTermStructureBasis() (*TermStructureBasis, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TermStructureBasis) WarmupPeriod() int { + r := int(C.wickra_term_structure_basis_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TermStructureBasis) IsReady() bool { + r := bool(C.wickra_term_structure_basis_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TermStructureBasis) Update(fundingRate float64, markPrice float64, indexPrice float64, futuresPrice float64, openInterest float64, longSize float64, shortSize float64, takerBuyVolume float64, takerSellVolume float64, longLiquidation float64, shortLiquidation float64, timestamp int64) float64 { @@ -25927,6 +32599,22 @@ func NewThreeDrives() (*ThreeDrives, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeDrives) WarmupPeriod() int { + r := int(C.wickra_three_drives_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeDrives) IsReady() bool { + r := bool(C.wickra_three_drives_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeDrives) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26002,6 +32690,22 @@ func NewThreeInside() (*ThreeInside, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeInside) WarmupPeriod() int { + r := int(C.wickra_three_inside_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeInside) IsReady() bool { + r := bool(C.wickra_three_inside_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeInside) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26077,6 +32781,22 @@ func NewThreeLineBreak(lines int) (*ThreeLineBreak, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeLineBreak) WarmupPeriod() int { + r := int(C.wickra_three_line_break_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeLineBreak) IsReady() bool { + r := bool(C.wickra_three_line_break_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeLineBreak) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26202,6 +32922,22 @@ func NewThreeLineStrike() (*ThreeLineStrike, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeLineStrike) WarmupPeriod() int { + r := int(C.wickra_three_line_strike_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeLineStrike) IsReady() bool { + r := bool(C.wickra_three_line_strike_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeLineStrike) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26277,6 +33013,22 @@ func NewThreeOutside() (*ThreeOutside, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeOutside) WarmupPeriod() int { + r := int(C.wickra_three_outside_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeOutside) IsReady() bool { + r := bool(C.wickra_three_outside_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeOutside) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26352,6 +33104,22 @@ func NewThreeSoldiersOrCrows() (*ThreeSoldiersOrCrows, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeSoldiersOrCrows) WarmupPeriod() int { + r := int(C.wickra_three_soldiers_or_crows_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeSoldiersOrCrows) IsReady() bool { + r := bool(C.wickra_three_soldiers_or_crows_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeSoldiersOrCrows) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26427,6 +33195,22 @@ func NewThreeStarsInSouth() (*ThreeStarsInSouth, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ThreeStarsInSouth) WarmupPeriod() int { + r := int(C.wickra_three_stars_in_south_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ThreeStarsInSouth) IsReady() bool { + r := bool(C.wickra_three_stars_in_south_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ThreeStarsInSouth) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26502,6 +33286,22 @@ func NewThrusting() (*Thrusting, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Thrusting) WarmupPeriod() int { + r := int(C.wickra_thrusting_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Thrusting) IsReady() bool { + r := bool(C.wickra_thrusting_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Thrusting) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26627,6 +33427,22 @@ func NewTickIndex() (*TickIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TickIndex) WarmupPeriod() int { + r := int(C.wickra_tick_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TickIndex) IsReady() bool { + r := bool(C.wickra_tick_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *TickIndex) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -26689,6 +33505,22 @@ func NewTii(smaPeriod int, devPeriod int) (*Tii, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tii) WarmupPeriod() int { + r := int(C.wickra_tii_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tii) IsReady() bool { + r := bool(C.wickra_tii_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tii) Update(value float64) float64 { @@ -26744,6 +33576,22 @@ func NewTimeBasedStop(maxBars int) (*TimeBasedStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TimeBasedStop) WarmupPeriod() int { + r := int(C.wickra_time_based_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TimeBasedStop) IsReady() bool { + r := bool(C.wickra_time_based_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TimeBasedStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26821,6 +33669,22 @@ func NewTimeOfDayReturnProfile(buckets int, utcOffsetMinutes int32) (*TimeOfDayR return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TimeOfDayReturnProfile) WarmupPeriod() int { + r := int(C.wickra_time_of_day_return_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TimeOfDayReturnProfile) IsReady() bool { + r := bool(C.wickra_time_of_day_return_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the profile values // (ok is false during warmup). func (ind *TimeOfDayReturnProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) ([]float64, bool) { @@ -26866,6 +33730,22 @@ func NewTowerTopBottom() (*TowerTopBottom, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TowerTopBottom) WarmupPeriod() int { + r := int(C.wickra_tower_top_bottom_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TowerTopBottom) IsReady() bool { + r := bool(C.wickra_tower_top_bottom_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TowerTopBottom) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -26943,6 +33823,22 @@ func NewTpoProfile(period int, binCount int) (*TpoProfile, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TpoProfile) WarmupPeriod() int { + r := int(C.wickra_tpo_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TpoProfile) IsReady() bool { + r := bool(C.wickra_tpo_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the profile snapshot // (ok is false during warmup). func (ind *TpoProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TpoProfileOutputScalars, bool) { @@ -26989,6 +33885,22 @@ func NewTradeImbalance(window int) (*TradeImbalance, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TradeImbalance) WarmupPeriod() int { + r := int(C.wickra_trade_imbalance_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TradeImbalance) IsReady() bool { + r := bool(C.wickra_trade_imbalance_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TradeImbalance) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -27030,6 +33942,22 @@ func NewTradeSignAutocorrelation(period int) (*TradeSignAutocorrelation, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TradeSignAutocorrelation) WarmupPeriod() int { + r := int(C.wickra_trade_sign_autocorrelation_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TradeSignAutocorrelation) IsReady() bool { + r := bool(C.wickra_trade_sign_autocorrelation_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TradeSignAutocorrelation) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -27071,6 +33999,22 @@ func NewTradeVolumeIndex(minTick float64) (*TradeVolumeIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TradeVolumeIndex) WarmupPeriod() int { + r := int(C.wickra_trade_volume_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TradeVolumeIndex) IsReady() bool { + r := bool(C.wickra_trade_volume_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TradeVolumeIndex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -27146,6 +34090,22 @@ func NewTrendLabel(period int) (*TrendLabel, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TrendLabel) WarmupPeriod() int { + r := int(C.wickra_trend_label_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TrendLabel) IsReady() bool { + r := bool(C.wickra_trend_label_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TrendLabel) Update(value float64) float64 { @@ -27201,6 +34161,22 @@ func NewTrendStrengthIndex(period int) (*TrendStrengthIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TrendStrengthIndex) WarmupPeriod() int { + r := int(C.wickra_trend_strength_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TrendStrengthIndex) IsReady() bool { + r := bool(C.wickra_trend_strength_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TrendStrengthIndex) Update(value float64) float64 { @@ -27256,6 +34232,22 @@ func NewTrendflex(period int) (*Trendflex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Trendflex) WarmupPeriod() int { + r := int(C.wickra_trendflex_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Trendflex) IsReady() bool { + r := bool(C.wickra_trendflex_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Trendflex) Update(value float64) float64 { @@ -27311,6 +34303,22 @@ func NewTreynorRatio(period int, riskFree float64) (*TreynorRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TreynorRatio) WarmupPeriod() int { + r := int(C.wickra_treynor_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TreynorRatio) IsReady() bool { + r := bool(C.wickra_treynor_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TreynorRatio) Update(x float64, y float64) float64 { @@ -27370,6 +34378,22 @@ func NewTriangle() (*Triangle, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Triangle) WarmupPeriod() int { + r := int(C.wickra_triangle_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Triangle) IsReady() bool { + r := bool(C.wickra_triangle_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Triangle) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -27445,6 +34469,22 @@ func NewTrima(period int) (*Trima, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Trima) WarmupPeriod() int { + r := int(C.wickra_trima_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Trima) IsReady() bool { + r := bool(C.wickra_trima_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Trima) Update(value float64) float64 { @@ -27500,6 +34540,22 @@ func NewTrin() (*Trin, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Trin) WarmupPeriod() int { + r := int(C.wickra_trin_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Trin) IsReady() bool { + r := bool(C.wickra_trin_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *Trin) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -27562,6 +34618,22 @@ func NewTripleTopBottom() (*TripleTopBottom, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TripleTopBottom) WarmupPeriod() int { + r := int(C.wickra_triple_top_bottom_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TripleTopBottom) IsReady() bool { + r := bool(C.wickra_triple_top_bottom_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TripleTopBottom) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -27637,6 +34709,22 @@ func NewTristar() (*Tristar, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tristar) WarmupPeriod() int { + r := int(C.wickra_tristar_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tristar) IsReady() bool { + r := bool(C.wickra_tristar_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tristar) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -27712,6 +34800,22 @@ func NewTrix(period int) (*Trix, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Trix) WarmupPeriod() int { + r := int(C.wickra_trix_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Trix) IsReady() bool { + r := bool(C.wickra_trix_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Trix) Update(value float64) float64 { @@ -27767,6 +34871,22 @@ func NewTrueRange() (*TrueRange, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TrueRange) WarmupPeriod() int { + r := int(C.wickra_true_range_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TrueRange) IsReady() bool { + r := bool(C.wickra_true_range_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TrueRange) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -27842,6 +34962,22 @@ func NewTsf(period int) (*Tsf, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tsf) WarmupPeriod() int { + r := int(C.wickra_tsf_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tsf) IsReady() bool { + r := bool(C.wickra_tsf_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tsf) Update(value float64) float64 { @@ -27897,6 +35033,22 @@ func NewTsfOscillator(period int) (*TsfOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TsfOscillator) WarmupPeriod() int { + r := int(C.wickra_tsf_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TsfOscillator) IsReady() bool { + r := bool(C.wickra_tsf_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TsfOscillator) Update(value float64) float64 { @@ -27952,6 +35104,22 @@ func NewTsi(long int, short int) (*Tsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tsi) WarmupPeriod() int { + r := int(C.wickra_tsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tsi) IsReady() bool { + r := bool(C.wickra_tsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tsi) Update(value float64) float64 { @@ -28007,6 +35175,22 @@ func NewTsv(period int) (*Tsv, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tsv) WarmupPeriod() int { + r := int(C.wickra_tsv_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tsv) IsReady() bool { + r := bool(C.wickra_tsv_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tsv) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28082,6 +35266,22 @@ func NewTtmSqueeze(period int, bbMult float64, kcMult float64) (*TtmSqueeze, err return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TtmSqueeze) WarmupPeriod() int { + r := int(C.wickra_ttm_squeeze_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TtmSqueeze) IsReady() bool { + r := bool(C.wickra_ttm_squeeze_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *TtmSqueeze) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (TtmSqueezeOutput, bool) { @@ -28127,6 +35327,22 @@ func NewTtmTrend(period int) (*TtmTrend, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TtmTrend) WarmupPeriod() int { + r := int(C.wickra_ttm_trend_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TtmTrend) IsReady() bool { + r := bool(C.wickra_ttm_trend_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TtmTrend) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28202,6 +35418,22 @@ func NewTurnOfMonth(nFirst uint32, nLast uint32, utcOffsetMinutes int32) (*TurnO return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TurnOfMonth) WarmupPeriod() int { + r := int(C.wickra_turn_of_month_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TurnOfMonth) IsReady() bool { + r := bool(C.wickra_turn_of_month_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TurnOfMonth) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28277,6 +35509,22 @@ func NewTweezer() (*Tweezer, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Tweezer) WarmupPeriod() int { + r := int(C.wickra_tweezer_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Tweezer) IsReady() bool { + r := bool(C.wickra_tweezer_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Tweezer) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28352,6 +35600,22 @@ func NewTwiggsMoneyFlow(period int) (*TwiggsMoneyFlow, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TwiggsMoneyFlow) WarmupPeriod() int { + r := int(C.wickra_twiggs_money_flow_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TwiggsMoneyFlow) IsReady() bool { + r := bool(C.wickra_twiggs_money_flow_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TwiggsMoneyFlow) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28427,6 +35691,22 @@ func NewTwoCrows() (*TwoCrows, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TwoCrows) WarmupPeriod() int { + r := int(C.wickra_two_crows_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TwoCrows) IsReady() bool { + r := bool(C.wickra_two_crows_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TwoCrows) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28502,6 +35782,22 @@ func NewTypicalPrice() (*TypicalPrice, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *TypicalPrice) WarmupPeriod() int { + r := int(C.wickra_typical_price_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *TypicalPrice) IsReady() bool { + r := bool(C.wickra_typical_price_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *TypicalPrice) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28577,6 +35873,22 @@ func NewUlcerIndex(period int) (*UlcerIndex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UlcerIndex) WarmupPeriod() int { + r := int(C.wickra_ulcer_index_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UlcerIndex) IsReady() bool { + r := bool(C.wickra_ulcer_index_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UlcerIndex) Update(value float64) float64 { @@ -28632,6 +35944,22 @@ func NewUltimateOscillator(short int, mid int, long int) (*UltimateOscillator, e return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UltimateOscillator) WarmupPeriod() int { + r := int(C.wickra_ultimate_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UltimateOscillator) IsReady() bool { + r := bool(C.wickra_ultimate_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UltimateOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28707,6 +36035,22 @@ func NewUniqueThreeRiver() (*UniqueThreeRiver, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UniqueThreeRiver) WarmupPeriod() int { + r := int(C.wickra_unique_three_river_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UniqueThreeRiver) IsReady() bool { + r := bool(C.wickra_unique_three_river_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UniqueThreeRiver) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28782,6 +36126,22 @@ func NewUniversalOscillator(period int) (*UniversalOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UniversalOscillator) WarmupPeriod() int { + r := int(C.wickra_universal_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UniversalOscillator) IsReady() bool { + r := bool(C.wickra_universal_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UniversalOscillator) Update(value float64) float64 { @@ -28837,6 +36197,22 @@ func NewUpDownVolumeRatio() (*UpDownVolumeRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UpDownVolumeRatio) WarmupPeriod() int { + r := int(C.wickra_up_down_volume_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UpDownVolumeRatio) IsReady() bool { + r := bool(C.wickra_up_down_volume_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one cross-sectional snapshot and returns the indicator // value (NaN until warmed up). Slices in a group must share a length. func (ind *UpDownVolumeRatio) Update(change []float64, volume []float64, newHigh []bool, newLow []bool, aboveMa []bool, onBuySignal []bool, timestamp int64) float64 { @@ -28899,6 +36275,22 @@ func NewUpsideGapThreeMethods() (*UpsideGapThreeMethods, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UpsideGapThreeMethods) WarmupPeriod() int { + r := int(C.wickra_upside_gap_three_methods_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UpsideGapThreeMethods) IsReady() bool { + r := bool(C.wickra_upside_gap_three_methods_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UpsideGapThreeMethods) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -28974,6 +36366,22 @@ func NewUpsideGapTwoCrows() (*UpsideGapTwoCrows, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UpsideGapTwoCrows) WarmupPeriod() int { + r := int(C.wickra_upside_gap_two_crows_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UpsideGapTwoCrows) IsReady() bool { + r := bool(C.wickra_upside_gap_two_crows_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UpsideGapTwoCrows) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -29049,6 +36457,22 @@ func NewUpsidePotentialRatio(period int, mar float64) (*UpsidePotentialRatio, er return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *UpsidePotentialRatio) WarmupPeriod() int { + r := int(C.wickra_upside_potential_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *UpsidePotentialRatio) IsReady() bool { + r := bool(C.wickra_upside_potential_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *UpsidePotentialRatio) Update(value float64) float64 { @@ -29104,6 +36528,22 @@ func NewValueArea(period int, binCount int, valueAreaPct float64) (*ValueArea, e return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ValueArea) WarmupPeriod() int { + r := int(C.wickra_value_area_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ValueArea) IsReady() bool { + r := bool(C.wickra_value_area_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ValueArea) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ValueAreaOutput, bool) { @@ -29149,6 +36589,22 @@ func NewValueAtRisk(period int, confidence float64) (*ValueAtRisk, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ValueAtRisk) WarmupPeriod() int { + r := int(C.wickra_value_at_risk_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ValueAtRisk) IsReady() bool { + r := bool(C.wickra_value_at_risk_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ValueAtRisk) Update(value float64) float64 { @@ -29204,6 +36660,22 @@ func NewVariance(period int) (*Variance, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Variance) WarmupPeriod() int { + r := int(C.wickra_variance_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Variance) IsReady() bool { + r := bool(C.wickra_variance_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Variance) Update(value float64) float64 { @@ -29259,6 +36731,22 @@ func NewVarianceRatio(period int, q int) (*VarianceRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VarianceRatio) WarmupPeriod() int { + r := int(C.wickra_variance_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VarianceRatio) IsReady() bool { + r := bool(C.wickra_variance_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VarianceRatio) Update(x float64, y float64) float64 { @@ -29318,6 +36806,22 @@ func NewVerticalHorizontalFilter(period int) (*VerticalHorizontalFilter, error) return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VerticalHorizontalFilter) WarmupPeriod() int { + r := int(C.wickra_vertical_horizontal_filter_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VerticalHorizontalFilter) IsReady() bool { + r := bool(C.wickra_vertical_horizontal_filter_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VerticalHorizontalFilter) Update(value float64) float64 { @@ -29373,6 +36877,22 @@ func NewVidya(period int, cmoPeriod int) (*Vidya, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Vidya) WarmupPeriod() int { + r := int(C.wickra_vidya_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Vidya) IsReady() bool { + r := bool(C.wickra_vidya_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Vidya) Update(value float64) float64 { @@ -29428,6 +36948,22 @@ func NewVolatilityCone(window int, lookback int) (*VolatilityCone, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolatilityCone) WarmupPeriod() int { + r := int(C.wickra_volatility_cone_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolatilityCone) IsReady() bool { + r := bool(C.wickra_volatility_cone_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *VolatilityCone) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (VolatilityConeOutput, bool) { @@ -29473,6 +37009,22 @@ func NewVolatilityOfVolatility(volWindow int, vovWindow int) (*VolatilityOfVolat return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolatilityOfVolatility) WarmupPeriod() int { + r := int(C.wickra_volatility_of_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolatilityOfVolatility) IsReady() bool { + r := bool(C.wickra_volatility_of_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VolatilityOfVolatility) Update(value float64) float64 { @@ -29528,6 +37080,22 @@ func NewVolatilityRatio(period int) (*VolatilityRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolatilityRatio) WarmupPeriod() int { + r := int(C.wickra_volatility_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolatilityRatio) IsReady() bool { + r := bool(C.wickra_volatility_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VolatilityRatio) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -29603,6 +37171,22 @@ func NewVoltyStop(atrPeriod int, multiplier float64) (*VoltyStop, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VoltyStop) WarmupPeriod() int { + r := int(C.wickra_volty_stop_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VoltyStop) IsReady() bool { + r := bool(C.wickra_volty_stop_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VoltyStop) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -29730,6 +37314,22 @@ func NewVolumeByTimeProfile(buckets int, utcOffsetMinutes int32) (*VolumeByTimeP return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumeByTimeProfile) WarmupPeriod() int { + r := int(C.wickra_volume_by_time_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumeByTimeProfile) IsReady() bool { + r := bool(C.wickra_volume_by_time_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the profile values // (ok is false during warmup). func (ind *VolumeByTimeProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) ([]float64, bool) { @@ -29775,6 +37375,22 @@ func NewVolumeOscillator(fast int, slow int) (*VolumeOscillator, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumeOscillator) WarmupPeriod() int { + r := int(C.wickra_volume_oscillator_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumeOscillator) IsReady() bool { + r := bool(C.wickra_volume_oscillator_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VolumeOscillator) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -29850,6 +37466,22 @@ func NewVolumePriceTrend() (*VolumePriceTrend, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumePriceTrend) WarmupPeriod() int { + r := int(C.wickra_volume_price_trend_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumePriceTrend) IsReady() bool { + r := bool(C.wickra_volume_price_trend_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VolumePriceTrend) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -29927,6 +37559,22 @@ func NewVolumeProfile(period int, binCount int) (*VolumeProfile, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumeProfile) WarmupPeriod() int { + r := int(C.wickra_volume_profile_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumeProfile) IsReady() bool { + r := bool(C.wickra_volume_profile_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the profile snapshot // (ok is false during warmup). func (ind *VolumeProfile) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (VolumeProfileOutputScalars, bool) { @@ -29973,6 +37621,22 @@ func NewVolumeRsi(period int) (*VolumeRsi, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumeRsi) WarmupPeriod() int { + r := int(C.wickra_volume_rsi_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumeRsi) IsReady() bool { + r := bool(C.wickra_volume_rsi_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *VolumeRsi) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30048,6 +37712,22 @@ func NewVolumeWeightedMacd(fast int, slow int, signal int) (*VolumeWeightedMacd, return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumeWeightedMacd) WarmupPeriod() int { + r := int(C.wickra_volume_weighted_macd_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumeWeightedMacd) IsReady() bool { + r := bool(C.wickra_volume_weighted_macd_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *VolumeWeightedMacd) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (VolumeWeightedMacdOutput, bool) { @@ -30093,6 +37773,22 @@ func NewVolumeWeightedSr(period int) (*VolumeWeightedSr, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VolumeWeightedSr) WarmupPeriod() int { + r := int(C.wickra_volume_weighted_sr_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VolumeWeightedSr) IsReady() bool { + r := bool(C.wickra_volume_weighted_sr_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *VolumeWeightedSr) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (VolumeWeightedSrOutput, bool) { @@ -30138,6 +37834,22 @@ func NewVortex(period int) (*Vortex, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Vortex) WarmupPeriod() int { + r := int(C.wickra_vortex_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Vortex) IsReady() bool { + r := bool(C.wickra_vortex_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *Vortex) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (VortexOutput, bool) { @@ -30183,6 +37895,22 @@ func NewVpin(bucketVolume float64, numBuckets int) (*Vpin, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Vpin) WarmupPeriod() int { + r := int(C.wickra_vpin_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Vpin) IsReady() bool { + r := bool(C.wickra_vpin_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Vpin) Update(price float64, size float64, isBuy bool, timestamp int64) float64 { @@ -30224,6 +37952,22 @@ func NewVwap() (*Vwap, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Vwap) WarmupPeriod() int { + r := int(C.wickra_vwap_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Vwap) IsReady() bool { + r := bool(C.wickra_vwap_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Vwap) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30299,6 +38043,22 @@ func NewVwapStdDevBands(multiplier float64) (*VwapStdDevBands, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *VwapStdDevBands) WarmupPeriod() int { + r := int(C.wickra_vwap_std_dev_bands_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *VwapStdDevBands) IsReady() bool { + r := bool(C.wickra_vwap_std_dev_bands_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *VwapStdDevBands) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (VwapStdDevBandsOutput, bool) { @@ -30344,6 +38104,22 @@ func NewVwma(period int) (*Vwma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Vwma) WarmupPeriod() int { + r := int(C.wickra_vwma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Vwma) IsReady() bool { + r := bool(C.wickra_vwma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Vwma) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30419,6 +38195,22 @@ func NewVzo(period int) (*Vzo, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Vzo) WarmupPeriod() int { + r := int(C.wickra_vzo_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Vzo) IsReady() bool { + r := bool(C.wickra_vzo_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Vzo) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30494,6 +38286,22 @@ func NewWad() (*Wad, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Wad) WarmupPeriod() int { + r := int(C.wickra_wad_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Wad) IsReady() bool { + r := bool(C.wickra_wad_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Wad) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30569,6 +38377,22 @@ func NewWavePm(length int, smoothing int) (*WavePm, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WavePm) WarmupPeriod() int { + r := int(C.wickra_wave_pm_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WavePm) IsReady() bool { + r := bool(C.wickra_wave_pm_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *WavePm) Update(value float64) float64 { @@ -30624,6 +38448,22 @@ func NewWaveTrend(channelPeriod int, averagePeriod int, signalPeriod int) (*Wave return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WaveTrend) WarmupPeriod() int { + r := int(C.wickra_wave_trend_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WaveTrend) IsReady() bool { + r := bool(C.wickra_wave_trend_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *WaveTrend) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (WaveTrendOutput, bool) { @@ -30669,6 +38509,22 @@ func NewWedge() (*Wedge, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Wedge) WarmupPeriod() int { + r := int(C.wickra_wedge_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Wedge) IsReady() bool { + r := bool(C.wickra_wedge_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Wedge) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30744,6 +38600,22 @@ func NewWeightedClose() (*WeightedClose, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WeightedClose) WarmupPeriod() int { + r := int(C.wickra_weighted_close_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WeightedClose) IsReady() bool { + r := bool(C.wickra_weighted_close_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *WeightedClose) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30819,6 +38691,22 @@ func NewWickRatio() (*WickRatio, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WickRatio) WarmupPeriod() int { + r := int(C.wickra_wick_ratio_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WickRatio) IsReady() bool { + r := bool(C.wickra_wick_ratio_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *WickRatio) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -30894,6 +38782,22 @@ func NewWilliamsFractals() (*WilliamsFractals, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WilliamsFractals) WarmupPeriod() int { + r := int(C.wickra_williams_fractals_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WilliamsFractals) IsReady() bool { + r := bool(C.wickra_williams_fractals_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *WilliamsFractals) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (WilliamsFractalsOutput, bool) { @@ -30939,6 +38843,22 @@ func NewWilliamsR(period int) (*WilliamsR, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WilliamsR) WarmupPeriod() int { + r := int(C.wickra_williams_r_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WilliamsR) IsReady() bool { + r := bool(C.wickra_williams_r_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *WilliamsR) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -31014,6 +38934,22 @@ func NewWinRate(period int) (*WinRate, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WinRate) WarmupPeriod() int { + r := int(C.wickra_win_rate_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WinRate) IsReady() bool { + r := bool(C.wickra_win_rate_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *WinRate) Update(value float64) float64 { @@ -31069,6 +39005,22 @@ func NewWma(period int) (*Wma, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Wma) WarmupPeriod() int { + r := int(C.wickra_wma_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Wma) IsReady() bool { + r := bool(C.wickra_wma_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Wma) Update(value float64) float64 { @@ -31124,6 +39076,22 @@ func NewWoodiePivots() (*WoodiePivots, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *WoodiePivots) WarmupPeriod() int { + r := int(C.wickra_woodie_pivots_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *WoodiePivots) IsReady() bool { + r := bool(C.wickra_woodie_pivots_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *WoodiePivots) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (WoodiePivotsOutput, bool) { @@ -31169,6 +39137,22 @@ func NewYangZhangVolatility(period int, tradingPeriods int) (*YangZhangVolatilit return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *YangZhangVolatility) WarmupPeriod() int { + r := int(C.wickra_yang_zhang_volatility_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *YangZhangVolatility) IsReady() bool { + r := bool(C.wickra_yang_zhang_volatility_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *YangZhangVolatility) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -31244,6 +39228,22 @@ func NewYoyoExit(atrPeriod int, multiplier float64) (*YoyoExit, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *YoyoExit) WarmupPeriod() int { + r := int(C.wickra_yoyo_exit_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *YoyoExit) IsReady() bool { + r := bool(C.wickra_yoyo_exit_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *YoyoExit) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) float64 { @@ -31319,6 +39319,22 @@ func NewZScore(period int) (*ZScore, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ZScore) WarmupPeriod() int { + r := int(C.wickra_z_score_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ZScore) IsReady() bool { + r := bool(C.wickra_z_score_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *ZScore) Update(value float64) float64 { @@ -31374,6 +39390,22 @@ func NewZeroLagMacd(fast int, slow int, signal int) (*ZeroLagMacd, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ZeroLagMacd) WarmupPeriod() int { + r := int(C.wickra_zero_lag_macd_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ZeroLagMacd) IsReady() bool { + r := bool(C.wickra_zero_lag_macd_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ZeroLagMacd) Update(value float64) (ZeroLagMacdOutput, bool) { @@ -31419,6 +39451,22 @@ func NewZigZag(threshold float64) (*ZigZag, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *ZigZag) WarmupPeriod() int { + r := int(C.wickra_zig_zag_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *ZigZag) IsReady() bool { + r := bool(C.wickra_zig_zag_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation. The bool reports whether a value is // available yet (false during warmup). func (ind *ZigZag) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (ZigZagOutput, bool) { @@ -31464,6 +39512,22 @@ func NewZlema(period int) (*Zlema, error) { return obj, nil } +// WarmupPeriod returns the number of updates required before Update +// yields a non-NaN value. +func (ind *Zlema) WarmupPeriod() int { + r := int(C.wickra_zlema_warmup_period(ind.handle)) + runtime.KeepAlive(ind) + return r +} + +// IsReady reports whether the indicator has consumed enough input to +// emit a value. +func (ind *Zlema) IsReady() bool { + r := bool(C.wickra_zlema_is_ready(ind.handle)) + runtime.KeepAlive(ind) + return r +} + // Update feeds one observation and returns the indicator value // (NaN until warmed up). func (ind *Zlema) Update(value float64) float64 { diff --git a/bindings/go/wickra_test.go b/bindings/go/wickra_test.go index 54f13855..a26ec65a 100644 --- a/bindings/go/wickra_test.go +++ b/bindings/go/wickra_test.go @@ -24,6 +24,34 @@ func TestScalarKnownValue(t *testing.T) { } } +func TestWarmupPeriodAndIsReady(t *testing.T) { + s, err := NewSma(3) + if err != nil { + t.Fatalf("NewSma: %v", err) + } + defer s.Close() + + if got := s.WarmupPeriod(); got != 3 { + t.Fatalf("sma(3) WarmupPeriod = %d, want 3", got) + } + if s.IsReady() { + t.Fatal("sma is ready before any update") + } + s.Update(1) + s.Update(2) + if s.IsReady() { + t.Fatal("sma is ready mid-warmup") + } + s.Update(3) + if !s.IsReady() { + t.Fatal("sma is not ready after the warmup period") + } + s.Reset() + if s.IsReady() { + t.Fatal("sma is ready after reset") + } +} + func TestScalarBatchMatchesStreaming(t *testing.T) { input := []float64{1, 2, 3, 4, 5, 6, 7, 8} diff --git a/bindings/java/src/main/java/org/wickra/AbandonedBaby.java b/bindings/java/src/main/java/org/wickra/AbandonedBaby.java index 59e82fad..9870ee51 100644 --- a/bindings/java/src/main/java/org/wickra/AbandonedBaby.java +++ b/bindings/java/src/main/java/org/wickra/AbandonedBaby.java @@ -71,6 +71,26 @@ public final class AbandonedBaby implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ABANDONED_BABY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ABANDONED_BABY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Abcd.java b/bindings/java/src/main/java/org/wickra/Abcd.java index 0a2bcf75..8d4c3039 100644 --- a/bindings/java/src/main/java/org/wickra/Abcd.java +++ b/bindings/java/src/main/java/org/wickra/Abcd.java @@ -71,6 +71,26 @@ public final class Abcd implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ABCD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ABCD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AbsoluteBreadthIndex.java b/bindings/java/src/main/java/org/wickra/AbsoluteBreadthIndex.java index a278db6e..02929b67 100644 --- a/bindings/java/src/main/java/org/wickra/AbsoluteBreadthIndex.java +++ b/bindings/java/src/main/java/org/wickra/AbsoluteBreadthIndex.java @@ -57,6 +57,26 @@ public final class AbsoluteBreadthIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ABSOLUTE_BREADTH_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AccelerationBands.java b/bindings/java/src/main/java/org/wickra/AccelerationBands.java index 27a744d4..8a275ffa 100644 --- a/bindings/java/src/main/java/org/wickra/AccelerationBands.java +++ b/bindings/java/src/main/java/org/wickra/AccelerationBands.java @@ -47,6 +47,26 @@ public final class AccelerationBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ACCELERATION_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ACCELERATION_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AcceleratorOscillator.java b/bindings/java/src/main/java/org/wickra/AcceleratorOscillator.java index e81dbed4..b8f8c049 100644 --- a/bindings/java/src/main/java/org/wickra/AcceleratorOscillator.java +++ b/bindings/java/src/main/java/org/wickra/AcceleratorOscillator.java @@ -80,6 +80,26 @@ public final class AcceleratorOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ACCELERATOR_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdOscillator.java b/bindings/java/src/main/java/org/wickra/AdOscillator.java index 3696903b..e7c76a90 100644 --- a/bindings/java/src/main/java/org/wickra/AdOscillator.java +++ b/bindings/java/src/main/java/org/wickra/AdOscillator.java @@ -71,6 +71,26 @@ public final class AdOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AD_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AD_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdVolumeLine.java b/bindings/java/src/main/java/org/wickra/AdVolumeLine.java index b1e38cbb..a3ee9d6e 100644 --- a/bindings/java/src/main/java/org/wickra/AdVolumeLine.java +++ b/bindings/java/src/main/java/org/wickra/AdVolumeLine.java @@ -57,6 +57,26 @@ public final class AdVolumeLine implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AD_VOLUME_LINE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AD_VOLUME_LINE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdaptiveCci.java b/bindings/java/src/main/java/org/wickra/AdaptiveCci.java index 869677b8..742c0f32 100644 --- a/bindings/java/src/main/java/org/wickra/AdaptiveCci.java +++ b/bindings/java/src/main/java/org/wickra/AdaptiveCci.java @@ -74,6 +74,26 @@ public final class AdaptiveCci implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADAPTIVE_CCI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADAPTIVE_CCI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdaptiveCycle.java b/bindings/java/src/main/java/org/wickra/AdaptiveCycle.java index ca027324..278f990c 100644 --- a/bindings/java/src/main/java/org/wickra/AdaptiveCycle.java +++ b/bindings/java/src/main/java/org/wickra/AdaptiveCycle.java @@ -51,6 +51,26 @@ public final class AdaptiveCycle implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADAPTIVE_CYCLE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADAPTIVE_CYCLE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdaptiveLaguerreFilter.java b/bindings/java/src/main/java/org/wickra/AdaptiveLaguerreFilter.java index 56d30a50..ecbc0be6 100644 --- a/bindings/java/src/main/java/org/wickra/AdaptiveLaguerreFilter.java +++ b/bindings/java/src/main/java/org/wickra/AdaptiveLaguerreFilter.java @@ -54,6 +54,26 @@ public final class AdaptiveLaguerreFilter implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADAPTIVE_LAGUERRE_FILTER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdaptiveRsi.java b/bindings/java/src/main/java/org/wickra/AdaptiveRsi.java index 56642fb3..b5295216 100644 --- a/bindings/java/src/main/java/org/wickra/AdaptiveRsi.java +++ b/bindings/java/src/main/java/org/wickra/AdaptiveRsi.java @@ -54,6 +54,26 @@ public final class AdaptiveRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADAPTIVE_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADAPTIVE_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Adl.java b/bindings/java/src/main/java/org/wickra/Adl.java index 11dcc550..03d4caf8 100644 --- a/bindings/java/src/main/java/org/wickra/Adl.java +++ b/bindings/java/src/main/java/org/wickra/Adl.java @@ -71,6 +71,26 @@ public final class Adl implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdvanceBlock.java b/bindings/java/src/main/java/org/wickra/AdvanceBlock.java index b4d10d87..bb34c76b 100644 --- a/bindings/java/src/main/java/org/wickra/AdvanceBlock.java +++ b/bindings/java/src/main/java/org/wickra/AdvanceBlock.java @@ -71,6 +71,26 @@ public final class AdvanceBlock implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADVANCE_BLOCK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADVANCE_BLOCK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdvanceDecline.java b/bindings/java/src/main/java/org/wickra/AdvanceDecline.java index 55d06086..f1dc639d 100644 --- a/bindings/java/src/main/java/org/wickra/AdvanceDecline.java +++ b/bindings/java/src/main/java/org/wickra/AdvanceDecline.java @@ -57,6 +57,26 @@ public final class AdvanceDecline implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADVANCE_DECLINE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADVANCE_DECLINE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AdvanceDeclineRatio.java b/bindings/java/src/main/java/org/wickra/AdvanceDeclineRatio.java index 66f9a427..d8b535eb 100644 --- a/bindings/java/src/main/java/org/wickra/AdvanceDeclineRatio.java +++ b/bindings/java/src/main/java/org/wickra/AdvanceDeclineRatio.java @@ -57,6 +57,26 @@ public final class AdvanceDeclineRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADVANCE_DECLINE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Adx.java b/bindings/java/src/main/java/org/wickra/Adx.java index f1230e86..3f0c377d 100644 --- a/bindings/java/src/main/java/org/wickra/Adx.java +++ b/bindings/java/src/main/java/org/wickra/Adx.java @@ -47,6 +47,26 @@ public final class Adx implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Adxr.java b/bindings/java/src/main/java/org/wickra/Adxr.java index 5f5fc188..bc025115 100644 --- a/bindings/java/src/main/java/org/wickra/Adxr.java +++ b/bindings/java/src/main/java/org/wickra/Adxr.java @@ -74,6 +74,26 @@ public final class Adxr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ADXR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ADXR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Alligator.java b/bindings/java/src/main/java/org/wickra/Alligator.java index 9d6c774e..43fcf21b 100644 --- a/bindings/java/src/main/java/org/wickra/Alligator.java +++ b/bindings/java/src/main/java/org/wickra/Alligator.java @@ -53,6 +53,26 @@ public final class Alligator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ALLIGATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ALLIGATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Alma.java b/bindings/java/src/main/java/org/wickra/Alma.java index 81335416..fdbf40f9 100644 --- a/bindings/java/src/main/java/org/wickra/Alma.java +++ b/bindings/java/src/main/java/org/wickra/Alma.java @@ -54,6 +54,26 @@ public final class Alma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ALMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ALMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Alpha.java b/bindings/java/src/main/java/org/wickra/Alpha.java index d825df29..193f3a1e 100644 --- a/bindings/java/src/main/java/org/wickra/Alpha.java +++ b/bindings/java/src/main/java/org/wickra/Alpha.java @@ -58,6 +58,26 @@ public final class Alpha implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ALPHA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ALPHA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AmihudIlliquidity.java b/bindings/java/src/main/java/org/wickra/AmihudIlliquidity.java index 9e2c12f0..9600a996 100644 --- a/bindings/java/src/main/java/org/wickra/AmihudIlliquidity.java +++ b/bindings/java/src/main/java/org/wickra/AmihudIlliquidity.java @@ -39,6 +39,26 @@ public final class AmihudIlliquidity implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AMIHUD_ILLIQUIDITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AnchoredRsi.java b/bindings/java/src/main/java/org/wickra/AnchoredRsi.java index ba9b2cec..5a72b6a6 100644 --- a/bindings/java/src/main/java/org/wickra/AnchoredRsi.java +++ b/bindings/java/src/main/java/org/wickra/AnchoredRsi.java @@ -51,6 +51,26 @@ public final class AnchoredRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ANCHORED_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ANCHORED_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AnchoredVwap.java b/bindings/java/src/main/java/org/wickra/AnchoredVwap.java index dd6dd3f3..acd95045 100644 --- a/bindings/java/src/main/java/org/wickra/AnchoredVwap.java +++ b/bindings/java/src/main/java/org/wickra/AnchoredVwap.java @@ -71,6 +71,26 @@ public final class AnchoredVwap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ANCHORED_VWAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ANCHORED_VWAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AndrewsPitchfork.java b/bindings/java/src/main/java/org/wickra/AndrewsPitchfork.java index c03d77ec..3c16db25 100644 --- a/bindings/java/src/main/java/org/wickra/AndrewsPitchfork.java +++ b/bindings/java/src/main/java/org/wickra/AndrewsPitchfork.java @@ -47,6 +47,26 @@ public final class AndrewsPitchfork implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ANDREWS_PITCHFORK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ANDREWS_PITCHFORK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Apo.java b/bindings/java/src/main/java/org/wickra/Apo.java index fc15dd0f..fc2a4e8b 100644 --- a/bindings/java/src/main/java/org/wickra/Apo.java +++ b/bindings/java/src/main/java/org/wickra/Apo.java @@ -57,6 +57,26 @@ public final class Apo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_APO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_APO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Aroon.java b/bindings/java/src/main/java/org/wickra/Aroon.java index aaa7be1f..9c6feffa 100644 --- a/bindings/java/src/main/java/org/wickra/Aroon.java +++ b/bindings/java/src/main/java/org/wickra/Aroon.java @@ -46,6 +46,26 @@ public final class Aroon implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AROON_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AROON_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AroonOscillator.java b/bindings/java/src/main/java/org/wickra/AroonOscillator.java index 202a3055..e480ef9a 100644 --- a/bindings/java/src/main/java/org/wickra/AroonOscillator.java +++ b/bindings/java/src/main/java/org/wickra/AroonOscillator.java @@ -74,6 +74,26 @@ public final class AroonOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AROON_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AROON_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Atr.java b/bindings/java/src/main/java/org/wickra/Atr.java index 770b4e3d..25910ad5 100644 --- a/bindings/java/src/main/java/org/wickra/Atr.java +++ b/bindings/java/src/main/java/org/wickra/Atr.java @@ -74,6 +74,26 @@ public final class Atr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ATR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ATR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AtrBands.java b/bindings/java/src/main/java/org/wickra/AtrBands.java index b9a9b28a..2416f878 100644 --- a/bindings/java/src/main/java/org/wickra/AtrBands.java +++ b/bindings/java/src/main/java/org/wickra/AtrBands.java @@ -47,6 +47,26 @@ public final class AtrBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ATR_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ATR_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AtrRatchet.java b/bindings/java/src/main/java/org/wickra/AtrRatchet.java index c86beb08..385845d8 100644 --- a/bindings/java/src/main/java/org/wickra/AtrRatchet.java +++ b/bindings/java/src/main/java/org/wickra/AtrRatchet.java @@ -46,6 +46,26 @@ public final class AtrRatchet implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ATR_RATCHET_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ATR_RATCHET_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AtrTrailingStop.java b/bindings/java/src/main/java/org/wickra/AtrTrailingStop.java index 9edf6628..8a02a6dd 100644 --- a/bindings/java/src/main/java/org/wickra/AtrTrailingStop.java +++ b/bindings/java/src/main/java/org/wickra/AtrTrailingStop.java @@ -74,6 +74,26 @@ public final class AtrTrailingStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ATR_TRAILING_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ATR_TRAILING_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AutoFib.java b/bindings/java/src/main/java/org/wickra/AutoFib.java index b1292d14..d16d1a60 100644 --- a/bindings/java/src/main/java/org/wickra/AutoFib.java +++ b/bindings/java/src/main/java/org/wickra/AutoFib.java @@ -48,6 +48,26 @@ public final class AutoFib implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AUTO_FIB_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AUTO_FIB_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Autocorrelation.java b/bindings/java/src/main/java/org/wickra/Autocorrelation.java index 2677acfa..86972592 100644 --- a/bindings/java/src/main/java/org/wickra/Autocorrelation.java +++ b/bindings/java/src/main/java/org/wickra/Autocorrelation.java @@ -57,6 +57,26 @@ public final class Autocorrelation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AUTOCORRELATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AUTOCORRELATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AutocorrelationPeriodogram.java b/bindings/java/src/main/java/org/wickra/AutocorrelationPeriodogram.java index 4a6cbe6b..78ecada2 100644 --- a/bindings/java/src/main/java/org/wickra/AutocorrelationPeriodogram.java +++ b/bindings/java/src/main/java/org/wickra/AutocorrelationPeriodogram.java @@ -57,6 +57,26 @@ public final class AutocorrelationPeriodogram implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AUTOCORRELATION_PERIODOGRAM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AverageDailyRange.java b/bindings/java/src/main/java/org/wickra/AverageDailyRange.java index 19a87174..63d4086a 100644 --- a/bindings/java/src/main/java/org/wickra/AverageDailyRange.java +++ b/bindings/java/src/main/java/org/wickra/AverageDailyRange.java @@ -74,6 +74,26 @@ public final class AverageDailyRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AVERAGE_DAILY_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AverageDrawdown.java b/bindings/java/src/main/java/org/wickra/AverageDrawdown.java index a42111a7..3363c0f4 100644 --- a/bindings/java/src/main/java/org/wickra/AverageDrawdown.java +++ b/bindings/java/src/main/java/org/wickra/AverageDrawdown.java @@ -54,6 +54,26 @@ public final class AverageDrawdown implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AVERAGE_DRAWDOWN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AvgPrice.java b/bindings/java/src/main/java/org/wickra/AvgPrice.java index 323737df..ebe3b40a 100644 --- a/bindings/java/src/main/java/org/wickra/AvgPrice.java +++ b/bindings/java/src/main/java/org/wickra/AvgPrice.java @@ -71,6 +71,26 @@ public final class AvgPrice implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AVG_PRICE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AVG_PRICE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AwesomeOscillator.java b/bindings/java/src/main/java/org/wickra/AwesomeOscillator.java index a072d34d..bc806224 100644 --- a/bindings/java/src/main/java/org/wickra/AwesomeOscillator.java +++ b/bindings/java/src/main/java/org/wickra/AwesomeOscillator.java @@ -77,6 +77,26 @@ public final class AwesomeOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AWESOME_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AWESOME_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/AwesomeOscillatorHistogram.java b/bindings/java/src/main/java/org/wickra/AwesomeOscillatorHistogram.java index cf811c27..f96d7e86 100644 --- a/bindings/java/src/main/java/org/wickra/AwesomeOscillatorHistogram.java +++ b/bindings/java/src/main/java/org/wickra/AwesomeOscillatorHistogram.java @@ -80,6 +80,26 @@ public final class AwesomeOscillatorHistogram implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BalanceOfPower.java b/bindings/java/src/main/java/org/wickra/BalanceOfPower.java index 580bf41f..f7719f6b 100644 --- a/bindings/java/src/main/java/org/wickra/BalanceOfPower.java +++ b/bindings/java/src/main/java/org/wickra/BalanceOfPower.java @@ -71,6 +71,26 @@ public final class BalanceOfPower implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BALANCE_OF_POWER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BALANCE_OF_POWER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BandpassFilter.java b/bindings/java/src/main/java/org/wickra/BandpassFilter.java index 8cc9ed79..a5ed7267 100644 --- a/bindings/java/src/main/java/org/wickra/BandpassFilter.java +++ b/bindings/java/src/main/java/org/wickra/BandpassFilter.java @@ -54,6 +54,26 @@ public final class BandpassFilter implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BANDPASS_FILTER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BANDPASS_FILTER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Bat.java b/bindings/java/src/main/java/org/wickra/Bat.java index a07687c0..72e31e6d 100644 --- a/bindings/java/src/main/java/org/wickra/Bat.java +++ b/bindings/java/src/main/java/org/wickra/Bat.java @@ -71,6 +71,26 @@ public final class Bat implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BAT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BAT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BeltHold.java b/bindings/java/src/main/java/org/wickra/BeltHold.java index 861f660b..40a9d419 100644 --- a/bindings/java/src/main/java/org/wickra/BeltHold.java +++ b/bindings/java/src/main/java/org/wickra/BeltHold.java @@ -71,6 +71,26 @@ public final class BeltHold implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BELT_HOLD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BELT_HOLD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Beta.java b/bindings/java/src/main/java/org/wickra/Beta.java index 4c8e94d5..dc6f29e3 100644 --- a/bindings/java/src/main/java/org/wickra/Beta.java +++ b/bindings/java/src/main/java/org/wickra/Beta.java @@ -58,6 +58,26 @@ public final class Beta implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BETA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BETA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BetaNeutralSpread.java b/bindings/java/src/main/java/org/wickra/BetaNeutralSpread.java index bb55f7e3..a55e57a5 100644 --- a/bindings/java/src/main/java/org/wickra/BetaNeutralSpread.java +++ b/bindings/java/src/main/java/org/wickra/BetaNeutralSpread.java @@ -58,6 +58,26 @@ public final class BetaNeutralSpread implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BETA_NEUTRAL_SPREAD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BetterVolume.java b/bindings/java/src/main/java/org/wickra/BetterVolume.java index f4207209..650cd147 100644 --- a/bindings/java/src/main/java/org/wickra/BetterVolume.java +++ b/bindings/java/src/main/java/org/wickra/BetterVolume.java @@ -74,6 +74,26 @@ public final class BetterVolume implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BETTER_VOLUME_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BETTER_VOLUME_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BipowerVariation.java b/bindings/java/src/main/java/org/wickra/BipowerVariation.java index d20d9b7d..d2ea3c16 100644 --- a/bindings/java/src/main/java/org/wickra/BipowerVariation.java +++ b/bindings/java/src/main/java/org/wickra/BipowerVariation.java @@ -54,6 +54,26 @@ public final class BipowerVariation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BIPOWER_VARIATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BIPOWER_VARIATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BodySizePct.java b/bindings/java/src/main/java/org/wickra/BodySizePct.java index 7e523686..74bd7a1d 100644 --- a/bindings/java/src/main/java/org/wickra/BodySizePct.java +++ b/bindings/java/src/main/java/org/wickra/BodySizePct.java @@ -71,6 +71,26 @@ public final class BodySizePct implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BODY_SIZE_PCT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BODY_SIZE_PCT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BollingerBands.java b/bindings/java/src/main/java/org/wickra/BollingerBands.java index 4513d129..d6b3954b 100644 --- a/bindings/java/src/main/java/org/wickra/BollingerBands.java +++ b/bindings/java/src/main/java/org/wickra/BollingerBands.java @@ -48,6 +48,26 @@ public final class BollingerBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BOLLINGER_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BOLLINGER_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BollingerBandwidth.java b/bindings/java/src/main/java/org/wickra/BollingerBandwidth.java index 8f1ab6c2..20421c8d 100644 --- a/bindings/java/src/main/java/org/wickra/BollingerBandwidth.java +++ b/bindings/java/src/main/java/org/wickra/BollingerBandwidth.java @@ -54,6 +54,26 @@ public final class BollingerBandwidth implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BOLLINGER_BANDWIDTH_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BomarBands.java b/bindings/java/src/main/java/org/wickra/BomarBands.java index 8aa6bb6a..395ec81c 100644 --- a/bindings/java/src/main/java/org/wickra/BomarBands.java +++ b/bindings/java/src/main/java/org/wickra/BomarBands.java @@ -47,6 +47,26 @@ public final class BomarBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BOMAR_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BOMAR_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BreadthThrust.java b/bindings/java/src/main/java/org/wickra/BreadthThrust.java index b11c6738..88c648cd 100644 --- a/bindings/java/src/main/java/org/wickra/BreadthThrust.java +++ b/bindings/java/src/main/java/org/wickra/BreadthThrust.java @@ -60,6 +60,26 @@ public final class BreadthThrust implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BREADTH_THRUST_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BREADTH_THRUST_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Breakaway.java b/bindings/java/src/main/java/org/wickra/Breakaway.java index 938c1a8b..704b7818 100644 --- a/bindings/java/src/main/java/org/wickra/Breakaway.java +++ b/bindings/java/src/main/java/org/wickra/Breakaway.java @@ -71,6 +71,26 @@ public final class Breakaway implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BREAKAWAY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BREAKAWAY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BullishPercentIndex.java b/bindings/java/src/main/java/org/wickra/BullishPercentIndex.java index 24de5dc5..724b5ddb 100644 --- a/bindings/java/src/main/java/org/wickra/BullishPercentIndex.java +++ b/bindings/java/src/main/java/org/wickra/BullishPercentIndex.java @@ -57,6 +57,26 @@ public final class BullishPercentIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BULLISH_PERCENT_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/BurkeRatio.java b/bindings/java/src/main/java/org/wickra/BurkeRatio.java index c1a74ad0..51d2d76f 100644 --- a/bindings/java/src/main/java/org/wickra/BurkeRatio.java +++ b/bindings/java/src/main/java/org/wickra/BurkeRatio.java @@ -54,6 +54,26 @@ public final class BurkeRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BURKE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BURKE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Butterfly.java b/bindings/java/src/main/java/org/wickra/Butterfly.java index b04063ed..91b011d9 100644 --- a/bindings/java/src/main/java/org/wickra/Butterfly.java +++ b/bindings/java/src/main/java/org/wickra/Butterfly.java @@ -71,6 +71,26 @@ public final class Butterfly implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_BUTTERFLY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_BUTTERFLY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CalendarSpread.java b/bindings/java/src/main/java/org/wickra/CalendarSpread.java index 57f21023..b5481e95 100644 --- a/bindings/java/src/main/java/org/wickra/CalendarSpread.java +++ b/bindings/java/src/main/java/org/wickra/CalendarSpread.java @@ -36,6 +36,26 @@ public final class CalendarSpread implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CALENDAR_SPREAD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CALENDAR_SPREAD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CalmarRatio.java b/bindings/java/src/main/java/org/wickra/CalmarRatio.java index 76f7d548..d5164cc9 100644 --- a/bindings/java/src/main/java/org/wickra/CalmarRatio.java +++ b/bindings/java/src/main/java/org/wickra/CalmarRatio.java @@ -54,6 +54,26 @@ public final class CalmarRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CALMAR_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CALMAR_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Camarilla.java b/bindings/java/src/main/java/org/wickra/Camarilla.java index 106adb3f..fa4f25a0 100644 --- a/bindings/java/src/main/java/org/wickra/Camarilla.java +++ b/bindings/java/src/main/java/org/wickra/Camarilla.java @@ -50,6 +50,26 @@ public final class Camarilla implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CAMARILLA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CAMARILLA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CandleVolume.java b/bindings/java/src/main/java/org/wickra/CandleVolume.java index c344a5bc..5b7bd457 100644 --- a/bindings/java/src/main/java/org/wickra/CandleVolume.java +++ b/bindings/java/src/main/java/org/wickra/CandleVolume.java @@ -46,6 +46,26 @@ public final class CandleVolume implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CANDLE_VOLUME_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CANDLE_VOLUME_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Cci.java b/bindings/java/src/main/java/org/wickra/Cci.java index bf46cffa..5973b20d 100644 --- a/bindings/java/src/main/java/org/wickra/Cci.java +++ b/bindings/java/src/main/java/org/wickra/Cci.java @@ -74,6 +74,26 @@ public final class Cci implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CCI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CCI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CenterOfGravity.java b/bindings/java/src/main/java/org/wickra/CenterOfGravity.java index efe1e7b2..3b1e6ca0 100644 --- a/bindings/java/src/main/java/org/wickra/CenterOfGravity.java +++ b/bindings/java/src/main/java/org/wickra/CenterOfGravity.java @@ -54,6 +54,26 @@ public final class CenterOfGravity implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CENTER_OF_GRAVITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CENTER_OF_GRAVITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CentralPivotRange.java b/bindings/java/src/main/java/org/wickra/CentralPivotRange.java index 39c1469e..6f88ffb2 100644 --- a/bindings/java/src/main/java/org/wickra/CentralPivotRange.java +++ b/bindings/java/src/main/java/org/wickra/CentralPivotRange.java @@ -44,6 +44,26 @@ public final class CentralPivotRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CENTRAL_PIVOT_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Cfo.java b/bindings/java/src/main/java/org/wickra/Cfo.java index 3b923903..8b4cab78 100644 --- a/bindings/java/src/main/java/org/wickra/Cfo.java +++ b/bindings/java/src/main/java/org/wickra/Cfo.java @@ -54,6 +54,26 @@ public final class Cfo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CFO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CFO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ChaikinMoneyFlow.java b/bindings/java/src/main/java/org/wickra/ChaikinMoneyFlow.java index fb70670c..6eb2a5f9 100644 --- a/bindings/java/src/main/java/org/wickra/ChaikinMoneyFlow.java +++ b/bindings/java/src/main/java/org/wickra/ChaikinMoneyFlow.java @@ -74,6 +74,26 @@ public final class ChaikinMoneyFlow implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CHAIKIN_MONEY_FLOW_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ChaikinOscillator.java b/bindings/java/src/main/java/org/wickra/ChaikinOscillator.java index 596a5efb..2d2a3e94 100644 --- a/bindings/java/src/main/java/org/wickra/ChaikinOscillator.java +++ b/bindings/java/src/main/java/org/wickra/ChaikinOscillator.java @@ -77,6 +77,26 @@ public final class ChaikinOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CHAIKIN_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ChaikinVolatility.java b/bindings/java/src/main/java/org/wickra/ChaikinVolatility.java index 70969d78..9c633ea3 100644 --- a/bindings/java/src/main/java/org/wickra/ChaikinVolatility.java +++ b/bindings/java/src/main/java/org/wickra/ChaikinVolatility.java @@ -77,6 +77,26 @@ public final class ChaikinVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CHAIKIN_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CHAIKIN_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ChandeKrollStop.java b/bindings/java/src/main/java/org/wickra/ChandeKrollStop.java index 0237bc05..819a28ba 100644 --- a/bindings/java/src/main/java/org/wickra/ChandeKrollStop.java +++ b/bindings/java/src/main/java/org/wickra/ChandeKrollStop.java @@ -49,6 +49,26 @@ public final class ChandeKrollStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CHANDE_KROLL_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CHANDE_KROLL_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ChandelierExit.java b/bindings/java/src/main/java/org/wickra/ChandelierExit.java index c928986f..f38a3354 100644 --- a/bindings/java/src/main/java/org/wickra/ChandelierExit.java +++ b/bindings/java/src/main/java/org/wickra/ChandelierExit.java @@ -46,6 +46,26 @@ public final class ChandelierExit implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CHANDELIER_EXIT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CHANDELIER_EXIT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ChoppinessIndex.java b/bindings/java/src/main/java/org/wickra/ChoppinessIndex.java index 48febebb..84fb44fa 100644 --- a/bindings/java/src/main/java/org/wickra/ChoppinessIndex.java +++ b/bindings/java/src/main/java/org/wickra/ChoppinessIndex.java @@ -74,6 +74,26 @@ public final class ChoppinessIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CHOPPINESS_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CHOPPINESS_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ClassicPivots.java b/bindings/java/src/main/java/org/wickra/ClassicPivots.java index 2343dad1..e2eeb99d 100644 --- a/bindings/java/src/main/java/org/wickra/ClassicPivots.java +++ b/bindings/java/src/main/java/org/wickra/ClassicPivots.java @@ -48,6 +48,26 @@ public final class ClassicPivots implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CLASSIC_PIVOTS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CLASSIC_PIVOTS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CloseVsOpen.java b/bindings/java/src/main/java/org/wickra/CloseVsOpen.java index 1fd833bb..04c9ca82 100644 --- a/bindings/java/src/main/java/org/wickra/CloseVsOpen.java +++ b/bindings/java/src/main/java/org/wickra/CloseVsOpen.java @@ -71,6 +71,26 @@ public final class CloseVsOpen implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CLOSE_VS_OPEN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CLOSE_VS_OPEN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ClosingMarubozu.java b/bindings/java/src/main/java/org/wickra/ClosingMarubozu.java index c34fdde4..65a33acc 100644 --- a/bindings/java/src/main/java/org/wickra/ClosingMarubozu.java +++ b/bindings/java/src/main/java/org/wickra/ClosingMarubozu.java @@ -71,6 +71,26 @@ public final class ClosingMarubozu implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CLOSING_MARUBOZU_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CLOSING_MARUBOZU_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Cmo.java b/bindings/java/src/main/java/org/wickra/Cmo.java index 030f3bbc..8606d38c 100644 --- a/bindings/java/src/main/java/org/wickra/Cmo.java +++ b/bindings/java/src/main/java/org/wickra/Cmo.java @@ -54,6 +54,26 @@ public final class Cmo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CMO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CMO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CoefficientOfVariation.java b/bindings/java/src/main/java/org/wickra/CoefficientOfVariation.java index 9980d8a0..6691bd02 100644 --- a/bindings/java/src/main/java/org/wickra/CoefficientOfVariation.java +++ b/bindings/java/src/main/java/org/wickra/CoefficientOfVariation.java @@ -54,6 +54,26 @@ public final class CoefficientOfVariation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_COEFFICIENT_OF_VARIATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Cointegration.java b/bindings/java/src/main/java/org/wickra/Cointegration.java index 49045cd2..eda1aa9a 100644 --- a/bindings/java/src/main/java/org/wickra/Cointegration.java +++ b/bindings/java/src/main/java/org/wickra/Cointegration.java @@ -50,6 +50,26 @@ public final class Cointegration implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_COINTEGRATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_COINTEGRATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CommonSenseRatio.java b/bindings/java/src/main/java/org/wickra/CommonSenseRatio.java index f03003cb..09b95d35 100644 --- a/bindings/java/src/main/java/org/wickra/CommonSenseRatio.java +++ b/bindings/java/src/main/java/org/wickra/CommonSenseRatio.java @@ -54,6 +54,26 @@ public final class CommonSenseRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_COMMON_SENSE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_COMMON_SENSE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CompositeProfile.java b/bindings/java/src/main/java/org/wickra/CompositeProfile.java index d27b4e10..65cff4b3 100644 --- a/bindings/java/src/main/java/org/wickra/CompositeProfile.java +++ b/bindings/java/src/main/java/org/wickra/CompositeProfile.java @@ -50,6 +50,26 @@ public final class CompositeProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_COMPOSITE_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_COMPOSITE_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ConcealingBabySwallow.java b/bindings/java/src/main/java/org/wickra/ConcealingBabySwallow.java index 957828a7..2943bda4 100644 --- a/bindings/java/src/main/java/org/wickra/ConcealingBabySwallow.java +++ b/bindings/java/src/main/java/org/wickra/ConcealingBabySwallow.java @@ -71,6 +71,26 @@ public final class ConcealingBabySwallow implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CONCEALING_BABY_SWALLOW_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ConditionalValueAtRisk.java b/bindings/java/src/main/java/org/wickra/ConditionalValueAtRisk.java index 96859adc..74940c0f 100644 --- a/bindings/java/src/main/java/org/wickra/ConditionalValueAtRisk.java +++ b/bindings/java/src/main/java/org/wickra/ConditionalValueAtRisk.java @@ -54,6 +54,26 @@ public final class ConditionalValueAtRisk implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CONDITIONAL_VALUE_AT_RISK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CONDITIONAL_VALUE_AT_RISK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ConnorsRsi.java b/bindings/java/src/main/java/org/wickra/ConnorsRsi.java index c4f590f0..4b5e072c 100644 --- a/bindings/java/src/main/java/org/wickra/ConnorsRsi.java +++ b/bindings/java/src/main/java/org/wickra/ConnorsRsi.java @@ -60,6 +60,26 @@ public final class ConnorsRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CONNORS_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CONNORS_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Coppock.java b/bindings/java/src/main/java/org/wickra/Coppock.java index 1ae6f29d..a0307b95 100644 --- a/bindings/java/src/main/java/org/wickra/Coppock.java +++ b/bindings/java/src/main/java/org/wickra/Coppock.java @@ -60,6 +60,26 @@ public final class Coppock implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_COPPOCK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_COPPOCK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CorrelationTrendIndicator.java b/bindings/java/src/main/java/org/wickra/CorrelationTrendIndicator.java index 33aabf4f..774d4d7f 100644 --- a/bindings/java/src/main/java/org/wickra/CorrelationTrendIndicator.java +++ b/bindings/java/src/main/java/org/wickra/CorrelationTrendIndicator.java @@ -54,6 +54,26 @@ public final class CorrelationTrendIndicator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CORRELATION_TREND_INDICATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CORRELATION_TREND_INDICATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Counterattack.java b/bindings/java/src/main/java/org/wickra/Counterattack.java index 12e2ccee..02ab4ab6 100644 --- a/bindings/java/src/main/java/org/wickra/Counterattack.java +++ b/bindings/java/src/main/java/org/wickra/Counterattack.java @@ -71,6 +71,26 @@ public final class Counterattack implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_COUNTERATTACK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_COUNTERATTACK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Crab.java b/bindings/java/src/main/java/org/wickra/Crab.java index 3cfc1a69..ed4d8e1a 100644 --- a/bindings/java/src/main/java/org/wickra/Crab.java +++ b/bindings/java/src/main/java/org/wickra/Crab.java @@ -71,6 +71,26 @@ public final class Crab implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CRAB_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CRAB_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CumulativeVolumeDelta.java b/bindings/java/src/main/java/org/wickra/CumulativeVolumeDelta.java index 8473ebfe..ab2a5aac 100644 --- a/bindings/java/src/main/java/org/wickra/CumulativeVolumeDelta.java +++ b/bindings/java/src/main/java/org/wickra/CumulativeVolumeDelta.java @@ -36,6 +36,26 @@ public final class CumulativeVolumeDelta implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CUMULATIVE_VOLUME_DELTA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CUMULATIVE_VOLUME_DELTA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CumulativeVolumeIndex.java b/bindings/java/src/main/java/org/wickra/CumulativeVolumeIndex.java index 9dabe396..31d896f1 100644 --- a/bindings/java/src/main/java/org/wickra/CumulativeVolumeIndex.java +++ b/bindings/java/src/main/java/org/wickra/CumulativeVolumeIndex.java @@ -57,6 +57,26 @@ public final class CumulativeVolumeIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CUMULATIVE_VOLUME_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CUMULATIVE_VOLUME_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CupAndHandle.java b/bindings/java/src/main/java/org/wickra/CupAndHandle.java index 20411441..826289a0 100644 --- a/bindings/java/src/main/java/org/wickra/CupAndHandle.java +++ b/bindings/java/src/main/java/org/wickra/CupAndHandle.java @@ -71,6 +71,26 @@ public final class CupAndHandle implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CUP_AND_HANDLE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CUP_AND_HANDLE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/CyberneticCycle.java b/bindings/java/src/main/java/org/wickra/CyberneticCycle.java index 196de20f..38faa671 100644 --- a/bindings/java/src/main/java/org/wickra/CyberneticCycle.java +++ b/bindings/java/src/main/java/org/wickra/CyberneticCycle.java @@ -54,6 +54,26 @@ public final class CyberneticCycle implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CYBERNETIC_CYCLE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CYBERNETIC_CYCLE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Cypher.java b/bindings/java/src/main/java/org/wickra/Cypher.java index ee0f4fc5..49963479 100644 --- a/bindings/java/src/main/java/org/wickra/Cypher.java +++ b/bindings/java/src/main/java/org/wickra/Cypher.java @@ -71,6 +71,26 @@ public final class Cypher implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_CYPHER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_CYPHER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DayOfWeekProfile.java b/bindings/java/src/main/java/org/wickra/DayOfWeekProfile.java index 333eb8d4..b0662e60 100644 --- a/bindings/java/src/main/java/org/wickra/DayOfWeekProfile.java +++ b/bindings/java/src/main/java/org/wickra/DayOfWeekProfile.java @@ -47,6 +47,26 @@ public final class DayOfWeekProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DAY_OF_WEEK_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DAY_OF_WEEK_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Decycler.java b/bindings/java/src/main/java/org/wickra/Decycler.java index 9908a8cc..ace326d4 100644 --- a/bindings/java/src/main/java/org/wickra/Decycler.java +++ b/bindings/java/src/main/java/org/wickra/Decycler.java @@ -54,6 +54,26 @@ public final class Decycler implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DECYCLER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DECYCLER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DecyclerOscillator.java b/bindings/java/src/main/java/org/wickra/DecyclerOscillator.java index 6e70e16a..024b7c88 100644 --- a/bindings/java/src/main/java/org/wickra/DecyclerOscillator.java +++ b/bindings/java/src/main/java/org/wickra/DecyclerOscillator.java @@ -57,6 +57,26 @@ public final class DecyclerOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DECYCLER_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DECYCLER_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Dema.java b/bindings/java/src/main/java/org/wickra/Dema.java index 8867e810..92b2ebc4 100644 --- a/bindings/java/src/main/java/org/wickra/Dema.java +++ b/bindings/java/src/main/java/org/wickra/Dema.java @@ -54,6 +54,26 @@ public final class Dema implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DEMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DEMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DemandIndex.java b/bindings/java/src/main/java/org/wickra/DemandIndex.java index 47e22a7c..7e7f8629 100644 --- a/bindings/java/src/main/java/org/wickra/DemandIndex.java +++ b/bindings/java/src/main/java/org/wickra/DemandIndex.java @@ -74,6 +74,26 @@ public final class DemandIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DEMAND_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DEMAND_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DemarkPivots.java b/bindings/java/src/main/java/org/wickra/DemarkPivots.java index 57c67ce5..20e42457 100644 --- a/bindings/java/src/main/java/org/wickra/DemarkPivots.java +++ b/bindings/java/src/main/java/org/wickra/DemarkPivots.java @@ -44,6 +44,26 @@ public final class DemarkPivots implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DEMARK_PIVOTS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DEMARK_PIVOTS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DepthSlope.java b/bindings/java/src/main/java/org/wickra/DepthSlope.java index 02965792..7e8f5d5e 100644 --- a/bindings/java/src/main/java/org/wickra/DepthSlope.java +++ b/bindings/java/src/main/java/org/wickra/DepthSlope.java @@ -46,6 +46,26 @@ public final class DepthSlope implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DEPTH_SLOPE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DEPTH_SLOPE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DerivativeOscillator.java b/bindings/java/src/main/java/org/wickra/DerivativeOscillator.java index bfec4e02..c2057811 100644 --- a/bindings/java/src/main/java/org/wickra/DerivativeOscillator.java +++ b/bindings/java/src/main/java/org/wickra/DerivativeOscillator.java @@ -63,6 +63,26 @@ public final class DerivativeOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DERIVATIVE_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DERIVATIVE_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DetrendedStdDev.java b/bindings/java/src/main/java/org/wickra/DetrendedStdDev.java index b9b31e9a..e517d539 100644 --- a/bindings/java/src/main/java/org/wickra/DetrendedStdDev.java +++ b/bindings/java/src/main/java/org/wickra/DetrendedStdDev.java @@ -54,6 +54,26 @@ public final class DetrendedStdDev implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DETRENDED_STD_DEV_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DETRENDED_STD_DEV_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DisparityIndex.java b/bindings/java/src/main/java/org/wickra/DisparityIndex.java index ddfdc8e4..64ece9d7 100644 --- a/bindings/java/src/main/java/org/wickra/DisparityIndex.java +++ b/bindings/java/src/main/java/org/wickra/DisparityIndex.java @@ -54,6 +54,26 @@ public final class DisparityIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DISPARITY_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DISPARITY_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DistanceSsd.java b/bindings/java/src/main/java/org/wickra/DistanceSsd.java index 207c25a3..73e789d3 100644 --- a/bindings/java/src/main/java/org/wickra/DistanceSsd.java +++ b/bindings/java/src/main/java/org/wickra/DistanceSsd.java @@ -58,6 +58,26 @@ public final class DistanceSsd implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DISTANCE_SSD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DISTANCE_SSD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Doji.java b/bindings/java/src/main/java/org/wickra/Doji.java index 2d687de6..a9360cdc 100644 --- a/bindings/java/src/main/java/org/wickra/Doji.java +++ b/bindings/java/src/main/java/org/wickra/Doji.java @@ -71,6 +71,26 @@ public final class Doji implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DOJI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DOJI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DojiStar.java b/bindings/java/src/main/java/org/wickra/DojiStar.java index 33640e5e..666e322b 100644 --- a/bindings/java/src/main/java/org/wickra/DojiStar.java +++ b/bindings/java/src/main/java/org/wickra/DojiStar.java @@ -71,6 +71,26 @@ public final class DojiStar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DOJI_STAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DOJI_STAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Donchian.java b/bindings/java/src/main/java/org/wickra/Donchian.java index a5b9e6d7..1507be8f 100644 --- a/bindings/java/src/main/java/org/wickra/Donchian.java +++ b/bindings/java/src/main/java/org/wickra/Donchian.java @@ -47,6 +47,26 @@ public final class Donchian implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DONCHIAN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DONCHIAN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DonchianStop.java b/bindings/java/src/main/java/org/wickra/DonchianStop.java index 96024299..dc0e5a9a 100644 --- a/bindings/java/src/main/java/org/wickra/DonchianStop.java +++ b/bindings/java/src/main/java/org/wickra/DonchianStop.java @@ -46,6 +46,26 @@ public final class DonchianStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DONCHIAN_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DONCHIAN_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DoubleBollinger.java b/bindings/java/src/main/java/org/wickra/DoubleBollinger.java index 9df63317..22c19834 100644 --- a/bindings/java/src/main/java/org/wickra/DoubleBollinger.java +++ b/bindings/java/src/main/java/org/wickra/DoubleBollinger.java @@ -49,6 +49,26 @@ public final class DoubleBollinger implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DOUBLE_BOLLINGER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DOUBLE_BOLLINGER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DoubleTopBottom.java b/bindings/java/src/main/java/org/wickra/DoubleTopBottom.java index 502956ad..f12ff1d6 100644 --- a/bindings/java/src/main/java/org/wickra/DoubleTopBottom.java +++ b/bindings/java/src/main/java/org/wickra/DoubleTopBottom.java @@ -71,6 +71,26 @@ public final class DoubleTopBottom implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DOUBLE_TOP_BOTTOM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DOUBLE_TOP_BOTTOM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DownsideGapThreeMethods.java b/bindings/java/src/main/java/org/wickra/DownsideGapThreeMethods.java index 052bdc85..e05f6465 100644 --- a/bindings/java/src/main/java/org/wickra/DownsideGapThreeMethods.java +++ b/bindings/java/src/main/java/org/wickra/DownsideGapThreeMethods.java @@ -71,6 +71,26 @@ public final class DownsideGapThreeMethods implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DOWNSIDE_GAP_THREE_METHODS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DOWNSIDE_GAP_THREE_METHODS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Dpo.java b/bindings/java/src/main/java/org/wickra/Dpo.java index eab64c5d..c392c609 100644 --- a/bindings/java/src/main/java/org/wickra/Dpo.java +++ b/bindings/java/src/main/java/org/wickra/Dpo.java @@ -54,6 +54,26 @@ public final class Dpo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DPO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DPO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DragonflyDoji.java b/bindings/java/src/main/java/org/wickra/DragonflyDoji.java index 9dfbaff4..58de7694 100644 --- a/bindings/java/src/main/java/org/wickra/DragonflyDoji.java +++ b/bindings/java/src/main/java/org/wickra/DragonflyDoji.java @@ -71,6 +71,26 @@ public final class DragonflyDoji implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DRAGONFLY_DOJI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DRAGONFLY_DOJI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DrawdownDuration.java b/bindings/java/src/main/java/org/wickra/DrawdownDuration.java index 655c0e7e..b6c7f086 100644 --- a/bindings/java/src/main/java/org/wickra/DrawdownDuration.java +++ b/bindings/java/src/main/java/org/wickra/DrawdownDuration.java @@ -51,6 +51,26 @@ public final class DrawdownDuration implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DRAWDOWN_DURATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DRAWDOWN_DURATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DumplingTop.java b/bindings/java/src/main/java/org/wickra/DumplingTop.java index f28f8717..4f15ed58 100644 --- a/bindings/java/src/main/java/org/wickra/DumplingTop.java +++ b/bindings/java/src/main/java/org/wickra/DumplingTop.java @@ -74,6 +74,26 @@ public final class DumplingTop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DUMPLING_TOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DUMPLING_TOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Dx.java b/bindings/java/src/main/java/org/wickra/Dx.java index 39969a65..e46b4364 100644 --- a/bindings/java/src/main/java/org/wickra/Dx.java +++ b/bindings/java/src/main/java/org/wickra/Dx.java @@ -74,6 +74,26 @@ public final class Dx implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/DynamicMomentumIndex.java b/bindings/java/src/main/java/org/wickra/DynamicMomentumIndex.java index 27f6599f..252e064c 100644 --- a/bindings/java/src/main/java/org/wickra/DynamicMomentumIndex.java +++ b/bindings/java/src/main/java/org/wickra/DynamicMomentumIndex.java @@ -54,6 +54,26 @@ public final class DynamicMomentumIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_DYNAMIC_MOMENTUM_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_DYNAMIC_MOMENTUM_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EaseOfMovement.java b/bindings/java/src/main/java/org/wickra/EaseOfMovement.java index 9423d882..5f895b30 100644 --- a/bindings/java/src/main/java/org/wickra/EaseOfMovement.java +++ b/bindings/java/src/main/java/org/wickra/EaseOfMovement.java @@ -74,6 +74,26 @@ public final class EaseOfMovement implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EASE_OF_MOVEMENT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EASE_OF_MOVEMENT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EffectiveSpread.java b/bindings/java/src/main/java/org/wickra/EffectiveSpread.java index e5ce08f6..b3146a2d 100644 --- a/bindings/java/src/main/java/org/wickra/EffectiveSpread.java +++ b/bindings/java/src/main/java/org/wickra/EffectiveSpread.java @@ -36,6 +36,26 @@ public final class EffectiveSpread implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EFFECTIVE_SPREAD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EFFECTIVE_SPREAD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EhlersStochastic.java b/bindings/java/src/main/java/org/wickra/EhlersStochastic.java index d159e78b..4033d9bc 100644 --- a/bindings/java/src/main/java/org/wickra/EhlersStochastic.java +++ b/bindings/java/src/main/java/org/wickra/EhlersStochastic.java @@ -54,6 +54,26 @@ public final class EhlersStochastic implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EHLERS_STOCHASTIC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EHLERS_STOCHASTIC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Ehma.java b/bindings/java/src/main/java/org/wickra/Ehma.java index 4903ea9c..423cf038 100644 --- a/bindings/java/src/main/java/org/wickra/Ehma.java +++ b/bindings/java/src/main/java/org/wickra/Ehma.java @@ -54,6 +54,26 @@ public final class Ehma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EHMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EHMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ElderImpulse.java b/bindings/java/src/main/java/org/wickra/ElderImpulse.java index 2eadb9a2..9338faf9 100644 --- a/bindings/java/src/main/java/org/wickra/ElderImpulse.java +++ b/bindings/java/src/main/java/org/wickra/ElderImpulse.java @@ -63,6 +63,26 @@ public final class ElderImpulse implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ELDER_IMPULSE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ELDER_IMPULSE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ElderRay.java b/bindings/java/src/main/java/org/wickra/ElderRay.java index eb638f41..7100d198 100644 --- a/bindings/java/src/main/java/org/wickra/ElderRay.java +++ b/bindings/java/src/main/java/org/wickra/ElderRay.java @@ -46,6 +46,26 @@ public final class ElderRay implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ELDER_RAY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ELDER_RAY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ElderSafeZone.java b/bindings/java/src/main/java/org/wickra/ElderSafeZone.java index f6b589af..f9671276 100644 --- a/bindings/java/src/main/java/org/wickra/ElderSafeZone.java +++ b/bindings/java/src/main/java/org/wickra/ElderSafeZone.java @@ -46,6 +46,26 @@ public final class ElderSafeZone implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ELDER_SAFE_ZONE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ELDER_SAFE_ZONE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Ema.java b/bindings/java/src/main/java/org/wickra/Ema.java index 2854246f..bbc299f7 100644 --- a/bindings/java/src/main/java/org/wickra/Ema.java +++ b/bindings/java/src/main/java/org/wickra/Ema.java @@ -54,6 +54,26 @@ public final class Ema implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EmpiricalModeDecomposition.java b/bindings/java/src/main/java/org/wickra/EmpiricalModeDecomposition.java index 631b7cda..035f6b90 100644 --- a/bindings/java/src/main/java/org/wickra/EmpiricalModeDecomposition.java +++ b/bindings/java/src/main/java/org/wickra/EmpiricalModeDecomposition.java @@ -54,6 +54,26 @@ public final class EmpiricalModeDecomposition implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EMPIRICAL_MODE_DECOMPOSITION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EMPIRICAL_MODE_DECOMPOSITION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Engulfing.java b/bindings/java/src/main/java/org/wickra/Engulfing.java index 481fa918..534df409 100644 --- a/bindings/java/src/main/java/org/wickra/Engulfing.java +++ b/bindings/java/src/main/java/org/wickra/Engulfing.java @@ -71,6 +71,26 @@ public final class Engulfing implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ENGULFING_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ENGULFING_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Equivolume.java b/bindings/java/src/main/java/org/wickra/Equivolume.java index c5c954de..267a57fc 100644 --- a/bindings/java/src/main/java/org/wickra/Equivolume.java +++ b/bindings/java/src/main/java/org/wickra/Equivolume.java @@ -46,6 +46,26 @@ public final class Equivolume implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EQUIVOLUME_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EQUIVOLUME_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EstimatedLeverageRatio.java b/bindings/java/src/main/java/org/wickra/EstimatedLeverageRatio.java index ee94661c..be7d6f4f 100644 --- a/bindings/java/src/main/java/org/wickra/EstimatedLeverageRatio.java +++ b/bindings/java/src/main/java/org/wickra/EstimatedLeverageRatio.java @@ -36,6 +36,26 @@ public final class EstimatedLeverageRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ESTIMATED_LEVERAGE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ESTIMATED_LEVERAGE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EvenBetterSinewave.java b/bindings/java/src/main/java/org/wickra/EvenBetterSinewave.java index 2abd8860..f1c4c8dc 100644 --- a/bindings/java/src/main/java/org/wickra/EvenBetterSinewave.java +++ b/bindings/java/src/main/java/org/wickra/EvenBetterSinewave.java @@ -57,6 +57,26 @@ public final class EvenBetterSinewave implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EVEN_BETTER_SINEWAVE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EVEN_BETTER_SINEWAVE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EveningDojiStar.java b/bindings/java/src/main/java/org/wickra/EveningDojiStar.java index ec621cc9..1ba587ee 100644 --- a/bindings/java/src/main/java/org/wickra/EveningDojiStar.java +++ b/bindings/java/src/main/java/org/wickra/EveningDojiStar.java @@ -71,6 +71,26 @@ public final class EveningDojiStar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EVENING_DOJI_STAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EVENING_DOJI_STAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Evwma.java b/bindings/java/src/main/java/org/wickra/Evwma.java index e0a25f3d..7154f292 100644 --- a/bindings/java/src/main/java/org/wickra/Evwma.java +++ b/bindings/java/src/main/java/org/wickra/Evwma.java @@ -74,6 +74,26 @@ public final class Evwma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EVWMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EVWMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/EwmaVolatility.java b/bindings/java/src/main/java/org/wickra/EwmaVolatility.java index 7d544707..d47d0332 100644 --- a/bindings/java/src/main/java/org/wickra/EwmaVolatility.java +++ b/bindings/java/src/main/java/org/wickra/EwmaVolatility.java @@ -51,6 +51,26 @@ public final class EwmaVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EWMA_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EWMA_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Expectancy.java b/bindings/java/src/main/java/org/wickra/Expectancy.java index 670db1b9..f94b3b95 100644 --- a/bindings/java/src/main/java/org/wickra/Expectancy.java +++ b/bindings/java/src/main/java/org/wickra/Expectancy.java @@ -54,6 +54,26 @@ public final class Expectancy implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_EXPECTANCY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_EXPECTANCY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FallingThreeMethods.java b/bindings/java/src/main/java/org/wickra/FallingThreeMethods.java index 7580e4c2..ac489411 100644 --- a/bindings/java/src/main/java/org/wickra/FallingThreeMethods.java +++ b/bindings/java/src/main/java/org/wickra/FallingThreeMethods.java @@ -71,6 +71,26 @@ public final class FallingThreeMethods implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FALLING_THREE_METHODS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FALLING_THREE_METHODS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Fama.java b/bindings/java/src/main/java/org/wickra/Fama.java index e9f3d519..7e69dbe4 100644 --- a/bindings/java/src/main/java/org/wickra/Fama.java +++ b/bindings/java/src/main/java/org/wickra/Fama.java @@ -51,6 +51,26 @@ public final class Fama implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FAMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FAMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibArcs.java b/bindings/java/src/main/java/org/wickra/FibArcs.java index 5965bc64..5455164a 100644 --- a/bindings/java/src/main/java/org/wickra/FibArcs.java +++ b/bindings/java/src/main/java/org/wickra/FibArcs.java @@ -44,6 +44,26 @@ public final class FibArcs implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_ARCS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_ARCS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibChannel.java b/bindings/java/src/main/java/org/wickra/FibChannel.java index 09bfca41..5bc72c06 100644 --- a/bindings/java/src/main/java/org/wickra/FibChannel.java +++ b/bindings/java/src/main/java/org/wickra/FibChannel.java @@ -45,6 +45,26 @@ public final class FibChannel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_CHANNEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_CHANNEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibConfluence.java b/bindings/java/src/main/java/org/wickra/FibConfluence.java index 7461a945..e3e0eb5f 100644 --- a/bindings/java/src/main/java/org/wickra/FibConfluence.java +++ b/bindings/java/src/main/java/org/wickra/FibConfluence.java @@ -43,6 +43,26 @@ public final class FibConfluence implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_CONFLUENCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_CONFLUENCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibExtension.java b/bindings/java/src/main/java/org/wickra/FibExtension.java index 53f57d32..fcaceb3b 100644 --- a/bindings/java/src/main/java/org/wickra/FibExtension.java +++ b/bindings/java/src/main/java/org/wickra/FibExtension.java @@ -46,6 +46,26 @@ public final class FibExtension implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_EXTENSION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_EXTENSION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibFan.java b/bindings/java/src/main/java/org/wickra/FibFan.java index 48c25e3a..ba913171 100644 --- a/bindings/java/src/main/java/org/wickra/FibFan.java +++ b/bindings/java/src/main/java/org/wickra/FibFan.java @@ -44,6 +44,26 @@ public final class FibFan implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_FAN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_FAN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibProjection.java b/bindings/java/src/main/java/org/wickra/FibProjection.java index cf649f74..b942bb52 100644 --- a/bindings/java/src/main/java/org/wickra/FibProjection.java +++ b/bindings/java/src/main/java/org/wickra/FibProjection.java @@ -45,6 +45,26 @@ public final class FibProjection implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_PROJECTION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_PROJECTION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibRetracement.java b/bindings/java/src/main/java/org/wickra/FibRetracement.java index 4d26afa5..d9aed6ba 100644 --- a/bindings/java/src/main/java/org/wickra/FibRetracement.java +++ b/bindings/java/src/main/java/org/wickra/FibRetracement.java @@ -48,6 +48,26 @@ public final class FibRetracement implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_RETRACEMENT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_RETRACEMENT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibTimeZones.java b/bindings/java/src/main/java/org/wickra/FibTimeZones.java index f8a530d9..a60f4b68 100644 --- a/bindings/java/src/main/java/org/wickra/FibTimeZones.java +++ b/bindings/java/src/main/java/org/wickra/FibTimeZones.java @@ -43,6 +43,26 @@ public final class FibTimeZones implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIB_TIME_ZONES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIB_TIME_ZONES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FibonacciPivots.java b/bindings/java/src/main/java/org/wickra/FibonacciPivots.java index 73a84469..46f79121 100644 --- a/bindings/java/src/main/java/org/wickra/FibonacciPivots.java +++ b/bindings/java/src/main/java/org/wickra/FibonacciPivots.java @@ -48,6 +48,26 @@ public final class FibonacciPivots implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FIBONACCI_PIVOTS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FIBONACCI_PIVOTS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FisherRsi.java b/bindings/java/src/main/java/org/wickra/FisherRsi.java index 4bdc0ccc..8582a3f7 100644 --- a/bindings/java/src/main/java/org/wickra/FisherRsi.java +++ b/bindings/java/src/main/java/org/wickra/FisherRsi.java @@ -54,6 +54,26 @@ public final class FisherRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FISHER_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FISHER_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FisherTransform.java b/bindings/java/src/main/java/org/wickra/FisherTransform.java index cad8fd18..189ec247 100644 --- a/bindings/java/src/main/java/org/wickra/FisherTransform.java +++ b/bindings/java/src/main/java/org/wickra/FisherTransform.java @@ -54,6 +54,26 @@ public final class FisherTransform implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FISHER_TRANSFORM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FISHER_TRANSFORM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FlagPennant.java b/bindings/java/src/main/java/org/wickra/FlagPennant.java index a0226367..903f65f4 100644 --- a/bindings/java/src/main/java/org/wickra/FlagPennant.java +++ b/bindings/java/src/main/java/org/wickra/FlagPennant.java @@ -71,6 +71,26 @@ public final class FlagPennant implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FLAG_PENNANT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FLAG_PENNANT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Footprint.java b/bindings/java/src/main/java/org/wickra/Footprint.java index 99b039e7..49a808c8 100644 --- a/bindings/java/src/main/java/org/wickra/Footprint.java +++ b/bindings/java/src/main/java/org/wickra/Footprint.java @@ -50,6 +50,26 @@ public final class Footprint implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FOOTPRINT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FOOTPRINT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ForceIndex.java b/bindings/java/src/main/java/org/wickra/ForceIndex.java index ff34757d..9b710b45 100644 --- a/bindings/java/src/main/java/org/wickra/ForceIndex.java +++ b/bindings/java/src/main/java/org/wickra/ForceIndex.java @@ -74,6 +74,26 @@ public final class ForceIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FORCE_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FORCE_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FractalChaosBands.java b/bindings/java/src/main/java/org/wickra/FractalChaosBands.java index 36ecbe71..23a6ef9c 100644 --- a/bindings/java/src/main/java/org/wickra/FractalChaosBands.java +++ b/bindings/java/src/main/java/org/wickra/FractalChaosBands.java @@ -46,6 +46,26 @@ public final class FractalChaosBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FRACTAL_CHAOS_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FRACTAL_CHAOS_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Frama.java b/bindings/java/src/main/java/org/wickra/Frama.java index b925f6dc..fca3dfb6 100644 --- a/bindings/java/src/main/java/org/wickra/Frama.java +++ b/bindings/java/src/main/java/org/wickra/Frama.java @@ -54,6 +54,26 @@ public final class Frama implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FRAMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FRAMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FryPanBottom.java b/bindings/java/src/main/java/org/wickra/FryPanBottom.java index 3dde122b..4479befa 100644 --- a/bindings/java/src/main/java/org/wickra/FryPanBottom.java +++ b/bindings/java/src/main/java/org/wickra/FryPanBottom.java @@ -74,6 +74,26 @@ public final class FryPanBottom implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FRY_PAN_BOTTOM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FRY_PAN_BOTTOM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FundingBasis.java b/bindings/java/src/main/java/org/wickra/FundingBasis.java index bfb19642..937c4564 100644 --- a/bindings/java/src/main/java/org/wickra/FundingBasis.java +++ b/bindings/java/src/main/java/org/wickra/FundingBasis.java @@ -36,6 +36,26 @@ public final class FundingBasis implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FUNDING_BASIS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FUNDING_BASIS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FundingImpliedApr.java b/bindings/java/src/main/java/org/wickra/FundingImpliedApr.java index 4698f483..0589262a 100644 --- a/bindings/java/src/main/java/org/wickra/FundingImpliedApr.java +++ b/bindings/java/src/main/java/org/wickra/FundingImpliedApr.java @@ -36,6 +36,26 @@ public final class FundingImpliedApr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FUNDING_IMPLIED_APR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FUNDING_IMPLIED_APR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FundingRate.java b/bindings/java/src/main/java/org/wickra/FundingRate.java index eefb624c..c7486059 100644 --- a/bindings/java/src/main/java/org/wickra/FundingRate.java +++ b/bindings/java/src/main/java/org/wickra/FundingRate.java @@ -36,6 +36,26 @@ public final class FundingRate implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FUNDING_RATE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FUNDING_RATE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FundingRateMean.java b/bindings/java/src/main/java/org/wickra/FundingRateMean.java index ef196761..c75718ad 100644 --- a/bindings/java/src/main/java/org/wickra/FundingRateMean.java +++ b/bindings/java/src/main/java/org/wickra/FundingRateMean.java @@ -39,6 +39,26 @@ public final class FundingRateMean implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FUNDING_RATE_MEAN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FUNDING_RATE_MEAN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/FundingRateZScore.java b/bindings/java/src/main/java/org/wickra/FundingRateZScore.java index 757f160f..be4569fa 100644 --- a/bindings/java/src/main/java/org/wickra/FundingRateZScore.java +++ b/bindings/java/src/main/java/org/wickra/FundingRateZScore.java @@ -39,6 +39,26 @@ public final class FundingRateZScore implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_FUNDING_RATE_Z_SCORE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_FUNDING_RATE_Z_SCORE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GainLossRatio.java b/bindings/java/src/main/java/org/wickra/GainLossRatio.java index f1fd3cde..dd6bd088 100644 --- a/bindings/java/src/main/java/org/wickra/GainLossRatio.java +++ b/bindings/java/src/main/java/org/wickra/GainLossRatio.java @@ -54,6 +54,26 @@ public final class GainLossRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GAIN_LOSS_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GAIN_LOSS_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GainToPainRatio.java b/bindings/java/src/main/java/org/wickra/GainToPainRatio.java index 62fbc996..f1720681 100644 --- a/bindings/java/src/main/java/org/wickra/GainToPainRatio.java +++ b/bindings/java/src/main/java/org/wickra/GainToPainRatio.java @@ -54,6 +54,26 @@ public final class GainToPainRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GAIN_TO_PAIN_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GAIN_TO_PAIN_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GapSideBySideWhite.java b/bindings/java/src/main/java/org/wickra/GapSideBySideWhite.java index 03718643..95e58040 100644 --- a/bindings/java/src/main/java/org/wickra/GapSideBySideWhite.java +++ b/bindings/java/src/main/java/org/wickra/GapSideBySideWhite.java @@ -71,6 +71,26 @@ public final class GapSideBySideWhite implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GAP_SIDE_BY_SIDE_WHITE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GAP_SIDE_BY_SIDE_WHITE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Garch11.java b/bindings/java/src/main/java/org/wickra/Garch11.java index eb044c3d..e9c56aef 100644 --- a/bindings/java/src/main/java/org/wickra/Garch11.java +++ b/bindings/java/src/main/java/org/wickra/Garch11.java @@ -51,6 +51,26 @@ public final class Garch11 implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GARCH11_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GARCH11_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GarmanKlassVolatility.java b/bindings/java/src/main/java/org/wickra/GarmanKlassVolatility.java index 925dc4e7..3ea15f83 100644 --- a/bindings/java/src/main/java/org/wickra/GarmanKlassVolatility.java +++ b/bindings/java/src/main/java/org/wickra/GarmanKlassVolatility.java @@ -77,6 +77,26 @@ public final class GarmanKlassVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GARMAN_KLASS_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GARMAN_KLASS_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Gartley.java b/bindings/java/src/main/java/org/wickra/Gartley.java index 517510ab..9630779b 100644 --- a/bindings/java/src/main/java/org/wickra/Gartley.java +++ b/bindings/java/src/main/java/org/wickra/Gartley.java @@ -71,6 +71,26 @@ public final class Gartley implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GARTLEY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GARTLEY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GatorOscillator.java b/bindings/java/src/main/java/org/wickra/GatorOscillator.java index 696b2bf4..08c97bc5 100644 --- a/bindings/java/src/main/java/org/wickra/GatorOscillator.java +++ b/bindings/java/src/main/java/org/wickra/GatorOscillator.java @@ -52,6 +52,26 @@ public final class GatorOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GATOR_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GATOR_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GeneralizedDema.java b/bindings/java/src/main/java/org/wickra/GeneralizedDema.java index 11bb317b..201c1e0f 100644 --- a/bindings/java/src/main/java/org/wickra/GeneralizedDema.java +++ b/bindings/java/src/main/java/org/wickra/GeneralizedDema.java @@ -54,6 +54,26 @@ public final class GeneralizedDema implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GENERALIZED_DEMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GENERALIZED_DEMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GeometricMa.java b/bindings/java/src/main/java/org/wickra/GeometricMa.java index 43cc4d55..a0ce12ea 100644 --- a/bindings/java/src/main/java/org/wickra/GeometricMa.java +++ b/bindings/java/src/main/java/org/wickra/GeometricMa.java @@ -54,6 +54,26 @@ public final class GeometricMa implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GEOMETRIC_MA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GEOMETRIC_MA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GoldenPocket.java b/bindings/java/src/main/java/org/wickra/GoldenPocket.java index a670b806..0b9b2a72 100644 --- a/bindings/java/src/main/java/org/wickra/GoldenPocket.java +++ b/bindings/java/src/main/java/org/wickra/GoldenPocket.java @@ -44,6 +44,26 @@ public final class GoldenPocket implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GOLDEN_POCKET_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GOLDEN_POCKET_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GrangerCausality.java b/bindings/java/src/main/java/org/wickra/GrangerCausality.java index 2fee4f89..281eb9d7 100644 --- a/bindings/java/src/main/java/org/wickra/GrangerCausality.java +++ b/bindings/java/src/main/java/org/wickra/GrangerCausality.java @@ -61,6 +61,26 @@ public final class GrangerCausality implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GRANGER_CAUSALITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GRANGER_CAUSALITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/GravestoneDoji.java b/bindings/java/src/main/java/org/wickra/GravestoneDoji.java index 9f4cd177..7324a757 100644 --- a/bindings/java/src/main/java/org/wickra/GravestoneDoji.java +++ b/bindings/java/src/main/java/org/wickra/GravestoneDoji.java @@ -71,6 +71,26 @@ public final class GravestoneDoji implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_GRAVESTONE_DOJI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_GRAVESTONE_DOJI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Hammer.java b/bindings/java/src/main/java/org/wickra/Hammer.java index b88dc321..e4991657 100644 --- a/bindings/java/src/main/java/org/wickra/Hammer.java +++ b/bindings/java/src/main/java/org/wickra/Hammer.java @@ -71,6 +71,26 @@ public final class Hammer implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HAMMER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HAMMER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HangingMan.java b/bindings/java/src/main/java/org/wickra/HangingMan.java index 81eb0562..d9b23945 100644 --- a/bindings/java/src/main/java/org/wickra/HangingMan.java +++ b/bindings/java/src/main/java/org/wickra/HangingMan.java @@ -71,6 +71,26 @@ public final class HangingMan implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HANGING_MAN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HANGING_MAN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Harami.java b/bindings/java/src/main/java/org/wickra/Harami.java index 259aefc7..9ba1d02c 100644 --- a/bindings/java/src/main/java/org/wickra/Harami.java +++ b/bindings/java/src/main/java/org/wickra/Harami.java @@ -71,6 +71,26 @@ public final class Harami implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HARAMI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HARAMI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HaramiCross.java b/bindings/java/src/main/java/org/wickra/HaramiCross.java index a7349cfc..2f634de8 100644 --- a/bindings/java/src/main/java/org/wickra/HaramiCross.java +++ b/bindings/java/src/main/java/org/wickra/HaramiCross.java @@ -71,6 +71,26 @@ public final class HaramiCross implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HARAMI_CROSS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HARAMI_CROSS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HasbrouckInformationShare.java b/bindings/java/src/main/java/org/wickra/HasbrouckInformationShare.java index dbf3cee8..6ad887fe 100644 --- a/bindings/java/src/main/java/org/wickra/HasbrouckInformationShare.java +++ b/bindings/java/src/main/java/org/wickra/HasbrouckInformationShare.java @@ -58,6 +58,26 @@ public final class HasbrouckInformationShare implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HASBROUCK_INFORMATION_SHARE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HASBROUCK_INFORMATION_SHARE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HeadAndShoulders.java b/bindings/java/src/main/java/org/wickra/HeadAndShoulders.java index 9f04624d..c0379427 100644 --- a/bindings/java/src/main/java/org/wickra/HeadAndShoulders.java +++ b/bindings/java/src/main/java/org/wickra/HeadAndShoulders.java @@ -71,6 +71,26 @@ public final class HeadAndShoulders implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HEAD_AND_SHOULDERS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HEAD_AND_SHOULDERS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HeikinAshi.java b/bindings/java/src/main/java/org/wickra/HeikinAshi.java index 3146a1ed..7d567b67 100644 --- a/bindings/java/src/main/java/org/wickra/HeikinAshi.java +++ b/bindings/java/src/main/java/org/wickra/HeikinAshi.java @@ -45,6 +45,26 @@ public final class HeikinAshi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HEIKIN_ASHI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HEIKIN_ASHI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HeikinAshiOscillator.java b/bindings/java/src/main/java/org/wickra/HeikinAshiOscillator.java index 5b781c44..07277700 100644 --- a/bindings/java/src/main/java/org/wickra/HeikinAshiOscillator.java +++ b/bindings/java/src/main/java/org/wickra/HeikinAshiOscillator.java @@ -74,6 +74,26 @@ public final class HeikinAshiOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HEIKIN_ASHI_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HEIKIN_ASHI_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HiLoActivator.java b/bindings/java/src/main/java/org/wickra/HiLoActivator.java index 2c6f6102..788d2057 100644 --- a/bindings/java/src/main/java/org/wickra/HiLoActivator.java +++ b/bindings/java/src/main/java/org/wickra/HiLoActivator.java @@ -74,6 +74,26 @@ public final class HiLoActivator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HI_LO_ACTIVATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HI_LO_ACTIVATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HighLowIndex.java b/bindings/java/src/main/java/org/wickra/HighLowIndex.java index b8c73516..41eb9f92 100644 --- a/bindings/java/src/main/java/org/wickra/HighLowIndex.java +++ b/bindings/java/src/main/java/org/wickra/HighLowIndex.java @@ -60,6 +60,26 @@ public final class HighLowIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIGH_LOW_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIGH_LOW_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HighLowRange.java b/bindings/java/src/main/java/org/wickra/HighLowRange.java index bd71c4af..e827d223 100644 --- a/bindings/java/src/main/java/org/wickra/HighLowRange.java +++ b/bindings/java/src/main/java/org/wickra/HighLowRange.java @@ -71,6 +71,26 @@ public final class HighLowRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIGH_LOW_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIGH_LOW_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HighLowVolumeNodes.java b/bindings/java/src/main/java/org/wickra/HighLowVolumeNodes.java index 46d9d170..cf61bb07 100644 --- a/bindings/java/src/main/java/org/wickra/HighLowVolumeNodes.java +++ b/bindings/java/src/main/java/org/wickra/HighLowVolumeNodes.java @@ -49,6 +49,26 @@ public final class HighLowVolumeNodes implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIGH_LOW_VOLUME_NODES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIGH_LOW_VOLUME_NODES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HighWave.java b/bindings/java/src/main/java/org/wickra/HighWave.java index 00666670..ef70e693 100644 --- a/bindings/java/src/main/java/org/wickra/HighWave.java +++ b/bindings/java/src/main/java/org/wickra/HighWave.java @@ -71,6 +71,26 @@ public final class HighWave implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIGH_WAVE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIGH_WAVE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HighpassFilter.java b/bindings/java/src/main/java/org/wickra/HighpassFilter.java index 1f663740..b0ee09da 100644 --- a/bindings/java/src/main/java/org/wickra/HighpassFilter.java +++ b/bindings/java/src/main/java/org/wickra/HighpassFilter.java @@ -54,6 +54,26 @@ public final class HighpassFilter implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIGHPASS_FILTER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIGHPASS_FILTER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Hikkake.java b/bindings/java/src/main/java/org/wickra/Hikkake.java index afad5b84..3dfd04d6 100644 --- a/bindings/java/src/main/java/org/wickra/Hikkake.java +++ b/bindings/java/src/main/java/org/wickra/Hikkake.java @@ -71,6 +71,26 @@ public final class Hikkake implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIKKAKE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIKKAKE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HikkakeModified.java b/bindings/java/src/main/java/org/wickra/HikkakeModified.java index e9894960..6ade6ee7 100644 --- a/bindings/java/src/main/java/org/wickra/HikkakeModified.java +++ b/bindings/java/src/main/java/org/wickra/HikkakeModified.java @@ -71,6 +71,26 @@ public final class HikkakeModified implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HIKKAKE_MODIFIED_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HIKKAKE_MODIFIED_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HilbertDominantCycle.java b/bindings/java/src/main/java/org/wickra/HilbertDominantCycle.java index 83761a05..fd8553f3 100644 --- a/bindings/java/src/main/java/org/wickra/HilbertDominantCycle.java +++ b/bindings/java/src/main/java/org/wickra/HilbertDominantCycle.java @@ -51,6 +51,26 @@ public final class HilbertDominantCycle implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HILBERT_DOMINANT_CYCLE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HILBERT_DOMINANT_CYCLE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HistoricalVolatility.java b/bindings/java/src/main/java/org/wickra/HistoricalVolatility.java index d50f7251..ed8ab59d 100644 --- a/bindings/java/src/main/java/org/wickra/HistoricalVolatility.java +++ b/bindings/java/src/main/java/org/wickra/HistoricalVolatility.java @@ -57,6 +57,26 @@ public final class HistoricalVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HISTORICAL_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HISTORICAL_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Hma.java b/bindings/java/src/main/java/org/wickra/Hma.java index dda2b805..0fd365d3 100644 --- a/bindings/java/src/main/java/org/wickra/Hma.java +++ b/bindings/java/src/main/java/org/wickra/Hma.java @@ -54,6 +54,26 @@ public final class Hma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HoltWinters.java b/bindings/java/src/main/java/org/wickra/HoltWinters.java index 103fccb9..ee573790 100644 --- a/bindings/java/src/main/java/org/wickra/HoltWinters.java +++ b/bindings/java/src/main/java/org/wickra/HoltWinters.java @@ -51,6 +51,26 @@ public final class HoltWinters implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HOLT_WINTERS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HOLT_WINTERS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HomingPigeon.java b/bindings/java/src/main/java/org/wickra/HomingPigeon.java index 40798f63..65acf595 100644 --- a/bindings/java/src/main/java/org/wickra/HomingPigeon.java +++ b/bindings/java/src/main/java/org/wickra/HomingPigeon.java @@ -71,6 +71,26 @@ public final class HomingPigeon implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HOMING_PIGEON_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HOMING_PIGEON_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HtDcPhase.java b/bindings/java/src/main/java/org/wickra/HtDcPhase.java index 9bc8e789..dd2282cf 100644 --- a/bindings/java/src/main/java/org/wickra/HtDcPhase.java +++ b/bindings/java/src/main/java/org/wickra/HtDcPhase.java @@ -51,6 +51,26 @@ public final class HtDcPhase implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HT_DC_PHASE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HT_DC_PHASE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HtPhasor.java b/bindings/java/src/main/java/org/wickra/HtPhasor.java index b861e325..77d0b2c0 100644 --- a/bindings/java/src/main/java/org/wickra/HtPhasor.java +++ b/bindings/java/src/main/java/org/wickra/HtPhasor.java @@ -43,6 +43,26 @@ public final class HtPhasor implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HT_PHASOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HT_PHASOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HtTrendMode.java b/bindings/java/src/main/java/org/wickra/HtTrendMode.java index 154b23d7..6497700c 100644 --- a/bindings/java/src/main/java/org/wickra/HtTrendMode.java +++ b/bindings/java/src/main/java/org/wickra/HtTrendMode.java @@ -51,6 +51,26 @@ public final class HtTrendMode implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HT_TREND_MODE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HT_TREND_MODE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HurstChannel.java b/bindings/java/src/main/java/org/wickra/HurstChannel.java index 7dd50236..73e2f449 100644 --- a/bindings/java/src/main/java/org/wickra/HurstChannel.java +++ b/bindings/java/src/main/java/org/wickra/HurstChannel.java @@ -47,6 +47,26 @@ public final class HurstChannel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HURST_CHANNEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HURST_CHANNEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/HurstExponent.java b/bindings/java/src/main/java/org/wickra/HurstExponent.java index b0a783a8..df8ab56d 100644 --- a/bindings/java/src/main/java/org/wickra/HurstExponent.java +++ b/bindings/java/src/main/java/org/wickra/HurstExponent.java @@ -57,6 +57,26 @@ public final class HurstExponent implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_HURST_EXPONENT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_HURST_EXPONENT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Ichimoku.java b/bindings/java/src/main/java/org/wickra/Ichimoku.java index 17c8fa46..46dfd505 100644 --- a/bindings/java/src/main/java/org/wickra/Ichimoku.java +++ b/bindings/java/src/main/java/org/wickra/Ichimoku.java @@ -58,6 +58,26 @@ public final class Ichimoku implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ICHIMOKU_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ICHIMOKU_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/IdenticalThreeCrows.java b/bindings/java/src/main/java/org/wickra/IdenticalThreeCrows.java index 6555c17a..4547e53e 100644 --- a/bindings/java/src/main/java/org/wickra/IdenticalThreeCrows.java +++ b/bindings/java/src/main/java/org/wickra/IdenticalThreeCrows.java @@ -71,6 +71,26 @@ public final class IdenticalThreeCrows implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_IDENTICAL_THREE_CROWS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_IDENTICAL_THREE_CROWS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/InNeck.java b/bindings/java/src/main/java/org/wickra/InNeck.java index c5e1831c..442f7cf0 100644 --- a/bindings/java/src/main/java/org/wickra/InNeck.java +++ b/bindings/java/src/main/java/org/wickra/InNeck.java @@ -71,6 +71,26 @@ public final class InNeck implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_IN_NECK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_IN_NECK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Inertia.java b/bindings/java/src/main/java/org/wickra/Inertia.java index 89f96a1d..9406260e 100644 --- a/bindings/java/src/main/java/org/wickra/Inertia.java +++ b/bindings/java/src/main/java/org/wickra/Inertia.java @@ -77,6 +77,26 @@ public final class Inertia implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INERTIA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INERTIA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/InformationRatio.java b/bindings/java/src/main/java/org/wickra/InformationRatio.java index 9cc8e2e2..22d21c92 100644 --- a/bindings/java/src/main/java/org/wickra/InformationRatio.java +++ b/bindings/java/src/main/java/org/wickra/InformationRatio.java @@ -58,6 +58,26 @@ public final class InformationRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INFORMATION_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INFORMATION_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/InitialBalance.java b/bindings/java/src/main/java/org/wickra/InitialBalance.java index a22864c4..5337fbaf 100644 --- a/bindings/java/src/main/java/org/wickra/InitialBalance.java +++ b/bindings/java/src/main/java/org/wickra/InitialBalance.java @@ -46,6 +46,26 @@ public final class InitialBalance implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INITIAL_BALANCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INITIAL_BALANCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/InstantaneousTrendline.java b/bindings/java/src/main/java/org/wickra/InstantaneousTrendline.java index 28ae9a7b..a20c2f4b 100644 --- a/bindings/java/src/main/java/org/wickra/InstantaneousTrendline.java +++ b/bindings/java/src/main/java/org/wickra/InstantaneousTrendline.java @@ -54,6 +54,26 @@ public final class InstantaneousTrendline implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INSTANTANEOUS_TRENDLINE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INSTANTANEOUS_TRENDLINE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/IntradayIntensity.java b/bindings/java/src/main/java/org/wickra/IntradayIntensity.java index e4e3c643..b291bad9 100644 --- a/bindings/java/src/main/java/org/wickra/IntradayIntensity.java +++ b/bindings/java/src/main/java/org/wickra/IntradayIntensity.java @@ -71,6 +71,26 @@ public final class IntradayIntensity implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INTRADAY_INTENSITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INTRADAY_INTENSITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/IntradayMomentumIndex.java b/bindings/java/src/main/java/org/wickra/IntradayMomentumIndex.java index 5da8d84d..675d3d18 100644 --- a/bindings/java/src/main/java/org/wickra/IntradayMomentumIndex.java +++ b/bindings/java/src/main/java/org/wickra/IntradayMomentumIndex.java @@ -74,6 +74,26 @@ public final class IntradayMomentumIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INTRADAY_MOMENTUM_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INTRADAY_MOMENTUM_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/IntradayVolatilityProfile.java b/bindings/java/src/main/java/org/wickra/IntradayVolatilityProfile.java index 563f4c02..f66acf49 100644 --- a/bindings/java/src/main/java/org/wickra/IntradayVolatilityProfile.java +++ b/bindings/java/src/main/java/org/wickra/IntradayVolatilityProfile.java @@ -50,6 +50,26 @@ public final class IntradayVolatilityProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INTRADAY_VOLATILITY_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INTRADAY_VOLATILITY_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/InverseFisherTransform.java b/bindings/java/src/main/java/org/wickra/InverseFisherTransform.java index b1f14b71..3e622be5 100644 --- a/bindings/java/src/main/java/org/wickra/InverseFisherTransform.java +++ b/bindings/java/src/main/java/org/wickra/InverseFisherTransform.java @@ -51,6 +51,26 @@ public final class InverseFisherTransform implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INVERSE_FISHER_TRANSFORM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INVERSE_FISHER_TRANSFORM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/InvertedHammer.java b/bindings/java/src/main/java/org/wickra/InvertedHammer.java index c65c0f85..23194224 100644 --- a/bindings/java/src/main/java/org/wickra/InvertedHammer.java +++ b/bindings/java/src/main/java/org/wickra/InvertedHammer.java @@ -71,6 +71,26 @@ public final class InvertedHammer implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_INVERTED_HAMMER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_INVERTED_HAMMER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/JarqueBera.java b/bindings/java/src/main/java/org/wickra/JarqueBera.java index c4db25ab..157a3d70 100644 --- a/bindings/java/src/main/java/org/wickra/JarqueBera.java +++ b/bindings/java/src/main/java/org/wickra/JarqueBera.java @@ -54,6 +54,26 @@ public final class JarqueBera implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_JARQUE_BERA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_JARQUE_BERA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Jma.java b/bindings/java/src/main/java/org/wickra/Jma.java index ff9fd8e4..79380b87 100644 --- a/bindings/java/src/main/java/org/wickra/Jma.java +++ b/bindings/java/src/main/java/org/wickra/Jma.java @@ -54,6 +54,26 @@ public final class Jma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_JMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_JMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/JumpIndicator.java b/bindings/java/src/main/java/org/wickra/JumpIndicator.java index a4d0e999..47cc7659 100644 --- a/bindings/java/src/main/java/org/wickra/JumpIndicator.java +++ b/bindings/java/src/main/java/org/wickra/JumpIndicator.java @@ -54,6 +54,26 @@ public final class JumpIndicator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_JUMP_INDICATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_JUMP_INDICATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KRatio.java b/bindings/java/src/main/java/org/wickra/KRatio.java index 55bf3775..be4fe186 100644 --- a/bindings/java/src/main/java/org/wickra/KRatio.java +++ b/bindings/java/src/main/java/org/wickra/KRatio.java @@ -54,6 +54,26 @@ public final class KRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_K_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_K_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KalmanHedgeRatio.java b/bindings/java/src/main/java/org/wickra/KalmanHedgeRatio.java index 1331fc4e..cc21b1f2 100644 --- a/bindings/java/src/main/java/org/wickra/KalmanHedgeRatio.java +++ b/bindings/java/src/main/java/org/wickra/KalmanHedgeRatio.java @@ -44,6 +44,26 @@ public final class KalmanHedgeRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KALMAN_HEDGE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KALMAN_HEDGE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Kama.java b/bindings/java/src/main/java/org/wickra/Kama.java index 538a7669..9448d417 100644 --- a/bindings/java/src/main/java/org/wickra/Kama.java +++ b/bindings/java/src/main/java/org/wickra/Kama.java @@ -60,6 +60,26 @@ public final class Kama implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KAMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KAMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KaseDevStop.java b/bindings/java/src/main/java/org/wickra/KaseDevStop.java index 19fdd8b1..dab27fcb 100644 --- a/bindings/java/src/main/java/org/wickra/KaseDevStop.java +++ b/bindings/java/src/main/java/org/wickra/KaseDevStop.java @@ -46,6 +46,26 @@ public final class KaseDevStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KASE_DEV_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KASE_DEV_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KasePermissionStochastic.java b/bindings/java/src/main/java/org/wickra/KasePermissionStochastic.java index 372a9a6e..13b395cb 100644 --- a/bindings/java/src/main/java/org/wickra/KasePermissionStochastic.java +++ b/bindings/java/src/main/java/org/wickra/KasePermissionStochastic.java @@ -49,6 +49,26 @@ public final class KasePermissionStochastic implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KASE_PERMISSION_STOCHASTIC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KASE_PERMISSION_STOCHASTIC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KellyCriterion.java b/bindings/java/src/main/java/org/wickra/KellyCriterion.java index 273cc98f..660ae87a 100644 --- a/bindings/java/src/main/java/org/wickra/KellyCriterion.java +++ b/bindings/java/src/main/java/org/wickra/KellyCriterion.java @@ -54,6 +54,26 @@ public final class KellyCriterion implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KELLY_CRITERION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KELLY_CRITERION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Keltner.java b/bindings/java/src/main/java/org/wickra/Keltner.java index 38262e0c..1bddc6e7 100644 --- a/bindings/java/src/main/java/org/wickra/Keltner.java +++ b/bindings/java/src/main/java/org/wickra/Keltner.java @@ -50,6 +50,26 @@ public final class Keltner implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KELTNER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KELTNER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KendallTau.java b/bindings/java/src/main/java/org/wickra/KendallTau.java index ba642a02..247f89dc 100644 --- a/bindings/java/src/main/java/org/wickra/KendallTau.java +++ b/bindings/java/src/main/java/org/wickra/KendallTau.java @@ -58,6 +58,26 @@ public final class KendallTau implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KENDALL_TAU_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KENDALL_TAU_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Kicking.java b/bindings/java/src/main/java/org/wickra/Kicking.java index 730a9c57..beceae36 100644 --- a/bindings/java/src/main/java/org/wickra/Kicking.java +++ b/bindings/java/src/main/java/org/wickra/Kicking.java @@ -71,6 +71,26 @@ public final class Kicking implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KICKING_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KICKING_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KickingByLength.java b/bindings/java/src/main/java/org/wickra/KickingByLength.java index 4510dbdb..ceb17ad1 100644 --- a/bindings/java/src/main/java/org/wickra/KickingByLength.java +++ b/bindings/java/src/main/java/org/wickra/KickingByLength.java @@ -71,6 +71,26 @@ public final class KickingByLength implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KICKING_BY_LENGTH_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KICKING_BY_LENGTH_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Kst.java b/bindings/java/src/main/java/org/wickra/Kst.java index 51b3954d..be944b1e 100644 --- a/bindings/java/src/main/java/org/wickra/Kst.java +++ b/bindings/java/src/main/java/org/wickra/Kst.java @@ -70,6 +70,26 @@ public final class Kst implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KST_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KST_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Kurtosis.java b/bindings/java/src/main/java/org/wickra/Kurtosis.java index a7c39fed..98350774 100644 --- a/bindings/java/src/main/java/org/wickra/Kurtosis.java +++ b/bindings/java/src/main/java/org/wickra/Kurtosis.java @@ -54,6 +54,26 @@ public final class Kurtosis implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KURTOSIS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KURTOSIS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Kvo.java b/bindings/java/src/main/java/org/wickra/Kvo.java index f5a4553f..4adc539d 100644 --- a/bindings/java/src/main/java/org/wickra/Kvo.java +++ b/bindings/java/src/main/java/org/wickra/Kvo.java @@ -77,6 +77,26 @@ public final class Kvo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KVO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KVO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/KylesLambda.java b/bindings/java/src/main/java/org/wickra/KylesLambda.java index b52b78ac..6f082ecc 100644 --- a/bindings/java/src/main/java/org/wickra/KylesLambda.java +++ b/bindings/java/src/main/java/org/wickra/KylesLambda.java @@ -39,6 +39,26 @@ public final class KylesLambda implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_KYLES_LAMBDA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_KYLES_LAMBDA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LadderBottom.java b/bindings/java/src/main/java/org/wickra/LadderBottom.java index 3c2ba1ba..5d38427a 100644 --- a/bindings/java/src/main/java/org/wickra/LadderBottom.java +++ b/bindings/java/src/main/java/org/wickra/LadderBottom.java @@ -71,6 +71,26 @@ public final class LadderBottom implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LADDER_BOTTOM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LADDER_BOTTOM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LaguerreRsi.java b/bindings/java/src/main/java/org/wickra/LaguerreRsi.java index ab67a06f..d4ed680d 100644 --- a/bindings/java/src/main/java/org/wickra/LaguerreRsi.java +++ b/bindings/java/src/main/java/org/wickra/LaguerreRsi.java @@ -51,6 +51,26 @@ public final class LaguerreRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LAGUERRE_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LAGUERRE_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LeadLagCrossCorrelation.java b/bindings/java/src/main/java/org/wickra/LeadLagCrossCorrelation.java index a3196c6c..5c322cbb 100644 --- a/bindings/java/src/main/java/org/wickra/LeadLagCrossCorrelation.java +++ b/bindings/java/src/main/java/org/wickra/LeadLagCrossCorrelation.java @@ -49,6 +49,26 @@ public final class LeadLagCrossCorrelation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LEAD_LAG_CROSS_CORRELATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LEAD_LAG_CROSS_CORRELATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LinRegAngle.java b/bindings/java/src/main/java/org/wickra/LinRegAngle.java index 9477f666..cd9848f9 100644 --- a/bindings/java/src/main/java/org/wickra/LinRegAngle.java +++ b/bindings/java/src/main/java/org/wickra/LinRegAngle.java @@ -54,6 +54,26 @@ public final class LinRegAngle implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LIN_REG_ANGLE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LIN_REG_ANGLE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LinRegChannel.java b/bindings/java/src/main/java/org/wickra/LinRegChannel.java index 9b473baa..de9d183b 100644 --- a/bindings/java/src/main/java/org/wickra/LinRegChannel.java +++ b/bindings/java/src/main/java/org/wickra/LinRegChannel.java @@ -47,6 +47,26 @@ public final class LinRegChannel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LIN_REG_CHANNEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LIN_REG_CHANNEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LinRegIntercept.java b/bindings/java/src/main/java/org/wickra/LinRegIntercept.java index 8ed8223a..b7e8ca13 100644 --- a/bindings/java/src/main/java/org/wickra/LinRegIntercept.java +++ b/bindings/java/src/main/java/org/wickra/LinRegIntercept.java @@ -54,6 +54,26 @@ public final class LinRegIntercept implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LIN_REG_INTERCEPT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LIN_REG_INTERCEPT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LinRegSlope.java b/bindings/java/src/main/java/org/wickra/LinRegSlope.java index bd61d486..d0f3a6c0 100644 --- a/bindings/java/src/main/java/org/wickra/LinRegSlope.java +++ b/bindings/java/src/main/java/org/wickra/LinRegSlope.java @@ -54,6 +54,26 @@ public final class LinRegSlope implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LIN_REG_SLOPE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LIN_REG_SLOPE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LinearRegression.java b/bindings/java/src/main/java/org/wickra/LinearRegression.java index edce1160..6b59bbaf 100644 --- a/bindings/java/src/main/java/org/wickra/LinearRegression.java +++ b/bindings/java/src/main/java/org/wickra/LinearRegression.java @@ -54,6 +54,26 @@ public final class LinearRegression implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LINEAR_REGRESSION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LINEAR_REGRESSION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LiquidationFeatures.java b/bindings/java/src/main/java/org/wickra/LiquidationFeatures.java index 3e657949..47020626 100644 --- a/bindings/java/src/main/java/org/wickra/LiquidationFeatures.java +++ b/bindings/java/src/main/java/org/wickra/LiquidationFeatures.java @@ -46,6 +46,26 @@ public final class LiquidationFeatures implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LIQUIDATION_FEATURES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LIQUIDATION_FEATURES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LogReturn.java b/bindings/java/src/main/java/org/wickra/LogReturn.java index ef94e063..64d30fe7 100644 --- a/bindings/java/src/main/java/org/wickra/LogReturn.java +++ b/bindings/java/src/main/java/org/wickra/LogReturn.java @@ -54,6 +54,26 @@ public final class LogReturn implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LOG_RETURN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LOG_RETURN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LongLeggedDoji.java b/bindings/java/src/main/java/org/wickra/LongLeggedDoji.java index bca7496b..66620597 100644 --- a/bindings/java/src/main/java/org/wickra/LongLeggedDoji.java +++ b/bindings/java/src/main/java/org/wickra/LongLeggedDoji.java @@ -71,6 +71,26 @@ public final class LongLeggedDoji implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LONG_LEGGED_DOJI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LONG_LEGGED_DOJI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LongLine.java b/bindings/java/src/main/java/org/wickra/LongLine.java index 0a13e93c..f7c104bf 100644 --- a/bindings/java/src/main/java/org/wickra/LongLine.java +++ b/bindings/java/src/main/java/org/wickra/LongLine.java @@ -71,6 +71,26 @@ public final class LongLine implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LONG_LINE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LONG_LINE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/LongShortRatio.java b/bindings/java/src/main/java/org/wickra/LongShortRatio.java index cd375956..c1c935f8 100644 --- a/bindings/java/src/main/java/org/wickra/LongShortRatio.java +++ b/bindings/java/src/main/java/org/wickra/LongShortRatio.java @@ -36,6 +36,26 @@ public final class LongShortRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_LONG_SHORT_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_LONG_SHORT_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/M2Measure.java b/bindings/java/src/main/java/org/wickra/M2Measure.java index bab7e721..adb9f0bc 100644 --- a/bindings/java/src/main/java/org/wickra/M2Measure.java +++ b/bindings/java/src/main/java/org/wickra/M2Measure.java @@ -54,6 +54,26 @@ public final class M2Measure implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_M2_MEASURE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_M2_MEASURE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MaEnvelope.java b/bindings/java/src/main/java/org/wickra/MaEnvelope.java index 5e88a73f..86de2db8 100644 --- a/bindings/java/src/main/java/org/wickra/MaEnvelope.java +++ b/bindings/java/src/main/java/org/wickra/MaEnvelope.java @@ -47,6 +47,26 @@ public final class MaEnvelope implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MA_ENVELOPE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MA_ENVELOPE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MacdExt.java b/bindings/java/src/main/java/org/wickra/MacdExt.java index 50e20d0c..d500fa8e 100644 --- a/bindings/java/src/main/java/org/wickra/MacdExt.java +++ b/bindings/java/src/main/java/org/wickra/MacdExt.java @@ -53,6 +53,26 @@ public final class MacdExt implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MACD_EXT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MACD_EXT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MacdFix.java b/bindings/java/src/main/java/org/wickra/MacdFix.java index 2da6a964..5a250b1f 100644 --- a/bindings/java/src/main/java/org/wickra/MacdFix.java +++ b/bindings/java/src/main/java/org/wickra/MacdFix.java @@ -47,6 +47,26 @@ public final class MacdFix implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MACD_FIX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MACD_FIX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MacdHistogram.java b/bindings/java/src/main/java/org/wickra/MacdHistogram.java index 20e06788..a13f3c07 100644 --- a/bindings/java/src/main/java/org/wickra/MacdHistogram.java +++ b/bindings/java/src/main/java/org/wickra/MacdHistogram.java @@ -60,6 +60,26 @@ public final class MacdHistogram implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MACD_HISTOGRAM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MACD_HISTOGRAM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MacdIndicator.java b/bindings/java/src/main/java/org/wickra/MacdIndicator.java index e48a3ab5..e04234cc 100644 --- a/bindings/java/src/main/java/org/wickra/MacdIndicator.java +++ b/bindings/java/src/main/java/org/wickra/MacdIndicator.java @@ -53,6 +53,26 @@ public final class MacdIndicator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MACD_INDICATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MACD_INDICATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Mama.java b/bindings/java/src/main/java/org/wickra/Mama.java index 7b9c6b80..b35ce172 100644 --- a/bindings/java/src/main/java/org/wickra/Mama.java +++ b/bindings/java/src/main/java/org/wickra/Mama.java @@ -43,6 +43,26 @@ public final class Mama implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MAMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MAMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MarketFacilitationIndex.java b/bindings/java/src/main/java/org/wickra/MarketFacilitationIndex.java index e8a9f3d4..9eb416fd 100644 --- a/bindings/java/src/main/java/org/wickra/MarketFacilitationIndex.java +++ b/bindings/java/src/main/java/org/wickra/MarketFacilitationIndex.java @@ -71,6 +71,26 @@ public final class MarketFacilitationIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MARKET_FACILITATION_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MARKET_FACILITATION_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MartinRatio.java b/bindings/java/src/main/java/org/wickra/MartinRatio.java index c82ccc26..28664df1 100644 --- a/bindings/java/src/main/java/org/wickra/MartinRatio.java +++ b/bindings/java/src/main/java/org/wickra/MartinRatio.java @@ -54,6 +54,26 @@ public final class MartinRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MARTIN_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MARTIN_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Marubozu.java b/bindings/java/src/main/java/org/wickra/Marubozu.java index 0f8fc6a7..40c45169 100644 --- a/bindings/java/src/main/java/org/wickra/Marubozu.java +++ b/bindings/java/src/main/java/org/wickra/Marubozu.java @@ -71,6 +71,26 @@ public final class Marubozu implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MARUBOZU_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MARUBOZU_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MassIndex.java b/bindings/java/src/main/java/org/wickra/MassIndex.java index 245aa275..7e959206 100644 --- a/bindings/java/src/main/java/org/wickra/MassIndex.java +++ b/bindings/java/src/main/java/org/wickra/MassIndex.java @@ -77,6 +77,26 @@ public final class MassIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MASS_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MASS_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MatHold.java b/bindings/java/src/main/java/org/wickra/MatHold.java index c7872e56..413f62f6 100644 --- a/bindings/java/src/main/java/org/wickra/MatHold.java +++ b/bindings/java/src/main/java/org/wickra/MatHold.java @@ -71,6 +71,26 @@ public final class MatHold implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MAT_HOLD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MAT_HOLD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MatchingLow.java b/bindings/java/src/main/java/org/wickra/MatchingLow.java index ecb1d922..7c63c8a4 100644 --- a/bindings/java/src/main/java/org/wickra/MatchingLow.java +++ b/bindings/java/src/main/java/org/wickra/MatchingLow.java @@ -71,6 +71,26 @@ public final class MatchingLow implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MATCHING_LOW_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MATCHING_LOW_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MaxDrawdown.java b/bindings/java/src/main/java/org/wickra/MaxDrawdown.java index 0e430f3d..a2debe10 100644 --- a/bindings/java/src/main/java/org/wickra/MaxDrawdown.java +++ b/bindings/java/src/main/java/org/wickra/MaxDrawdown.java @@ -54,6 +54,26 @@ public final class MaxDrawdown implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MAX_DRAWDOWN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MAX_DRAWDOWN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/McClellanOscillator.java b/bindings/java/src/main/java/org/wickra/McClellanOscillator.java index bc452399..fac00902 100644 --- a/bindings/java/src/main/java/org/wickra/McClellanOscillator.java +++ b/bindings/java/src/main/java/org/wickra/McClellanOscillator.java @@ -57,6 +57,26 @@ public final class McClellanOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MC_CLELLAN_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MC_CLELLAN_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/McClellanSummationIndex.java b/bindings/java/src/main/java/org/wickra/McClellanSummationIndex.java index 7033a4c8..e74f3281 100644 --- a/bindings/java/src/main/java/org/wickra/McClellanSummationIndex.java +++ b/bindings/java/src/main/java/org/wickra/McClellanSummationIndex.java @@ -57,6 +57,26 @@ public final class McClellanSummationIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MC_CLELLAN_SUMMATION_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MC_CLELLAN_SUMMATION_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/McGinleyDynamic.java b/bindings/java/src/main/java/org/wickra/McGinleyDynamic.java index 0280b5c8..7f0932be 100644 --- a/bindings/java/src/main/java/org/wickra/McGinleyDynamic.java +++ b/bindings/java/src/main/java/org/wickra/McGinleyDynamic.java @@ -54,6 +54,26 @@ public final class McGinleyDynamic implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MC_GINLEY_DYNAMIC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MC_GINLEY_DYNAMIC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MedianAbsoluteDeviation.java b/bindings/java/src/main/java/org/wickra/MedianAbsoluteDeviation.java index 05dc1184..8d6378bc 100644 --- a/bindings/java/src/main/java/org/wickra/MedianAbsoluteDeviation.java +++ b/bindings/java/src/main/java/org/wickra/MedianAbsoluteDeviation.java @@ -54,6 +54,26 @@ public final class MedianAbsoluteDeviation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MEDIAN_ABSOLUTE_DEVIATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MEDIAN_ABSOLUTE_DEVIATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MedianChannel.java b/bindings/java/src/main/java/org/wickra/MedianChannel.java index 01b80d91..45584ccf 100644 --- a/bindings/java/src/main/java/org/wickra/MedianChannel.java +++ b/bindings/java/src/main/java/org/wickra/MedianChannel.java @@ -47,6 +47,26 @@ public final class MedianChannel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MEDIAN_CHANNEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MEDIAN_CHANNEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MedianMa.java b/bindings/java/src/main/java/org/wickra/MedianMa.java index 855d0882..971d324d 100644 --- a/bindings/java/src/main/java/org/wickra/MedianMa.java +++ b/bindings/java/src/main/java/org/wickra/MedianMa.java @@ -54,6 +54,26 @@ public final class MedianMa implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MEDIAN_MA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MEDIAN_MA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MedianPrice.java b/bindings/java/src/main/java/org/wickra/MedianPrice.java index bfef062a..d6ffa378 100644 --- a/bindings/java/src/main/java/org/wickra/MedianPrice.java +++ b/bindings/java/src/main/java/org/wickra/MedianPrice.java @@ -71,6 +71,26 @@ public final class MedianPrice implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MEDIAN_PRICE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MEDIAN_PRICE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Mfi.java b/bindings/java/src/main/java/org/wickra/Mfi.java index 768f300b..164152e0 100644 --- a/bindings/java/src/main/java/org/wickra/Mfi.java +++ b/bindings/java/src/main/java/org/wickra/Mfi.java @@ -74,6 +74,26 @@ public final class Mfi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MFI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MFI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Microprice.java b/bindings/java/src/main/java/org/wickra/Microprice.java index be3362f5..fbc89d5d 100644 --- a/bindings/java/src/main/java/org/wickra/Microprice.java +++ b/bindings/java/src/main/java/org/wickra/Microprice.java @@ -46,6 +46,26 @@ public final class Microprice implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MICROPRICE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MICROPRICE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MidPoint.java b/bindings/java/src/main/java/org/wickra/MidPoint.java index 0fc1d416..1a91c0eb 100644 --- a/bindings/java/src/main/java/org/wickra/MidPoint.java +++ b/bindings/java/src/main/java/org/wickra/MidPoint.java @@ -54,6 +54,26 @@ public final class MidPoint implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MID_POINT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MID_POINT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MidPrice.java b/bindings/java/src/main/java/org/wickra/MidPrice.java index e004ed5b..350845ea 100644 --- a/bindings/java/src/main/java/org/wickra/MidPrice.java +++ b/bindings/java/src/main/java/org/wickra/MidPrice.java @@ -74,6 +74,26 @@ public final class MidPrice implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MID_PRICE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MID_PRICE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MinusDi.java b/bindings/java/src/main/java/org/wickra/MinusDi.java index 10f5dab0..42ae5949 100644 --- a/bindings/java/src/main/java/org/wickra/MinusDi.java +++ b/bindings/java/src/main/java/org/wickra/MinusDi.java @@ -74,6 +74,26 @@ public final class MinusDi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MINUS_DI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MINUS_DI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MinusDm.java b/bindings/java/src/main/java/org/wickra/MinusDm.java index 5978b749..e0c43a2e 100644 --- a/bindings/java/src/main/java/org/wickra/MinusDm.java +++ b/bindings/java/src/main/java/org/wickra/MinusDm.java @@ -74,6 +74,26 @@ public final class MinusDm implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MINUS_DM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MINUS_DM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ModifiedMaStop.java b/bindings/java/src/main/java/org/wickra/ModifiedMaStop.java index 396ee895..691df6b8 100644 --- a/bindings/java/src/main/java/org/wickra/ModifiedMaStop.java +++ b/bindings/java/src/main/java/org/wickra/ModifiedMaStop.java @@ -46,6 +46,26 @@ public final class ModifiedMaStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MODIFIED_MA_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MODIFIED_MA_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Mom.java b/bindings/java/src/main/java/org/wickra/Mom.java index 934ad0f8..d06dc16d 100644 --- a/bindings/java/src/main/java/org/wickra/Mom.java +++ b/bindings/java/src/main/java/org/wickra/Mom.java @@ -54,6 +54,26 @@ public final class Mom implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MOM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MOM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MorningDojiStar.java b/bindings/java/src/main/java/org/wickra/MorningDojiStar.java index 0edcda6f..d421a1d1 100644 --- a/bindings/java/src/main/java/org/wickra/MorningDojiStar.java +++ b/bindings/java/src/main/java/org/wickra/MorningDojiStar.java @@ -71,6 +71,26 @@ public final class MorningDojiStar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MORNING_DOJI_STAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MORNING_DOJI_STAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MorningEveningStar.java b/bindings/java/src/main/java/org/wickra/MorningEveningStar.java index 600522e4..eadf72ca 100644 --- a/bindings/java/src/main/java/org/wickra/MorningEveningStar.java +++ b/bindings/java/src/main/java/org/wickra/MorningEveningStar.java @@ -71,6 +71,26 @@ public final class MorningEveningStar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MORNING_EVENING_STAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MORNING_EVENING_STAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/MurreyMathLines.java b/bindings/java/src/main/java/org/wickra/MurreyMathLines.java index da3efad4..2480b58c 100644 --- a/bindings/java/src/main/java/org/wickra/MurreyMathLines.java +++ b/bindings/java/src/main/java/org/wickra/MurreyMathLines.java @@ -53,6 +53,26 @@ public final class MurreyMathLines implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_MURREY_MATH_LINES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_MURREY_MATH_LINES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/NakedPoc.java b/bindings/java/src/main/java/org/wickra/NakedPoc.java index 0aa16e9e..02b4ace2 100644 --- a/bindings/java/src/main/java/org/wickra/NakedPoc.java +++ b/bindings/java/src/main/java/org/wickra/NakedPoc.java @@ -77,6 +77,26 @@ public final class NakedPoc implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_NAKED_POC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_NAKED_POC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Natr.java b/bindings/java/src/main/java/org/wickra/Natr.java index 9894d431..2ea2413b 100644 --- a/bindings/java/src/main/java/org/wickra/Natr.java +++ b/bindings/java/src/main/java/org/wickra/Natr.java @@ -74,6 +74,26 @@ public final class Natr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_NATR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_NATR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/NewHighsNewLows.java b/bindings/java/src/main/java/org/wickra/NewHighsNewLows.java index 61e83105..b9039947 100644 --- a/bindings/java/src/main/java/org/wickra/NewHighsNewLows.java +++ b/bindings/java/src/main/java/org/wickra/NewHighsNewLows.java @@ -57,6 +57,26 @@ public final class NewHighsNewLows implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_NEW_HIGHS_NEW_LOWS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_NEW_HIGHS_NEW_LOWS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/NewPriceLines.java b/bindings/java/src/main/java/org/wickra/NewPriceLines.java index 01f6696c..11bc78fa 100644 --- a/bindings/java/src/main/java/org/wickra/NewPriceLines.java +++ b/bindings/java/src/main/java/org/wickra/NewPriceLines.java @@ -74,6 +74,26 @@ public final class NewPriceLines implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_NEW_PRICE_LINES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_NEW_PRICE_LINES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Nrtr.java b/bindings/java/src/main/java/org/wickra/Nrtr.java index 8dc462be..31998228 100644 --- a/bindings/java/src/main/java/org/wickra/Nrtr.java +++ b/bindings/java/src/main/java/org/wickra/Nrtr.java @@ -43,6 +43,26 @@ public final class Nrtr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_NRTR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_NRTR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Nvi.java b/bindings/java/src/main/java/org/wickra/Nvi.java index bc1a3687..8163d5ce 100644 --- a/bindings/java/src/main/java/org/wickra/Nvi.java +++ b/bindings/java/src/main/java/org/wickra/Nvi.java @@ -71,6 +71,26 @@ public final class Nvi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_NVI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_NVI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OIPriceDivergence.java b/bindings/java/src/main/java/org/wickra/OIPriceDivergence.java index 38c876ef..6b0a8672 100644 --- a/bindings/java/src/main/java/org/wickra/OIPriceDivergence.java +++ b/bindings/java/src/main/java/org/wickra/OIPriceDivergence.java @@ -39,6 +39,26 @@ public final class OIPriceDivergence implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OI_PRICE_DIVERGENCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OI_PRICE_DIVERGENCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OIWeighted.java b/bindings/java/src/main/java/org/wickra/OIWeighted.java index d300b4e8..bfe39314 100644 --- a/bindings/java/src/main/java/org/wickra/OIWeighted.java +++ b/bindings/java/src/main/java/org/wickra/OIWeighted.java @@ -36,6 +36,26 @@ public final class OIWeighted implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OI_WEIGHTED_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OI_WEIGHTED_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Obv.java b/bindings/java/src/main/java/org/wickra/Obv.java index 9419cd0d..5b166838 100644 --- a/bindings/java/src/main/java/org/wickra/Obv.java +++ b/bindings/java/src/main/java/org/wickra/Obv.java @@ -71,6 +71,26 @@ public final class Obv implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OBV_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OBV_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OiToVolumeRatio.java b/bindings/java/src/main/java/org/wickra/OiToVolumeRatio.java index 6be3cf6f..4f268440 100644 --- a/bindings/java/src/main/java/org/wickra/OiToVolumeRatio.java +++ b/bindings/java/src/main/java/org/wickra/OiToVolumeRatio.java @@ -36,6 +36,26 @@ public final class OiToVolumeRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OI_TO_VOLUME_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OI_TO_VOLUME_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OmegaRatio.java b/bindings/java/src/main/java/org/wickra/OmegaRatio.java index 80624221..f227345c 100644 --- a/bindings/java/src/main/java/org/wickra/OmegaRatio.java +++ b/bindings/java/src/main/java/org/wickra/OmegaRatio.java @@ -54,6 +54,26 @@ public final class OmegaRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OMEGA_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OMEGA_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OnNeck.java b/bindings/java/src/main/java/org/wickra/OnNeck.java index 42a75a55..3ea52075 100644 --- a/bindings/java/src/main/java/org/wickra/OnNeck.java +++ b/bindings/java/src/main/java/org/wickra/OnNeck.java @@ -71,6 +71,26 @@ public final class OnNeck implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ON_NECK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ON_NECK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OpenInterestDelta.java b/bindings/java/src/main/java/org/wickra/OpenInterestDelta.java index 04e7a4ba..6e115529 100644 --- a/bindings/java/src/main/java/org/wickra/OpenInterestDelta.java +++ b/bindings/java/src/main/java/org/wickra/OpenInterestDelta.java @@ -36,6 +36,26 @@ public final class OpenInterestDelta implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OPEN_INTEREST_DELTA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OPEN_INTEREST_DELTA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OpenInterestMomentum.java b/bindings/java/src/main/java/org/wickra/OpenInterestMomentum.java index 0911a452..e6e8bd04 100644 --- a/bindings/java/src/main/java/org/wickra/OpenInterestMomentum.java +++ b/bindings/java/src/main/java/org/wickra/OpenInterestMomentum.java @@ -39,6 +39,26 @@ public final class OpenInterestMomentum implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OPEN_INTEREST_MOMENTUM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OPEN_INTEREST_MOMENTUM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OpeningMarubozu.java b/bindings/java/src/main/java/org/wickra/OpeningMarubozu.java index ef4a077e..6b0ab7dd 100644 --- a/bindings/java/src/main/java/org/wickra/OpeningMarubozu.java +++ b/bindings/java/src/main/java/org/wickra/OpeningMarubozu.java @@ -71,6 +71,26 @@ public final class OpeningMarubozu implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OPENING_MARUBOZU_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OPENING_MARUBOZU_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OpeningRange.java b/bindings/java/src/main/java/org/wickra/OpeningRange.java index 9c3f50d3..032254f3 100644 --- a/bindings/java/src/main/java/org/wickra/OpeningRange.java +++ b/bindings/java/src/main/java/org/wickra/OpeningRange.java @@ -47,6 +47,26 @@ public final class OpeningRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OPENING_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OPENING_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OrderBookImbalanceFull.java b/bindings/java/src/main/java/org/wickra/OrderBookImbalanceFull.java index f78c8f89..29d85357 100644 --- a/bindings/java/src/main/java/org/wickra/OrderBookImbalanceFull.java +++ b/bindings/java/src/main/java/org/wickra/OrderBookImbalanceFull.java @@ -46,6 +46,26 @@ public final class OrderBookImbalanceFull implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ORDER_BOOK_IMBALANCE_FULL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ORDER_BOOK_IMBALANCE_FULL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTop1.java b/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTop1.java index d0d90e48..7d73da73 100644 --- a/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTop1.java +++ b/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTop1.java @@ -46,6 +46,26 @@ public final class OrderBookImbalanceTop1 implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ORDER_BOOK_IMBALANCE_TOP1_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ORDER_BOOK_IMBALANCE_TOP1_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTopN.java b/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTopN.java index 5b1b3d0c..65679a72 100644 --- a/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTopN.java +++ b/bindings/java/src/main/java/org/wickra/OrderBookImbalanceTopN.java @@ -49,6 +49,26 @@ public final class OrderBookImbalanceTopN implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OrderFlowImbalance.java b/bindings/java/src/main/java/org/wickra/OrderFlowImbalance.java index ed6c4fe4..b0da4864 100644 --- a/bindings/java/src/main/java/org/wickra/OrderFlowImbalance.java +++ b/bindings/java/src/main/java/org/wickra/OrderFlowImbalance.java @@ -49,6 +49,26 @@ public final class OrderFlowImbalance implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ORDER_FLOW_IMBALANCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ORDER_FLOW_IMBALANCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OuHalfLife.java b/bindings/java/src/main/java/org/wickra/OuHalfLife.java index 31d34c96..88fd3632 100644 --- a/bindings/java/src/main/java/org/wickra/OuHalfLife.java +++ b/bindings/java/src/main/java/org/wickra/OuHalfLife.java @@ -58,6 +58,26 @@ public final class OuHalfLife implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OU_HALF_LIFE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OU_HALF_LIFE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OvernightGap.java b/bindings/java/src/main/java/org/wickra/OvernightGap.java index d95af9b1..e107e29f 100644 --- a/bindings/java/src/main/java/org/wickra/OvernightGap.java +++ b/bindings/java/src/main/java/org/wickra/OvernightGap.java @@ -71,6 +71,26 @@ public final class OvernightGap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OVERNIGHT_GAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OVERNIGHT_GAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/OvernightIntradayReturn.java b/bindings/java/src/main/java/org/wickra/OvernightIntradayReturn.java index 46a4c39c..e7094ae9 100644 --- a/bindings/java/src/main/java/org/wickra/OvernightIntradayReturn.java +++ b/bindings/java/src/main/java/org/wickra/OvernightIntradayReturn.java @@ -43,6 +43,26 @@ public final class OvernightIntradayReturn implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_OVERNIGHT_INTRADAY_RETURN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_OVERNIGHT_INTRADAY_RETURN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PainIndex.java b/bindings/java/src/main/java/org/wickra/PainIndex.java index 57f0acca..6a101b7f 100644 --- a/bindings/java/src/main/java/org/wickra/PainIndex.java +++ b/bindings/java/src/main/java/org/wickra/PainIndex.java @@ -54,6 +54,26 @@ public final class PainIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PAIN_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PAIN_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PairSpreadZScore.java b/bindings/java/src/main/java/org/wickra/PairSpreadZScore.java index 1d084db9..924ef023 100644 --- a/bindings/java/src/main/java/org/wickra/PairSpreadZScore.java +++ b/bindings/java/src/main/java/org/wickra/PairSpreadZScore.java @@ -61,6 +61,26 @@ public final class PairSpreadZScore implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PAIR_SPREAD_Z_SCORE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PAIR_SPREAD_Z_SCORE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PairwiseBeta.java b/bindings/java/src/main/java/org/wickra/PairwiseBeta.java index 0bc88ac8..dfb27558 100644 --- a/bindings/java/src/main/java/org/wickra/PairwiseBeta.java +++ b/bindings/java/src/main/java/org/wickra/PairwiseBeta.java @@ -58,6 +58,26 @@ public final class PairwiseBeta implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PAIRWISE_BETA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PAIRWISE_BETA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ParkinsonVolatility.java b/bindings/java/src/main/java/org/wickra/ParkinsonVolatility.java index f9ecf08b..84cb6a3d 100644 --- a/bindings/java/src/main/java/org/wickra/ParkinsonVolatility.java +++ b/bindings/java/src/main/java/org/wickra/ParkinsonVolatility.java @@ -77,6 +77,26 @@ public final class ParkinsonVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PARKINSON_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PARKINSON_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PearsonCorrelation.java b/bindings/java/src/main/java/org/wickra/PearsonCorrelation.java index 63b0d4cf..696f9df5 100644 --- a/bindings/java/src/main/java/org/wickra/PearsonCorrelation.java +++ b/bindings/java/src/main/java/org/wickra/PearsonCorrelation.java @@ -58,6 +58,26 @@ public final class PearsonCorrelation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PEARSON_CORRELATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PEARSON_CORRELATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PercentAboveMa.java b/bindings/java/src/main/java/org/wickra/PercentAboveMa.java index 02bac08e..83bd9177 100644 --- a/bindings/java/src/main/java/org/wickra/PercentAboveMa.java +++ b/bindings/java/src/main/java/org/wickra/PercentAboveMa.java @@ -57,6 +57,26 @@ public final class PercentAboveMa implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PERCENT_ABOVE_MA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PERCENT_ABOVE_MA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PercentB.java b/bindings/java/src/main/java/org/wickra/PercentB.java index 18a69cb2..5581318c 100644 --- a/bindings/java/src/main/java/org/wickra/PercentB.java +++ b/bindings/java/src/main/java/org/wickra/PercentB.java @@ -54,6 +54,26 @@ public final class PercentB implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PERCENT_B_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PERCENT_B_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PercentageTrailingStop.java b/bindings/java/src/main/java/org/wickra/PercentageTrailingStop.java index cf2dada7..035a10cc 100644 --- a/bindings/java/src/main/java/org/wickra/PercentageTrailingStop.java +++ b/bindings/java/src/main/java/org/wickra/PercentageTrailingStop.java @@ -51,6 +51,26 @@ public final class PercentageTrailingStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PERCENTAGE_TRAILING_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PERCENTAGE_TRAILING_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PerpetualPremiumIndex.java b/bindings/java/src/main/java/org/wickra/PerpetualPremiumIndex.java index 955976b5..2fd07156 100644 --- a/bindings/java/src/main/java/org/wickra/PerpetualPremiumIndex.java +++ b/bindings/java/src/main/java/org/wickra/PerpetualPremiumIndex.java @@ -36,6 +36,26 @@ public final class PerpetualPremiumIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PERPETUAL_PREMIUM_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PERPETUAL_PREMIUM_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Pgo.java b/bindings/java/src/main/java/org/wickra/Pgo.java index 02e1e5a9..d91ffd88 100644 --- a/bindings/java/src/main/java/org/wickra/Pgo.java +++ b/bindings/java/src/main/java/org/wickra/Pgo.java @@ -74,6 +74,26 @@ public final class Pgo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PGO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PGO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PiercingDarkCloud.java b/bindings/java/src/main/java/org/wickra/PiercingDarkCloud.java index bf8da7bb..45bdc4e4 100644 --- a/bindings/java/src/main/java/org/wickra/PiercingDarkCloud.java +++ b/bindings/java/src/main/java/org/wickra/PiercingDarkCloud.java @@ -71,6 +71,26 @@ public final class PiercingDarkCloud implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PIERCING_DARK_CLOUD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PIERCING_DARK_CLOUD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Pin.java b/bindings/java/src/main/java/org/wickra/Pin.java index 13b9e621..3d0fb624 100644 --- a/bindings/java/src/main/java/org/wickra/Pin.java +++ b/bindings/java/src/main/java/org/wickra/Pin.java @@ -39,6 +39,26 @@ public final class Pin implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PIN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PIN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PivotReversal.java b/bindings/java/src/main/java/org/wickra/PivotReversal.java index 0a0273bb..a2879962 100644 --- a/bindings/java/src/main/java/org/wickra/PivotReversal.java +++ b/bindings/java/src/main/java/org/wickra/PivotReversal.java @@ -77,6 +77,26 @@ public final class PivotReversal implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PIVOT_REVERSAL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PIVOT_REVERSAL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PlusDi.java b/bindings/java/src/main/java/org/wickra/PlusDi.java index 26c76828..3a594d07 100644 --- a/bindings/java/src/main/java/org/wickra/PlusDi.java +++ b/bindings/java/src/main/java/org/wickra/PlusDi.java @@ -74,6 +74,26 @@ public final class PlusDi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PLUS_DI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PLUS_DI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PlusDm.java b/bindings/java/src/main/java/org/wickra/PlusDm.java index da9e3f29..85865d1a 100644 --- a/bindings/java/src/main/java/org/wickra/PlusDm.java +++ b/bindings/java/src/main/java/org/wickra/PlusDm.java @@ -74,6 +74,26 @@ public final class PlusDm implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PLUS_DM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PLUS_DM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Pmo.java b/bindings/java/src/main/java/org/wickra/Pmo.java index 78aea686..ff475176 100644 --- a/bindings/java/src/main/java/org/wickra/Pmo.java +++ b/bindings/java/src/main/java/org/wickra/Pmo.java @@ -57,6 +57,26 @@ public final class Pmo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PMO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PMO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PolarizedFractalEfficiency.java b/bindings/java/src/main/java/org/wickra/PolarizedFractalEfficiency.java index ac919493..0d29569c 100644 --- a/bindings/java/src/main/java/org/wickra/PolarizedFractalEfficiency.java +++ b/bindings/java/src/main/java/org/wickra/PolarizedFractalEfficiency.java @@ -57,6 +57,26 @@ public final class PolarizedFractalEfficiency implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_POLARIZED_FRACTAL_EFFICIENCY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_POLARIZED_FRACTAL_EFFICIENCY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Ppo.java b/bindings/java/src/main/java/org/wickra/Ppo.java index 8c80ec1c..9250adf5 100644 --- a/bindings/java/src/main/java/org/wickra/Ppo.java +++ b/bindings/java/src/main/java/org/wickra/Ppo.java @@ -57,6 +57,26 @@ public final class Ppo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PPO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PPO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/PpoHistogram.java b/bindings/java/src/main/java/org/wickra/PpoHistogram.java index cb2a3a1f..d66418b8 100644 --- a/bindings/java/src/main/java/org/wickra/PpoHistogram.java +++ b/bindings/java/src/main/java/org/wickra/PpoHistogram.java @@ -60,6 +60,26 @@ public final class PpoHistogram implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PPO_HISTOGRAM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PPO_HISTOGRAM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ProfileShape.java b/bindings/java/src/main/java/org/wickra/ProfileShape.java index e857403c..a491c934 100644 --- a/bindings/java/src/main/java/org/wickra/ProfileShape.java +++ b/bindings/java/src/main/java/org/wickra/ProfileShape.java @@ -77,6 +77,26 @@ public final class ProfileShape implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PROFILE_SHAPE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PROFILE_SHAPE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ProfitFactor.java b/bindings/java/src/main/java/org/wickra/ProfitFactor.java index d4133b55..764da4e1 100644 --- a/bindings/java/src/main/java/org/wickra/ProfitFactor.java +++ b/bindings/java/src/main/java/org/wickra/ProfitFactor.java @@ -54,6 +54,26 @@ public final class ProfitFactor implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PROFIT_FACTOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PROFIT_FACTOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ProjectionBands.java b/bindings/java/src/main/java/org/wickra/ProjectionBands.java index dec1233f..b04ce291 100644 --- a/bindings/java/src/main/java/org/wickra/ProjectionBands.java +++ b/bindings/java/src/main/java/org/wickra/ProjectionBands.java @@ -47,6 +47,26 @@ public final class ProjectionBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PROJECTION_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PROJECTION_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ProjectionOscillator.java b/bindings/java/src/main/java/org/wickra/ProjectionOscillator.java index 12d51eb1..7c063c1b 100644 --- a/bindings/java/src/main/java/org/wickra/ProjectionOscillator.java +++ b/bindings/java/src/main/java/org/wickra/ProjectionOscillator.java @@ -74,6 +74,26 @@ public final class ProjectionOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PROJECTION_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PROJECTION_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Psar.java b/bindings/java/src/main/java/org/wickra/Psar.java index 0088c69f..1855956e 100644 --- a/bindings/java/src/main/java/org/wickra/Psar.java +++ b/bindings/java/src/main/java/org/wickra/Psar.java @@ -71,6 +71,26 @@ public final class Psar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PSAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PSAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Pvi.java b/bindings/java/src/main/java/org/wickra/Pvi.java index b3f97601..c5f3a935 100644 --- a/bindings/java/src/main/java/org/wickra/Pvi.java +++ b/bindings/java/src/main/java/org/wickra/Pvi.java @@ -71,6 +71,26 @@ public final class Pvi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_PVI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_PVI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Qqe.java b/bindings/java/src/main/java/org/wickra/Qqe.java index f56b771b..b582b284 100644 --- a/bindings/java/src/main/java/org/wickra/Qqe.java +++ b/bindings/java/src/main/java/org/wickra/Qqe.java @@ -49,6 +49,26 @@ public final class Qqe implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_QQE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_QQE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Qstick.java b/bindings/java/src/main/java/org/wickra/Qstick.java index 261b065e..4f0fedbd 100644 --- a/bindings/java/src/main/java/org/wickra/Qstick.java +++ b/bindings/java/src/main/java/org/wickra/Qstick.java @@ -74,6 +74,26 @@ public final class Qstick implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_QSTICK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_QSTICK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/QuartileBands.java b/bindings/java/src/main/java/org/wickra/QuartileBands.java index 6b20fec8..b966cd9c 100644 --- a/bindings/java/src/main/java/org/wickra/QuartileBands.java +++ b/bindings/java/src/main/java/org/wickra/QuartileBands.java @@ -47,6 +47,26 @@ public final class QuartileBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_QUARTILE_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_QUARTILE_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/QuotedSpread.java b/bindings/java/src/main/java/org/wickra/QuotedSpread.java index 00584ee8..97ce11fb 100644 --- a/bindings/java/src/main/java/org/wickra/QuotedSpread.java +++ b/bindings/java/src/main/java/org/wickra/QuotedSpread.java @@ -46,6 +46,26 @@ public final class QuotedSpread implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_QUOTED_SPREAD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_QUOTED_SPREAD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RSquared.java b/bindings/java/src/main/java/org/wickra/RSquared.java index 86c66ece..aec31f58 100644 --- a/bindings/java/src/main/java/org/wickra/RSquared.java +++ b/bindings/java/src/main/java/org/wickra/RSquared.java @@ -54,6 +54,26 @@ public final class RSquared implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_R_SQUARED_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_R_SQUARED_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RealizedSpread.java b/bindings/java/src/main/java/org/wickra/RealizedSpread.java index a4ea490c..818a80a4 100644 --- a/bindings/java/src/main/java/org/wickra/RealizedSpread.java +++ b/bindings/java/src/main/java/org/wickra/RealizedSpread.java @@ -39,6 +39,26 @@ public final class RealizedSpread implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_REALIZED_SPREAD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_REALIZED_SPREAD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RealizedVolatility.java b/bindings/java/src/main/java/org/wickra/RealizedVolatility.java index 898a51fb..0eabedfd 100644 --- a/bindings/java/src/main/java/org/wickra/RealizedVolatility.java +++ b/bindings/java/src/main/java/org/wickra/RealizedVolatility.java @@ -54,6 +54,26 @@ public final class RealizedVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_REALIZED_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_REALIZED_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RecoveryFactor.java b/bindings/java/src/main/java/org/wickra/RecoveryFactor.java index 6606e4c4..90e8b84e 100644 --- a/bindings/java/src/main/java/org/wickra/RecoveryFactor.java +++ b/bindings/java/src/main/java/org/wickra/RecoveryFactor.java @@ -51,6 +51,26 @@ public final class RecoveryFactor implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RECOVERY_FACTOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RECOVERY_FACTOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RectangleRange.java b/bindings/java/src/main/java/org/wickra/RectangleRange.java index 10dd5492..8316d169 100644 --- a/bindings/java/src/main/java/org/wickra/RectangleRange.java +++ b/bindings/java/src/main/java/org/wickra/RectangleRange.java @@ -71,6 +71,26 @@ public final class RectangleRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RECTANGLE_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RECTANGLE_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Reflex.java b/bindings/java/src/main/java/org/wickra/Reflex.java index aab57b9c..3553c5b7 100644 --- a/bindings/java/src/main/java/org/wickra/Reflex.java +++ b/bindings/java/src/main/java/org/wickra/Reflex.java @@ -54,6 +54,26 @@ public final class Reflex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_REFLEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_REFLEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RegimeLabel.java b/bindings/java/src/main/java/org/wickra/RegimeLabel.java index d89c7203..53141dd9 100644 --- a/bindings/java/src/main/java/org/wickra/RegimeLabel.java +++ b/bindings/java/src/main/java/org/wickra/RegimeLabel.java @@ -57,6 +57,26 @@ public final class RegimeLabel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_REGIME_LABEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_REGIME_LABEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RelativeStrengthAB.java b/bindings/java/src/main/java/org/wickra/RelativeStrengthAB.java index 0d494664..9ab2197d 100644 --- a/bindings/java/src/main/java/org/wickra/RelativeStrengthAB.java +++ b/bindings/java/src/main/java/org/wickra/RelativeStrengthAB.java @@ -50,6 +50,26 @@ public final class RelativeStrengthAB implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RELATIVE_STRENGTH_AB_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RELATIVE_STRENGTH_AB_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RenkoTrailingStop.java b/bindings/java/src/main/java/org/wickra/RenkoTrailingStop.java index 9d8ea478..77c73aad 100644 --- a/bindings/java/src/main/java/org/wickra/RenkoTrailingStop.java +++ b/bindings/java/src/main/java/org/wickra/RenkoTrailingStop.java @@ -51,6 +51,26 @@ public final class RenkoTrailingStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RENKO_TRAILING_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RENKO_TRAILING_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RickshawMan.java b/bindings/java/src/main/java/org/wickra/RickshawMan.java index d8d2a027..6586c008 100644 --- a/bindings/java/src/main/java/org/wickra/RickshawMan.java +++ b/bindings/java/src/main/java/org/wickra/RickshawMan.java @@ -71,6 +71,26 @@ public final class RickshawMan implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RICKSHAW_MAN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RICKSHAW_MAN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RisingThreeMethods.java b/bindings/java/src/main/java/org/wickra/RisingThreeMethods.java index 96a57ace..916e7381 100644 --- a/bindings/java/src/main/java/org/wickra/RisingThreeMethods.java +++ b/bindings/java/src/main/java/org/wickra/RisingThreeMethods.java @@ -71,6 +71,26 @@ public final class RisingThreeMethods implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RISING_THREE_METHODS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RISING_THREE_METHODS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rmi.java b/bindings/java/src/main/java/org/wickra/Rmi.java index 2439591d..8b937eb2 100644 --- a/bindings/java/src/main/java/org/wickra/Rmi.java +++ b/bindings/java/src/main/java/org/wickra/Rmi.java @@ -57,6 +57,26 @@ public final class Rmi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RMI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RMI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Roc.java b/bindings/java/src/main/java/org/wickra/Roc.java index 5172452f..ccacc13f 100644 --- a/bindings/java/src/main/java/org/wickra/Roc.java +++ b/bindings/java/src/main/java/org/wickra/Roc.java @@ -54,6 +54,26 @@ public final class Roc implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rocp.java b/bindings/java/src/main/java/org/wickra/Rocp.java index 1ae03afc..d2631e3a 100644 --- a/bindings/java/src/main/java/org/wickra/Rocp.java +++ b/bindings/java/src/main/java/org/wickra/Rocp.java @@ -54,6 +54,26 @@ public final class Rocp implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROCP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROCP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rocr.java b/bindings/java/src/main/java/org/wickra/Rocr.java index 4b728443..f71e514f 100644 --- a/bindings/java/src/main/java/org/wickra/Rocr.java +++ b/bindings/java/src/main/java/org/wickra/Rocr.java @@ -54,6 +54,26 @@ public final class Rocr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROCR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROCR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rocr100.java b/bindings/java/src/main/java/org/wickra/Rocr100.java index c8273b2b..5149de54 100644 --- a/bindings/java/src/main/java/org/wickra/Rocr100.java +++ b/bindings/java/src/main/java/org/wickra/Rocr100.java @@ -54,6 +54,26 @@ public final class Rocr100 implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROCR100_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROCR100_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RogersSatchellVolatility.java b/bindings/java/src/main/java/org/wickra/RogersSatchellVolatility.java index a04dbcf9..27868490 100644 --- a/bindings/java/src/main/java/org/wickra/RogersSatchellVolatility.java +++ b/bindings/java/src/main/java/org/wickra/RogersSatchellVolatility.java @@ -77,6 +77,26 @@ public final class RogersSatchellVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROGERS_SATCHELL_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROGERS_SATCHELL_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollMeasure.java b/bindings/java/src/main/java/org/wickra/RollMeasure.java index 0219632d..395103e7 100644 --- a/bindings/java/src/main/java/org/wickra/RollMeasure.java +++ b/bindings/java/src/main/java/org/wickra/RollMeasure.java @@ -39,6 +39,26 @@ public final class RollMeasure implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLL_MEASURE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLL_MEASURE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingCorrelation.java b/bindings/java/src/main/java/org/wickra/RollingCorrelation.java index 4cd073ce..dfe6fabe 100644 --- a/bindings/java/src/main/java/org/wickra/RollingCorrelation.java +++ b/bindings/java/src/main/java/org/wickra/RollingCorrelation.java @@ -58,6 +58,26 @@ public final class RollingCorrelation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_CORRELATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_CORRELATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingCovariance.java b/bindings/java/src/main/java/org/wickra/RollingCovariance.java index ecb69e86..c833928a 100644 --- a/bindings/java/src/main/java/org/wickra/RollingCovariance.java +++ b/bindings/java/src/main/java/org/wickra/RollingCovariance.java @@ -58,6 +58,26 @@ public final class RollingCovariance implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_COVARIANCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_COVARIANCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingIqr.java b/bindings/java/src/main/java/org/wickra/RollingIqr.java index dd42f807..e25e12d6 100644 --- a/bindings/java/src/main/java/org/wickra/RollingIqr.java +++ b/bindings/java/src/main/java/org/wickra/RollingIqr.java @@ -54,6 +54,26 @@ public final class RollingIqr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_IQR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_IQR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingMinMaxScaler.java b/bindings/java/src/main/java/org/wickra/RollingMinMaxScaler.java index 62dfbff2..2910eca4 100644 --- a/bindings/java/src/main/java/org/wickra/RollingMinMaxScaler.java +++ b/bindings/java/src/main/java/org/wickra/RollingMinMaxScaler.java @@ -54,6 +54,26 @@ public final class RollingMinMaxScaler implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_MIN_MAX_SCALER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_MIN_MAX_SCALER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingPercentileRank.java b/bindings/java/src/main/java/org/wickra/RollingPercentileRank.java index db769177..11460b58 100644 --- a/bindings/java/src/main/java/org/wickra/RollingPercentileRank.java +++ b/bindings/java/src/main/java/org/wickra/RollingPercentileRank.java @@ -54,6 +54,26 @@ public final class RollingPercentileRank implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_PERCENTILE_RANK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_PERCENTILE_RANK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingQuantile.java b/bindings/java/src/main/java/org/wickra/RollingQuantile.java index 8b7307a8..014a0652 100644 --- a/bindings/java/src/main/java/org/wickra/RollingQuantile.java +++ b/bindings/java/src/main/java/org/wickra/RollingQuantile.java @@ -54,6 +54,26 @@ public final class RollingQuantile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_QUANTILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_QUANTILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RollingVwap.java b/bindings/java/src/main/java/org/wickra/RollingVwap.java index fd9462fb..faa49b3d 100644 --- a/bindings/java/src/main/java/org/wickra/RollingVwap.java +++ b/bindings/java/src/main/java/org/wickra/RollingVwap.java @@ -74,6 +74,26 @@ public final class RollingVwap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROLLING_VWAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROLLING_VWAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RoofingFilter.java b/bindings/java/src/main/java/org/wickra/RoofingFilter.java index 0dade089..e988f45d 100644 --- a/bindings/java/src/main/java/org/wickra/RoofingFilter.java +++ b/bindings/java/src/main/java/org/wickra/RoofingFilter.java @@ -57,6 +57,26 @@ public final class RoofingFilter implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ROOFING_FILTER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ROOFING_FILTER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rsi.java b/bindings/java/src/main/java/org/wickra/Rsi.java index 4b4b6ddb..7bb97f4b 100644 --- a/bindings/java/src/main/java/org/wickra/Rsi.java +++ b/bindings/java/src/main/java/org/wickra/Rsi.java @@ -54,6 +54,26 @@ public final class Rsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rsx.java b/bindings/java/src/main/java/org/wickra/Rsx.java index 2be91cb5..66b6b6e2 100644 --- a/bindings/java/src/main/java/org/wickra/Rsx.java +++ b/bindings/java/src/main/java/org/wickra/Rsx.java @@ -54,6 +54,26 @@ public final class Rsx implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RSX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RSX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rvi.java b/bindings/java/src/main/java/org/wickra/Rvi.java index 8e81a077..3d10a70b 100644 --- a/bindings/java/src/main/java/org/wickra/Rvi.java +++ b/bindings/java/src/main/java/org/wickra/Rvi.java @@ -74,6 +74,26 @@ public final class Rvi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RVI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RVI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/RviVolatility.java b/bindings/java/src/main/java/org/wickra/RviVolatility.java index e94e50c3..78272981 100644 --- a/bindings/java/src/main/java/org/wickra/RviVolatility.java +++ b/bindings/java/src/main/java/org/wickra/RviVolatility.java @@ -54,6 +54,26 @@ public final class RviVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RVI_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RVI_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Rwi.java b/bindings/java/src/main/java/org/wickra/Rwi.java index e41c53cd..0e487be0 100644 --- a/bindings/java/src/main/java/org/wickra/Rwi.java +++ b/bindings/java/src/main/java/org/wickra/Rwi.java @@ -46,6 +46,26 @@ public final class Rwi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_RWI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_RWI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SampleEntropy.java b/bindings/java/src/main/java/org/wickra/SampleEntropy.java index 3db527c7..d64d3e64 100644 --- a/bindings/java/src/main/java/org/wickra/SampleEntropy.java +++ b/bindings/java/src/main/java/org/wickra/SampleEntropy.java @@ -57,6 +57,26 @@ public final class SampleEntropy implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SAMPLE_ENTROPY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SAMPLE_ENTROPY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SarExt.java b/bindings/java/src/main/java/org/wickra/SarExt.java index d59a8b00..83c01c8a 100644 --- a/bindings/java/src/main/java/org/wickra/SarExt.java +++ b/bindings/java/src/main/java/org/wickra/SarExt.java @@ -71,6 +71,26 @@ public final class SarExt implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SAR_EXT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SAR_EXT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SeasonalZScore.java b/bindings/java/src/main/java/org/wickra/SeasonalZScore.java index f1f285de..90a959ba 100644 --- a/bindings/java/src/main/java/org/wickra/SeasonalZScore.java +++ b/bindings/java/src/main/java/org/wickra/SeasonalZScore.java @@ -71,6 +71,26 @@ public final class SeasonalZScore implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SEASONAL_Z_SCORE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SEASONAL_Z_SCORE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SeparatingLines.java b/bindings/java/src/main/java/org/wickra/SeparatingLines.java index 05fe46a3..340ac5d1 100644 --- a/bindings/java/src/main/java/org/wickra/SeparatingLines.java +++ b/bindings/java/src/main/java/org/wickra/SeparatingLines.java @@ -71,6 +71,26 @@ public final class SeparatingLines implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SEPARATING_LINES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SEPARATING_LINES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SessionHighLow.java b/bindings/java/src/main/java/org/wickra/SessionHighLow.java index 9f9648b4..35b1cb17 100644 --- a/bindings/java/src/main/java/org/wickra/SessionHighLow.java +++ b/bindings/java/src/main/java/org/wickra/SessionHighLow.java @@ -43,6 +43,26 @@ public final class SessionHighLow implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SESSION_HIGH_LOW_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SESSION_HIGH_LOW_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SessionRange.java b/bindings/java/src/main/java/org/wickra/SessionRange.java index 6036597b..5e264c1f 100644 --- a/bindings/java/src/main/java/org/wickra/SessionRange.java +++ b/bindings/java/src/main/java/org/wickra/SessionRange.java @@ -44,6 +44,26 @@ public final class SessionRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SESSION_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SESSION_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SessionVwap.java b/bindings/java/src/main/java/org/wickra/SessionVwap.java index 588a0484..321ef974 100644 --- a/bindings/java/src/main/java/org/wickra/SessionVwap.java +++ b/bindings/java/src/main/java/org/wickra/SessionVwap.java @@ -71,6 +71,26 @@ public final class SessionVwap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SESSION_VWAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SESSION_VWAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ShannonEntropy.java b/bindings/java/src/main/java/org/wickra/ShannonEntropy.java index 87e8c795..ba9039a2 100644 --- a/bindings/java/src/main/java/org/wickra/ShannonEntropy.java +++ b/bindings/java/src/main/java/org/wickra/ShannonEntropy.java @@ -57,6 +57,26 @@ public final class ShannonEntropy implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SHANNON_ENTROPY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SHANNON_ENTROPY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Shark.java b/bindings/java/src/main/java/org/wickra/Shark.java index bdca1e79..a76992a1 100644 --- a/bindings/java/src/main/java/org/wickra/Shark.java +++ b/bindings/java/src/main/java/org/wickra/Shark.java @@ -71,6 +71,26 @@ public final class Shark implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SHARK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SHARK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SharpeRatio.java b/bindings/java/src/main/java/org/wickra/SharpeRatio.java index 353c6cb0..cbbe1ddc 100644 --- a/bindings/java/src/main/java/org/wickra/SharpeRatio.java +++ b/bindings/java/src/main/java/org/wickra/SharpeRatio.java @@ -54,6 +54,26 @@ public final class SharpeRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SHARPE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SHARPE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ShootingStar.java b/bindings/java/src/main/java/org/wickra/ShootingStar.java index 539d422c..11579429 100644 --- a/bindings/java/src/main/java/org/wickra/ShootingStar.java +++ b/bindings/java/src/main/java/org/wickra/ShootingStar.java @@ -71,6 +71,26 @@ public final class ShootingStar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SHOOTING_STAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SHOOTING_STAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ShortLine.java b/bindings/java/src/main/java/org/wickra/ShortLine.java index 5ba4063d..243b38b0 100644 --- a/bindings/java/src/main/java/org/wickra/ShortLine.java +++ b/bindings/java/src/main/java/org/wickra/ShortLine.java @@ -71,6 +71,26 @@ public final class ShortLine implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SHORT_LINE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SHORT_LINE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SignedVolume.java b/bindings/java/src/main/java/org/wickra/SignedVolume.java index 053e526d..5fb892e3 100644 --- a/bindings/java/src/main/java/org/wickra/SignedVolume.java +++ b/bindings/java/src/main/java/org/wickra/SignedVolume.java @@ -36,6 +36,26 @@ public final class SignedVolume implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SIGNED_VOLUME_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SIGNED_VOLUME_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SineWave.java b/bindings/java/src/main/java/org/wickra/SineWave.java index 331841ae..3126e211 100644 --- a/bindings/java/src/main/java/org/wickra/SineWave.java +++ b/bindings/java/src/main/java/org/wickra/SineWave.java @@ -51,6 +51,26 @@ public final class SineWave implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SINE_WAVE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SINE_WAVE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SineWeightedMa.java b/bindings/java/src/main/java/org/wickra/SineWeightedMa.java index 2b81e81a..e3a6a0b9 100644 --- a/bindings/java/src/main/java/org/wickra/SineWeightedMa.java +++ b/bindings/java/src/main/java/org/wickra/SineWeightedMa.java @@ -54,6 +54,26 @@ public final class SineWeightedMa implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SINE_WEIGHTED_MA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SINE_WEIGHTED_MA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SinglePrints.java b/bindings/java/src/main/java/org/wickra/SinglePrints.java index bf764be3..79486929 100644 --- a/bindings/java/src/main/java/org/wickra/SinglePrints.java +++ b/bindings/java/src/main/java/org/wickra/SinglePrints.java @@ -77,6 +77,26 @@ public final class SinglePrints implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SINGLE_PRINTS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SINGLE_PRINTS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Skewness.java b/bindings/java/src/main/java/org/wickra/Skewness.java index 76d0b2fa..02d05993 100644 --- a/bindings/java/src/main/java/org/wickra/Skewness.java +++ b/bindings/java/src/main/java/org/wickra/Skewness.java @@ -54,6 +54,26 @@ public final class Skewness implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SKEWNESS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SKEWNESS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Sma.java b/bindings/java/src/main/java/org/wickra/Sma.java index c607acf7..106db6a0 100644 --- a/bindings/java/src/main/java/org/wickra/Sma.java +++ b/bindings/java/src/main/java/org/wickra/Sma.java @@ -54,6 +54,26 @@ public final class Sma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Smi.java b/bindings/java/src/main/java/org/wickra/Smi.java index 9279e134..34a5b06a 100644 --- a/bindings/java/src/main/java/org/wickra/Smi.java +++ b/bindings/java/src/main/java/org/wickra/Smi.java @@ -80,6 +80,26 @@ public final class Smi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SMI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SMI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Smma.java b/bindings/java/src/main/java/org/wickra/Smma.java index 6d446d01..b123dbc1 100644 --- a/bindings/java/src/main/java/org/wickra/Smma.java +++ b/bindings/java/src/main/java/org/wickra/Smma.java @@ -54,6 +54,26 @@ public final class Smma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SMMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SMMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SmoothedHeikinAshi.java b/bindings/java/src/main/java/org/wickra/SmoothedHeikinAshi.java index 8738e69c..fdf8a9cd 100644 --- a/bindings/java/src/main/java/org/wickra/SmoothedHeikinAshi.java +++ b/bindings/java/src/main/java/org/wickra/SmoothedHeikinAshi.java @@ -48,6 +48,26 @@ public final class SmoothedHeikinAshi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SMOOTHED_HEIKIN_ASHI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SMOOTHED_HEIKIN_ASHI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SortinoRatio.java b/bindings/java/src/main/java/org/wickra/SortinoRatio.java index 688234ae..21c88227 100644 --- a/bindings/java/src/main/java/org/wickra/SortinoRatio.java +++ b/bindings/java/src/main/java/org/wickra/SortinoRatio.java @@ -54,6 +54,26 @@ public final class SortinoRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SORTINO_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SORTINO_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SpearmanCorrelation.java b/bindings/java/src/main/java/org/wickra/SpearmanCorrelation.java index eaad0f76..1981c322 100644 --- a/bindings/java/src/main/java/org/wickra/SpearmanCorrelation.java +++ b/bindings/java/src/main/java/org/wickra/SpearmanCorrelation.java @@ -58,6 +58,26 @@ public final class SpearmanCorrelation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SPEARMAN_CORRELATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SPEARMAN_CORRELATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SpinningTop.java b/bindings/java/src/main/java/org/wickra/SpinningTop.java index 6535c069..ceb32d34 100644 --- a/bindings/java/src/main/java/org/wickra/SpinningTop.java +++ b/bindings/java/src/main/java/org/wickra/SpinningTop.java @@ -71,6 +71,26 @@ public final class SpinningTop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SPINNING_TOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SPINNING_TOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SpreadAr1Coefficient.java b/bindings/java/src/main/java/org/wickra/SpreadAr1Coefficient.java index 46ff2b7a..3234511c 100644 --- a/bindings/java/src/main/java/org/wickra/SpreadAr1Coefficient.java +++ b/bindings/java/src/main/java/org/wickra/SpreadAr1Coefficient.java @@ -58,6 +58,26 @@ public final class SpreadAr1Coefficient implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SPREAD_AR1_COEFFICIENT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SPREAD_AR1_COEFFICIENT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SpreadBollingerBands.java b/bindings/java/src/main/java/org/wickra/SpreadBollingerBands.java index 44dce188..dcbf69c0 100644 --- a/bindings/java/src/main/java/org/wickra/SpreadBollingerBands.java +++ b/bindings/java/src/main/java/org/wickra/SpreadBollingerBands.java @@ -48,6 +48,26 @@ public final class SpreadBollingerBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SPREAD_BOLLINGER_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SPREAD_BOLLINGER_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SpreadHurst.java b/bindings/java/src/main/java/org/wickra/SpreadHurst.java index e89afa6a..a6713578 100644 --- a/bindings/java/src/main/java/org/wickra/SpreadHurst.java +++ b/bindings/java/src/main/java/org/wickra/SpreadHurst.java @@ -58,6 +58,26 @@ public final class SpreadHurst implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SPREAD_HURST_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SPREAD_HURST_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StalledPattern.java b/bindings/java/src/main/java/org/wickra/StalledPattern.java index b3e99577..4ecf01a9 100644 --- a/bindings/java/src/main/java/org/wickra/StalledPattern.java +++ b/bindings/java/src/main/java/org/wickra/StalledPattern.java @@ -71,6 +71,26 @@ public final class StalledPattern implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STALLED_PATTERN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STALLED_PATTERN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StandardError.java b/bindings/java/src/main/java/org/wickra/StandardError.java index 70d2ce75..0d3a3ba0 100644 --- a/bindings/java/src/main/java/org/wickra/StandardError.java +++ b/bindings/java/src/main/java/org/wickra/StandardError.java @@ -54,6 +54,26 @@ public final class StandardError implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STANDARD_ERROR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STANDARD_ERROR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StandardErrorBands.java b/bindings/java/src/main/java/org/wickra/StandardErrorBands.java index 3dda7f1f..48ccddd6 100644 --- a/bindings/java/src/main/java/org/wickra/StandardErrorBands.java +++ b/bindings/java/src/main/java/org/wickra/StandardErrorBands.java @@ -47,6 +47,26 @@ public final class StandardErrorBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STANDARD_ERROR_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STANDARD_ERROR_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StarcBands.java b/bindings/java/src/main/java/org/wickra/StarcBands.java index 4ee6c79a..1b4806a0 100644 --- a/bindings/java/src/main/java/org/wickra/StarcBands.java +++ b/bindings/java/src/main/java/org/wickra/StarcBands.java @@ -50,6 +50,26 @@ public final class StarcBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STARC_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STARC_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Stc.java b/bindings/java/src/main/java/org/wickra/Stc.java index 7b9ccebb..e1cbcd67 100644 --- a/bindings/java/src/main/java/org/wickra/Stc.java +++ b/bindings/java/src/main/java/org/wickra/Stc.java @@ -60,6 +60,26 @@ public final class Stc implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StdDev.java b/bindings/java/src/main/java/org/wickra/StdDev.java index e1ea9859..a0596eb0 100644 --- a/bindings/java/src/main/java/org/wickra/StdDev.java +++ b/bindings/java/src/main/java/org/wickra/StdDev.java @@ -54,6 +54,26 @@ public final class StdDev implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STD_DEV_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STD_DEV_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StepTrailingStop.java b/bindings/java/src/main/java/org/wickra/StepTrailingStop.java index 18a7aeca..7979ff7f 100644 --- a/bindings/java/src/main/java/org/wickra/StepTrailingStop.java +++ b/bindings/java/src/main/java/org/wickra/StepTrailingStop.java @@ -51,6 +51,26 @@ public final class StepTrailingStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STEP_TRAILING_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STEP_TRAILING_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SterlingRatio.java b/bindings/java/src/main/java/org/wickra/SterlingRatio.java index 8714008e..c9332bbb 100644 --- a/bindings/java/src/main/java/org/wickra/SterlingRatio.java +++ b/bindings/java/src/main/java/org/wickra/SterlingRatio.java @@ -54,6 +54,26 @@ public final class SterlingRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STERLING_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STERLING_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StickSandwich.java b/bindings/java/src/main/java/org/wickra/StickSandwich.java index 8b204e2c..b77f6efc 100644 --- a/bindings/java/src/main/java/org/wickra/StickSandwich.java +++ b/bindings/java/src/main/java/org/wickra/StickSandwich.java @@ -71,6 +71,26 @@ public final class StickSandwich implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STICK_SANDWICH_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STICK_SANDWICH_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StochRsi.java b/bindings/java/src/main/java/org/wickra/StochRsi.java index 527a92c1..528850ac 100644 --- a/bindings/java/src/main/java/org/wickra/StochRsi.java +++ b/bindings/java/src/main/java/org/wickra/StochRsi.java @@ -57,6 +57,26 @@ public final class StochRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STOCH_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STOCH_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Stochastic.java b/bindings/java/src/main/java/org/wickra/Stochastic.java index 170cb1fe..9b97c1d9 100644 --- a/bindings/java/src/main/java/org/wickra/Stochastic.java +++ b/bindings/java/src/main/java/org/wickra/Stochastic.java @@ -49,6 +49,26 @@ public final class Stochastic implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STOCHASTIC_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STOCHASTIC_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/StochasticCci.java b/bindings/java/src/main/java/org/wickra/StochasticCci.java index e744e391..b96b583e 100644 --- a/bindings/java/src/main/java/org/wickra/StochasticCci.java +++ b/bindings/java/src/main/java/org/wickra/StochasticCci.java @@ -74,6 +74,26 @@ public final class StochasticCci implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_STOCHASTIC_CCI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_STOCHASTIC_CCI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SuperSmoother.java b/bindings/java/src/main/java/org/wickra/SuperSmoother.java index cf4223da..48dbc68b 100644 --- a/bindings/java/src/main/java/org/wickra/SuperSmoother.java +++ b/bindings/java/src/main/java/org/wickra/SuperSmoother.java @@ -54,6 +54,26 @@ public final class SuperSmoother implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SUPER_SMOOTHER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SUPER_SMOOTHER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/SuperTrend.java b/bindings/java/src/main/java/org/wickra/SuperTrend.java index ef46179d..53019b65 100644 --- a/bindings/java/src/main/java/org/wickra/SuperTrend.java +++ b/bindings/java/src/main/java/org/wickra/SuperTrend.java @@ -46,6 +46,26 @@ public final class SuperTrend implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_SUPER_TREND_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_SUPER_TREND_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/T3.java b/bindings/java/src/main/java/org/wickra/T3.java index 138f48a8..114218f7 100644 --- a/bindings/java/src/main/java/org/wickra/T3.java +++ b/bindings/java/src/main/java/org/wickra/T3.java @@ -54,6 +54,26 @@ public final class T3 implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_T3_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_T3_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TailRatio.java b/bindings/java/src/main/java/org/wickra/TailRatio.java index b66b9993..9f55dd79 100644 --- a/bindings/java/src/main/java/org/wickra/TailRatio.java +++ b/bindings/java/src/main/java/org/wickra/TailRatio.java @@ -54,6 +54,26 @@ public final class TailRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TAIL_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TAIL_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TakerBuySellRatio.java b/bindings/java/src/main/java/org/wickra/TakerBuySellRatio.java index be2aaba6..78ff2443 100644 --- a/bindings/java/src/main/java/org/wickra/TakerBuySellRatio.java +++ b/bindings/java/src/main/java/org/wickra/TakerBuySellRatio.java @@ -36,6 +36,26 @@ public final class TakerBuySellRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TAKER_BUY_SELL_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TAKER_BUY_SELL_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Takuri.java b/bindings/java/src/main/java/org/wickra/Takuri.java index f2c452aa..fc0269bf 100644 --- a/bindings/java/src/main/java/org/wickra/Takuri.java +++ b/bindings/java/src/main/java/org/wickra/Takuri.java @@ -71,6 +71,26 @@ public final class Takuri implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TAKURI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TAKURI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TasukiGap.java b/bindings/java/src/main/java/org/wickra/TasukiGap.java index 8d3e7604..63800309 100644 --- a/bindings/java/src/main/java/org/wickra/TasukiGap.java +++ b/bindings/java/src/main/java/org/wickra/TasukiGap.java @@ -71,6 +71,26 @@ public final class TasukiGap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TASUKI_GAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TASUKI_GAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdCamouflage.java b/bindings/java/src/main/java/org/wickra/TdCamouflage.java index 63d0279f..3b56da19 100644 --- a/bindings/java/src/main/java/org/wickra/TdCamouflage.java +++ b/bindings/java/src/main/java/org/wickra/TdCamouflage.java @@ -71,6 +71,26 @@ public final class TdCamouflage implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_CAMOUFLAGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_CAMOUFLAGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdClop.java b/bindings/java/src/main/java/org/wickra/TdClop.java index 48c94fa8..a7ea9f92 100644 --- a/bindings/java/src/main/java/org/wickra/TdClop.java +++ b/bindings/java/src/main/java/org/wickra/TdClop.java @@ -71,6 +71,26 @@ public final class TdClop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_CLOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_CLOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdClopwin.java b/bindings/java/src/main/java/org/wickra/TdClopwin.java index 03f7beab..6daba005 100644 --- a/bindings/java/src/main/java/org/wickra/TdClopwin.java +++ b/bindings/java/src/main/java/org/wickra/TdClopwin.java @@ -71,6 +71,26 @@ public final class TdClopwin implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_CLOPWIN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_CLOPWIN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdCombo.java b/bindings/java/src/main/java/org/wickra/TdCombo.java index 33ff6e97..426312fe 100644 --- a/bindings/java/src/main/java/org/wickra/TdCombo.java +++ b/bindings/java/src/main/java/org/wickra/TdCombo.java @@ -83,6 +83,26 @@ public final class TdCombo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_COMBO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_COMBO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdCountdown.java b/bindings/java/src/main/java/org/wickra/TdCountdown.java index e0aa143a..b2145ecd 100644 --- a/bindings/java/src/main/java/org/wickra/TdCountdown.java +++ b/bindings/java/src/main/java/org/wickra/TdCountdown.java @@ -83,6 +83,26 @@ public final class TdCountdown implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_COUNTDOWN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_COUNTDOWN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdDWave.java b/bindings/java/src/main/java/org/wickra/TdDWave.java index 63f465d6..ae50b7ef 100644 --- a/bindings/java/src/main/java/org/wickra/TdDWave.java +++ b/bindings/java/src/main/java/org/wickra/TdDWave.java @@ -74,6 +74,26 @@ public final class TdDWave implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_D_WAVE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_D_WAVE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdDeMarker.java b/bindings/java/src/main/java/org/wickra/TdDeMarker.java index 3325e952..5226c0c1 100644 --- a/bindings/java/src/main/java/org/wickra/TdDeMarker.java +++ b/bindings/java/src/main/java/org/wickra/TdDeMarker.java @@ -74,6 +74,26 @@ public final class TdDeMarker implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_DE_MARKER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_DE_MARKER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdDifferential.java b/bindings/java/src/main/java/org/wickra/TdDifferential.java index 9d05d5eb..65cbd04c 100644 --- a/bindings/java/src/main/java/org/wickra/TdDifferential.java +++ b/bindings/java/src/main/java/org/wickra/TdDifferential.java @@ -71,6 +71,26 @@ public final class TdDifferential implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_DIFFERENTIAL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_DIFFERENTIAL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdLines.java b/bindings/java/src/main/java/org/wickra/TdLines.java index cc3fa57a..75f91758 100644 --- a/bindings/java/src/main/java/org/wickra/TdLines.java +++ b/bindings/java/src/main/java/org/wickra/TdLines.java @@ -49,6 +49,26 @@ public final class TdLines implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_LINES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_LINES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdMovingAverage.java b/bindings/java/src/main/java/org/wickra/TdMovingAverage.java index 8ac55e82..2a0af0cb 100644 --- a/bindings/java/src/main/java/org/wickra/TdMovingAverage.java +++ b/bindings/java/src/main/java/org/wickra/TdMovingAverage.java @@ -49,6 +49,26 @@ public final class TdMovingAverage implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_MOVING_AVERAGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_MOVING_AVERAGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdOpen.java b/bindings/java/src/main/java/org/wickra/TdOpen.java index 37c6dd0e..903ba335 100644 --- a/bindings/java/src/main/java/org/wickra/TdOpen.java +++ b/bindings/java/src/main/java/org/wickra/TdOpen.java @@ -71,6 +71,26 @@ public final class TdOpen implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_OPEN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_OPEN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdPressure.java b/bindings/java/src/main/java/org/wickra/TdPressure.java index ee05644f..b09a94ab 100644 --- a/bindings/java/src/main/java/org/wickra/TdPressure.java +++ b/bindings/java/src/main/java/org/wickra/TdPressure.java @@ -74,6 +74,26 @@ public final class TdPressure implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_PRESSURE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_PRESSURE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdPropulsion.java b/bindings/java/src/main/java/org/wickra/TdPropulsion.java index a7908d42..60ab468b 100644 --- a/bindings/java/src/main/java/org/wickra/TdPropulsion.java +++ b/bindings/java/src/main/java/org/wickra/TdPropulsion.java @@ -71,6 +71,26 @@ public final class TdPropulsion implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_PROPULSION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_PROPULSION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdRangeProjection.java b/bindings/java/src/main/java/org/wickra/TdRangeProjection.java index 585aa39b..59c84cb5 100644 --- a/bindings/java/src/main/java/org/wickra/TdRangeProjection.java +++ b/bindings/java/src/main/java/org/wickra/TdRangeProjection.java @@ -43,6 +43,26 @@ public final class TdRangeProjection implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_RANGE_PROJECTION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_RANGE_PROJECTION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdRei.java b/bindings/java/src/main/java/org/wickra/TdRei.java index 23fa1bbb..d46dbff5 100644 --- a/bindings/java/src/main/java/org/wickra/TdRei.java +++ b/bindings/java/src/main/java/org/wickra/TdRei.java @@ -74,6 +74,26 @@ public final class TdRei implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_REI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_REI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdRiskLevel.java b/bindings/java/src/main/java/org/wickra/TdRiskLevel.java index fe512458..50047edd 100644 --- a/bindings/java/src/main/java/org/wickra/TdRiskLevel.java +++ b/bindings/java/src/main/java/org/wickra/TdRiskLevel.java @@ -49,6 +49,26 @@ public final class TdRiskLevel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_RISK_LEVEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_RISK_LEVEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdSequential.java b/bindings/java/src/main/java/org/wickra/TdSequential.java index 76dc8e6e..f0efa1d4 100644 --- a/bindings/java/src/main/java/org/wickra/TdSequential.java +++ b/bindings/java/src/main/java/org/wickra/TdSequential.java @@ -56,6 +56,26 @@ public final class TdSequential implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_SEQUENTIAL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_SEQUENTIAL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdSetup.java b/bindings/java/src/main/java/org/wickra/TdSetup.java index 6f4eea77..7052a481 100644 --- a/bindings/java/src/main/java/org/wickra/TdSetup.java +++ b/bindings/java/src/main/java/org/wickra/TdSetup.java @@ -77,6 +77,26 @@ public final class TdSetup implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_SETUP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_SETUP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TdTrap.java b/bindings/java/src/main/java/org/wickra/TdTrap.java index ff69c5f6..8d993e3f 100644 --- a/bindings/java/src/main/java/org/wickra/TdTrap.java +++ b/bindings/java/src/main/java/org/wickra/TdTrap.java @@ -71,6 +71,26 @@ public final class TdTrap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TD_TRAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TD_TRAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tema.java b/bindings/java/src/main/java/org/wickra/Tema.java index cf66a33a..abba5509 100644 --- a/bindings/java/src/main/java/org/wickra/Tema.java +++ b/bindings/java/src/main/java/org/wickra/Tema.java @@ -54,6 +54,26 @@ public final class Tema implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TEMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TEMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TermStructureBasis.java b/bindings/java/src/main/java/org/wickra/TermStructureBasis.java index 788573fb..a35b973c 100644 --- a/bindings/java/src/main/java/org/wickra/TermStructureBasis.java +++ b/bindings/java/src/main/java/org/wickra/TermStructureBasis.java @@ -36,6 +36,26 @@ public final class TermStructureBasis implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TERM_STRUCTURE_BASIS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TERM_STRUCTURE_BASIS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeDrives.java b/bindings/java/src/main/java/org/wickra/ThreeDrives.java index a8eb807d..cd5e7cac 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeDrives.java +++ b/bindings/java/src/main/java/org/wickra/ThreeDrives.java @@ -71,6 +71,26 @@ public final class ThreeDrives implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_DRIVES_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_DRIVES_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeInside.java b/bindings/java/src/main/java/org/wickra/ThreeInside.java index 882915d8..b5c1d328 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeInside.java +++ b/bindings/java/src/main/java/org/wickra/ThreeInside.java @@ -71,6 +71,26 @@ public final class ThreeInside implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_INSIDE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_INSIDE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeLineBreak.java b/bindings/java/src/main/java/org/wickra/ThreeLineBreak.java index fc957801..40e5163c 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeLineBreak.java +++ b/bindings/java/src/main/java/org/wickra/ThreeLineBreak.java @@ -74,6 +74,26 @@ public final class ThreeLineBreak implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_LINE_BREAK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_LINE_BREAK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeLineStrike.java b/bindings/java/src/main/java/org/wickra/ThreeLineStrike.java index 2569496c..810bddbf 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeLineStrike.java +++ b/bindings/java/src/main/java/org/wickra/ThreeLineStrike.java @@ -71,6 +71,26 @@ public final class ThreeLineStrike implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_LINE_STRIKE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_LINE_STRIKE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeOutside.java b/bindings/java/src/main/java/org/wickra/ThreeOutside.java index f41bb0cc..5a64ae70 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeOutside.java +++ b/bindings/java/src/main/java/org/wickra/ThreeOutside.java @@ -71,6 +71,26 @@ public final class ThreeOutside implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_OUTSIDE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_OUTSIDE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeSoldiersOrCrows.java b/bindings/java/src/main/java/org/wickra/ThreeSoldiersOrCrows.java index e114e314..6cec0729 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeSoldiersOrCrows.java +++ b/bindings/java/src/main/java/org/wickra/ThreeSoldiersOrCrows.java @@ -71,6 +71,26 @@ public final class ThreeSoldiersOrCrows implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_SOLDIERS_OR_CROWS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_SOLDIERS_OR_CROWS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ThreeStarsInSouth.java b/bindings/java/src/main/java/org/wickra/ThreeStarsInSouth.java index 2d9a3be5..952879c0 100644 --- a/bindings/java/src/main/java/org/wickra/ThreeStarsInSouth.java +++ b/bindings/java/src/main/java/org/wickra/ThreeStarsInSouth.java @@ -71,6 +71,26 @@ public final class ThreeStarsInSouth implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THREE_STARS_IN_SOUTH_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THREE_STARS_IN_SOUTH_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Thrusting.java b/bindings/java/src/main/java/org/wickra/Thrusting.java index ae881aeb..5b749b1d 100644 --- a/bindings/java/src/main/java/org/wickra/Thrusting.java +++ b/bindings/java/src/main/java/org/wickra/Thrusting.java @@ -71,6 +71,26 @@ public final class Thrusting implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_THRUSTING_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_THRUSTING_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TickIndex.java b/bindings/java/src/main/java/org/wickra/TickIndex.java index ee341179..47703f15 100644 --- a/bindings/java/src/main/java/org/wickra/TickIndex.java +++ b/bindings/java/src/main/java/org/wickra/TickIndex.java @@ -57,6 +57,26 @@ public final class TickIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TICK_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TICK_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tii.java b/bindings/java/src/main/java/org/wickra/Tii.java index 9094621b..3657ae33 100644 --- a/bindings/java/src/main/java/org/wickra/Tii.java +++ b/bindings/java/src/main/java/org/wickra/Tii.java @@ -57,6 +57,26 @@ public final class Tii implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TII_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TII_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TimeBasedStop.java b/bindings/java/src/main/java/org/wickra/TimeBasedStop.java index 5e082d6a..fff73752 100644 --- a/bindings/java/src/main/java/org/wickra/TimeBasedStop.java +++ b/bindings/java/src/main/java/org/wickra/TimeBasedStop.java @@ -74,6 +74,26 @@ public final class TimeBasedStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TIME_BASED_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TIME_BASED_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TimeOfDayReturnProfile.java b/bindings/java/src/main/java/org/wickra/TimeOfDayReturnProfile.java index 8375de3b..859eaa6f 100644 --- a/bindings/java/src/main/java/org/wickra/TimeOfDayReturnProfile.java +++ b/bindings/java/src/main/java/org/wickra/TimeOfDayReturnProfile.java @@ -50,6 +50,26 @@ public final class TimeOfDayReturnProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TIME_OF_DAY_RETURN_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TIME_OF_DAY_RETURN_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TowerTopBottom.java b/bindings/java/src/main/java/org/wickra/TowerTopBottom.java index e15ec4ac..6eeaa3ce 100644 --- a/bindings/java/src/main/java/org/wickra/TowerTopBottom.java +++ b/bindings/java/src/main/java/org/wickra/TowerTopBottom.java @@ -71,6 +71,26 @@ public final class TowerTopBottom implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TOWER_TOP_BOTTOM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TOWER_TOP_BOTTOM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TpoProfile.java b/bindings/java/src/main/java/org/wickra/TpoProfile.java index e3e4f8c0..2ffea586 100644 --- a/bindings/java/src/main/java/org/wickra/TpoProfile.java +++ b/bindings/java/src/main/java/org/wickra/TpoProfile.java @@ -57,6 +57,26 @@ public final class TpoProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TPO_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TPO_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TradeImbalance.java b/bindings/java/src/main/java/org/wickra/TradeImbalance.java index 9b44463f..2b150ee1 100644 --- a/bindings/java/src/main/java/org/wickra/TradeImbalance.java +++ b/bindings/java/src/main/java/org/wickra/TradeImbalance.java @@ -39,6 +39,26 @@ public final class TradeImbalance implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRADE_IMBALANCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRADE_IMBALANCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TradeSignAutocorrelation.java b/bindings/java/src/main/java/org/wickra/TradeSignAutocorrelation.java index 29a31c00..1a414a81 100644 --- a/bindings/java/src/main/java/org/wickra/TradeSignAutocorrelation.java +++ b/bindings/java/src/main/java/org/wickra/TradeSignAutocorrelation.java @@ -39,6 +39,26 @@ public final class TradeSignAutocorrelation implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRADE_SIGN_AUTOCORRELATION_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRADE_SIGN_AUTOCORRELATION_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TradeVolumeIndex.java b/bindings/java/src/main/java/org/wickra/TradeVolumeIndex.java index ccaff06d..13a54064 100644 --- a/bindings/java/src/main/java/org/wickra/TradeVolumeIndex.java +++ b/bindings/java/src/main/java/org/wickra/TradeVolumeIndex.java @@ -71,6 +71,26 @@ public final class TradeVolumeIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRADE_VOLUME_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRADE_VOLUME_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TrendLabel.java b/bindings/java/src/main/java/org/wickra/TrendLabel.java index 918ee5e7..7f164f67 100644 --- a/bindings/java/src/main/java/org/wickra/TrendLabel.java +++ b/bindings/java/src/main/java/org/wickra/TrendLabel.java @@ -54,6 +54,26 @@ public final class TrendLabel implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TREND_LABEL_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TREND_LABEL_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TrendStrengthIndex.java b/bindings/java/src/main/java/org/wickra/TrendStrengthIndex.java index 000183c0..37670cfd 100644 --- a/bindings/java/src/main/java/org/wickra/TrendStrengthIndex.java +++ b/bindings/java/src/main/java/org/wickra/TrendStrengthIndex.java @@ -54,6 +54,26 @@ public final class TrendStrengthIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TREND_STRENGTH_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TREND_STRENGTH_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Trendflex.java b/bindings/java/src/main/java/org/wickra/Trendflex.java index e8bf62b8..33be3e09 100644 --- a/bindings/java/src/main/java/org/wickra/Trendflex.java +++ b/bindings/java/src/main/java/org/wickra/Trendflex.java @@ -54,6 +54,26 @@ public final class Trendflex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRENDFLEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRENDFLEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TreynorRatio.java b/bindings/java/src/main/java/org/wickra/TreynorRatio.java index 0bff32d5..122f9e59 100644 --- a/bindings/java/src/main/java/org/wickra/TreynorRatio.java +++ b/bindings/java/src/main/java/org/wickra/TreynorRatio.java @@ -58,6 +58,26 @@ public final class TreynorRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TREYNOR_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TREYNOR_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Triangle.java b/bindings/java/src/main/java/org/wickra/Triangle.java index 4d0b22e0..9968d609 100644 --- a/bindings/java/src/main/java/org/wickra/Triangle.java +++ b/bindings/java/src/main/java/org/wickra/Triangle.java @@ -71,6 +71,26 @@ public final class Triangle implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRIANGLE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRIANGLE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Trima.java b/bindings/java/src/main/java/org/wickra/Trima.java index 77ffd17d..9d4e9ecb 100644 --- a/bindings/java/src/main/java/org/wickra/Trima.java +++ b/bindings/java/src/main/java/org/wickra/Trima.java @@ -54,6 +54,26 @@ public final class Trima implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRIMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRIMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Trin.java b/bindings/java/src/main/java/org/wickra/Trin.java index 06c1bb82..7c014083 100644 --- a/bindings/java/src/main/java/org/wickra/Trin.java +++ b/bindings/java/src/main/java/org/wickra/Trin.java @@ -57,6 +57,26 @@ public final class Trin implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRIN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRIN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TripleTopBottom.java b/bindings/java/src/main/java/org/wickra/TripleTopBottom.java index 11dca419..e497e29d 100644 --- a/bindings/java/src/main/java/org/wickra/TripleTopBottom.java +++ b/bindings/java/src/main/java/org/wickra/TripleTopBottom.java @@ -71,6 +71,26 @@ public final class TripleTopBottom implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRIPLE_TOP_BOTTOM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRIPLE_TOP_BOTTOM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tristar.java b/bindings/java/src/main/java/org/wickra/Tristar.java index 4db23086..116b2652 100644 --- a/bindings/java/src/main/java/org/wickra/Tristar.java +++ b/bindings/java/src/main/java/org/wickra/Tristar.java @@ -71,6 +71,26 @@ public final class Tristar implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRISTAR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRISTAR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Trix.java b/bindings/java/src/main/java/org/wickra/Trix.java index 0cbbcafd..091adf71 100644 --- a/bindings/java/src/main/java/org/wickra/Trix.java +++ b/bindings/java/src/main/java/org/wickra/Trix.java @@ -54,6 +54,26 @@ public final class Trix implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRIX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRIX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TrueRange.java b/bindings/java/src/main/java/org/wickra/TrueRange.java index 1356ece0..98948650 100644 --- a/bindings/java/src/main/java/org/wickra/TrueRange.java +++ b/bindings/java/src/main/java/org/wickra/TrueRange.java @@ -71,6 +71,26 @@ public final class TrueRange implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TRUE_RANGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TRUE_RANGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tsf.java b/bindings/java/src/main/java/org/wickra/Tsf.java index cbd6580c..5a977ce9 100644 --- a/bindings/java/src/main/java/org/wickra/Tsf.java +++ b/bindings/java/src/main/java/org/wickra/Tsf.java @@ -54,6 +54,26 @@ public final class Tsf implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TSF_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TSF_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TsfOscillator.java b/bindings/java/src/main/java/org/wickra/TsfOscillator.java index 9308fd6d..26ef42a1 100644 --- a/bindings/java/src/main/java/org/wickra/TsfOscillator.java +++ b/bindings/java/src/main/java/org/wickra/TsfOscillator.java @@ -54,6 +54,26 @@ public final class TsfOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TSF_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TSF_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tsi.java b/bindings/java/src/main/java/org/wickra/Tsi.java index 29f33911..82583b69 100644 --- a/bindings/java/src/main/java/org/wickra/Tsi.java +++ b/bindings/java/src/main/java/org/wickra/Tsi.java @@ -57,6 +57,26 @@ public final class Tsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tsv.java b/bindings/java/src/main/java/org/wickra/Tsv.java index 9d639d2a..bdb99e74 100644 --- a/bindings/java/src/main/java/org/wickra/Tsv.java +++ b/bindings/java/src/main/java/org/wickra/Tsv.java @@ -74,6 +74,26 @@ public final class Tsv implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TSV_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TSV_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TtmSqueeze.java b/bindings/java/src/main/java/org/wickra/TtmSqueeze.java index e1475fdb..cbbf2578 100644 --- a/bindings/java/src/main/java/org/wickra/TtmSqueeze.java +++ b/bindings/java/src/main/java/org/wickra/TtmSqueeze.java @@ -46,6 +46,26 @@ public final class TtmSqueeze implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TTM_SQUEEZE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TTM_SQUEEZE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TtmTrend.java b/bindings/java/src/main/java/org/wickra/TtmTrend.java index 6233eb03..29d435b3 100644 --- a/bindings/java/src/main/java/org/wickra/TtmTrend.java +++ b/bindings/java/src/main/java/org/wickra/TtmTrend.java @@ -74,6 +74,26 @@ public final class TtmTrend implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TTM_TREND_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TTM_TREND_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TurnOfMonth.java b/bindings/java/src/main/java/org/wickra/TurnOfMonth.java index a574843e..d31fd1b2 100644 --- a/bindings/java/src/main/java/org/wickra/TurnOfMonth.java +++ b/bindings/java/src/main/java/org/wickra/TurnOfMonth.java @@ -71,6 +71,26 @@ public final class TurnOfMonth implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TURN_OF_MONTH_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TURN_OF_MONTH_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Tweezer.java b/bindings/java/src/main/java/org/wickra/Tweezer.java index f7ec03fc..805e2977 100644 --- a/bindings/java/src/main/java/org/wickra/Tweezer.java +++ b/bindings/java/src/main/java/org/wickra/Tweezer.java @@ -71,6 +71,26 @@ public final class Tweezer implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TWEEZER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TWEEZER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TwiggsMoneyFlow.java b/bindings/java/src/main/java/org/wickra/TwiggsMoneyFlow.java index 568e3741..00f5ca21 100644 --- a/bindings/java/src/main/java/org/wickra/TwiggsMoneyFlow.java +++ b/bindings/java/src/main/java/org/wickra/TwiggsMoneyFlow.java @@ -74,6 +74,26 @@ public final class TwiggsMoneyFlow implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TWIGGS_MONEY_FLOW_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TWIGGS_MONEY_FLOW_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TwoCrows.java b/bindings/java/src/main/java/org/wickra/TwoCrows.java index 75538530..1e7cd216 100644 --- a/bindings/java/src/main/java/org/wickra/TwoCrows.java +++ b/bindings/java/src/main/java/org/wickra/TwoCrows.java @@ -71,6 +71,26 @@ public final class TwoCrows implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TWO_CROWS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TWO_CROWS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/TypicalPrice.java b/bindings/java/src/main/java/org/wickra/TypicalPrice.java index e5b62758..b659717e 100644 --- a/bindings/java/src/main/java/org/wickra/TypicalPrice.java +++ b/bindings/java/src/main/java/org/wickra/TypicalPrice.java @@ -71,6 +71,26 @@ public final class TypicalPrice implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_TYPICAL_PRICE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_TYPICAL_PRICE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UlcerIndex.java b/bindings/java/src/main/java/org/wickra/UlcerIndex.java index d84a0877..279ce055 100644 --- a/bindings/java/src/main/java/org/wickra/UlcerIndex.java +++ b/bindings/java/src/main/java/org/wickra/UlcerIndex.java @@ -54,6 +54,26 @@ public final class UlcerIndex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ULCER_INDEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ULCER_INDEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UltimateOscillator.java b/bindings/java/src/main/java/org/wickra/UltimateOscillator.java index 5b526318..4af84221 100644 --- a/bindings/java/src/main/java/org/wickra/UltimateOscillator.java +++ b/bindings/java/src/main/java/org/wickra/UltimateOscillator.java @@ -80,6 +80,26 @@ public final class UltimateOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ULTIMATE_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ULTIMATE_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UniqueThreeRiver.java b/bindings/java/src/main/java/org/wickra/UniqueThreeRiver.java index 547601ab..0a5a6ce0 100644 --- a/bindings/java/src/main/java/org/wickra/UniqueThreeRiver.java +++ b/bindings/java/src/main/java/org/wickra/UniqueThreeRiver.java @@ -71,6 +71,26 @@ public final class UniqueThreeRiver implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_UNIQUE_THREE_RIVER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_UNIQUE_THREE_RIVER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UniversalOscillator.java b/bindings/java/src/main/java/org/wickra/UniversalOscillator.java index 22233034..d63bc139 100644 --- a/bindings/java/src/main/java/org/wickra/UniversalOscillator.java +++ b/bindings/java/src/main/java/org/wickra/UniversalOscillator.java @@ -54,6 +54,26 @@ public final class UniversalOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_UNIVERSAL_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_UNIVERSAL_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UpDownVolumeRatio.java b/bindings/java/src/main/java/org/wickra/UpDownVolumeRatio.java index 0ff5c585..775c97c2 100644 --- a/bindings/java/src/main/java/org/wickra/UpDownVolumeRatio.java +++ b/bindings/java/src/main/java/org/wickra/UpDownVolumeRatio.java @@ -57,6 +57,26 @@ public final class UpDownVolumeRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_UP_DOWN_VOLUME_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_UP_DOWN_VOLUME_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UpsideGapThreeMethods.java b/bindings/java/src/main/java/org/wickra/UpsideGapThreeMethods.java index c67f3e09..34981c16 100644 --- a/bindings/java/src/main/java/org/wickra/UpsideGapThreeMethods.java +++ b/bindings/java/src/main/java/org/wickra/UpsideGapThreeMethods.java @@ -71,6 +71,26 @@ public final class UpsideGapThreeMethods implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_UPSIDE_GAP_THREE_METHODS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_UPSIDE_GAP_THREE_METHODS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UpsideGapTwoCrows.java b/bindings/java/src/main/java/org/wickra/UpsideGapTwoCrows.java index d217399e..8e07c9ea 100644 --- a/bindings/java/src/main/java/org/wickra/UpsideGapTwoCrows.java +++ b/bindings/java/src/main/java/org/wickra/UpsideGapTwoCrows.java @@ -71,6 +71,26 @@ public final class UpsideGapTwoCrows implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_UPSIDE_GAP_TWO_CROWS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_UPSIDE_GAP_TWO_CROWS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/UpsidePotentialRatio.java b/bindings/java/src/main/java/org/wickra/UpsidePotentialRatio.java index ca2bd888..1587f3f8 100644 --- a/bindings/java/src/main/java/org/wickra/UpsidePotentialRatio.java +++ b/bindings/java/src/main/java/org/wickra/UpsidePotentialRatio.java @@ -54,6 +54,26 @@ public final class UpsidePotentialRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_UPSIDE_POTENTIAL_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_UPSIDE_POTENTIAL_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ValueArea.java b/bindings/java/src/main/java/org/wickra/ValueArea.java index a7c39bd6..359bd049 100644 --- a/bindings/java/src/main/java/org/wickra/ValueArea.java +++ b/bindings/java/src/main/java/org/wickra/ValueArea.java @@ -50,6 +50,26 @@ public final class ValueArea implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VALUE_AREA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VALUE_AREA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ValueAtRisk.java b/bindings/java/src/main/java/org/wickra/ValueAtRisk.java index 2957396f..5fffce4c 100644 --- a/bindings/java/src/main/java/org/wickra/ValueAtRisk.java +++ b/bindings/java/src/main/java/org/wickra/ValueAtRisk.java @@ -54,6 +54,26 @@ public final class ValueAtRisk implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VALUE_AT_RISK_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VALUE_AT_RISK_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Variance.java b/bindings/java/src/main/java/org/wickra/Variance.java index 96f445a0..c79c00e3 100644 --- a/bindings/java/src/main/java/org/wickra/Variance.java +++ b/bindings/java/src/main/java/org/wickra/Variance.java @@ -54,6 +54,26 @@ public final class Variance implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VARIANCE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VARIANCE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VarianceRatio.java b/bindings/java/src/main/java/org/wickra/VarianceRatio.java index 60e90771..980d3288 100644 --- a/bindings/java/src/main/java/org/wickra/VarianceRatio.java +++ b/bindings/java/src/main/java/org/wickra/VarianceRatio.java @@ -61,6 +61,26 @@ public final class VarianceRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VARIANCE_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VARIANCE_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VerticalHorizontalFilter.java b/bindings/java/src/main/java/org/wickra/VerticalHorizontalFilter.java index 1afabd65..2a9872e8 100644 --- a/bindings/java/src/main/java/org/wickra/VerticalHorizontalFilter.java +++ b/bindings/java/src/main/java/org/wickra/VerticalHorizontalFilter.java @@ -54,6 +54,26 @@ public final class VerticalHorizontalFilter implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VERTICAL_HORIZONTAL_FILTER_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VERTICAL_HORIZONTAL_FILTER_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Vidya.java b/bindings/java/src/main/java/org/wickra/Vidya.java index eaeaa6cc..7e9578d9 100644 --- a/bindings/java/src/main/java/org/wickra/Vidya.java +++ b/bindings/java/src/main/java/org/wickra/Vidya.java @@ -57,6 +57,26 @@ public final class Vidya implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VIDYA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VIDYA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolatilityCone.java b/bindings/java/src/main/java/org/wickra/VolatilityCone.java index 62456a8d..9c1d5007 100644 --- a/bindings/java/src/main/java/org/wickra/VolatilityCone.java +++ b/bindings/java/src/main/java/org/wickra/VolatilityCone.java @@ -52,6 +52,26 @@ public final class VolatilityCone implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLATILITY_CONE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLATILITY_CONE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolatilityOfVolatility.java b/bindings/java/src/main/java/org/wickra/VolatilityOfVolatility.java index a40da83c..e767bf37 100644 --- a/bindings/java/src/main/java/org/wickra/VolatilityOfVolatility.java +++ b/bindings/java/src/main/java/org/wickra/VolatilityOfVolatility.java @@ -57,6 +57,26 @@ public final class VolatilityOfVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLATILITY_OF_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLATILITY_OF_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolatilityRatio.java b/bindings/java/src/main/java/org/wickra/VolatilityRatio.java index e0ac7be2..4282dacb 100644 --- a/bindings/java/src/main/java/org/wickra/VolatilityRatio.java +++ b/bindings/java/src/main/java/org/wickra/VolatilityRatio.java @@ -74,6 +74,26 @@ public final class VolatilityRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLATILITY_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLATILITY_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VoltyStop.java b/bindings/java/src/main/java/org/wickra/VoltyStop.java index 1c7e7b62..ea37f95b 100644 --- a/bindings/java/src/main/java/org/wickra/VoltyStop.java +++ b/bindings/java/src/main/java/org/wickra/VoltyStop.java @@ -74,6 +74,26 @@ public final class VoltyStop implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLTY_STOP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLTY_STOP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumeByTimeProfile.java b/bindings/java/src/main/java/org/wickra/VolumeByTimeProfile.java index 39677589..12f0cce3 100644 --- a/bindings/java/src/main/java/org/wickra/VolumeByTimeProfile.java +++ b/bindings/java/src/main/java/org/wickra/VolumeByTimeProfile.java @@ -50,6 +50,26 @@ public final class VolumeByTimeProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_BY_TIME_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_BY_TIME_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumeOscillator.java b/bindings/java/src/main/java/org/wickra/VolumeOscillator.java index 6699b84b..642528e9 100644 --- a/bindings/java/src/main/java/org/wickra/VolumeOscillator.java +++ b/bindings/java/src/main/java/org/wickra/VolumeOscillator.java @@ -77,6 +77,26 @@ public final class VolumeOscillator implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_OSCILLATOR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_OSCILLATOR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumePriceTrend.java b/bindings/java/src/main/java/org/wickra/VolumePriceTrend.java index ac3a2ac9..ef72bd78 100644 --- a/bindings/java/src/main/java/org/wickra/VolumePriceTrend.java +++ b/bindings/java/src/main/java/org/wickra/VolumePriceTrend.java @@ -71,6 +71,26 @@ public final class VolumePriceTrend implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_PRICE_TREND_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_PRICE_TREND_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumeProfile.java b/bindings/java/src/main/java/org/wickra/VolumeProfile.java index a49263b9..3ebbd2c4 100644 --- a/bindings/java/src/main/java/org/wickra/VolumeProfile.java +++ b/bindings/java/src/main/java/org/wickra/VolumeProfile.java @@ -57,6 +57,26 @@ public final class VolumeProfile implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_PROFILE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_PROFILE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumeRsi.java b/bindings/java/src/main/java/org/wickra/VolumeRsi.java index 192832d9..e17f235f 100644 --- a/bindings/java/src/main/java/org/wickra/VolumeRsi.java +++ b/bindings/java/src/main/java/org/wickra/VolumeRsi.java @@ -74,6 +74,26 @@ public final class VolumeRsi implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_RSI_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_RSI_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumeWeightedMacd.java b/bindings/java/src/main/java/org/wickra/VolumeWeightedMacd.java index 9cc5f172..c74f7fe7 100644 --- a/bindings/java/src/main/java/org/wickra/VolumeWeightedMacd.java +++ b/bindings/java/src/main/java/org/wickra/VolumeWeightedMacd.java @@ -53,6 +53,26 @@ public final class VolumeWeightedMacd implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_WEIGHTED_MACD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_WEIGHTED_MACD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VolumeWeightedSr.java b/bindings/java/src/main/java/org/wickra/VolumeWeightedSr.java index 4fa32598..1fd59525 100644 --- a/bindings/java/src/main/java/org/wickra/VolumeWeightedSr.java +++ b/bindings/java/src/main/java/org/wickra/VolumeWeightedSr.java @@ -46,6 +46,26 @@ public final class VolumeWeightedSr implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VOLUME_WEIGHTED_SR_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VOLUME_WEIGHTED_SR_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Vortex.java b/bindings/java/src/main/java/org/wickra/Vortex.java index 884b2a58..638aa83e 100644 --- a/bindings/java/src/main/java/org/wickra/Vortex.java +++ b/bindings/java/src/main/java/org/wickra/Vortex.java @@ -46,6 +46,26 @@ public final class Vortex implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VORTEX_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VORTEX_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Vpin.java b/bindings/java/src/main/java/org/wickra/Vpin.java index e144bbb2..2a5643a9 100644 --- a/bindings/java/src/main/java/org/wickra/Vpin.java +++ b/bindings/java/src/main/java/org/wickra/Vpin.java @@ -39,6 +39,26 @@ public final class Vpin implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VPIN_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VPIN_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Vwap.java b/bindings/java/src/main/java/org/wickra/Vwap.java index 406ebb2e..d23af480 100644 --- a/bindings/java/src/main/java/org/wickra/Vwap.java +++ b/bindings/java/src/main/java/org/wickra/Vwap.java @@ -71,6 +71,26 @@ public final class Vwap implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VWAP_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VWAP_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/VwapStdDevBands.java b/bindings/java/src/main/java/org/wickra/VwapStdDevBands.java index 052f7f11..0cfdfbba 100644 --- a/bindings/java/src/main/java/org/wickra/VwapStdDevBands.java +++ b/bindings/java/src/main/java/org/wickra/VwapStdDevBands.java @@ -45,6 +45,26 @@ public final class VwapStdDevBands implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VWAP_STD_DEV_BANDS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VWAP_STD_DEV_BANDS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Vwma.java b/bindings/java/src/main/java/org/wickra/Vwma.java index 3bc764a3..f5f15215 100644 --- a/bindings/java/src/main/java/org/wickra/Vwma.java +++ b/bindings/java/src/main/java/org/wickra/Vwma.java @@ -74,6 +74,26 @@ public final class Vwma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VWMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VWMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Vzo.java b/bindings/java/src/main/java/org/wickra/Vzo.java index 21d71a8e..76f1fca4 100644 --- a/bindings/java/src/main/java/org/wickra/Vzo.java +++ b/bindings/java/src/main/java/org/wickra/Vzo.java @@ -74,6 +74,26 @@ public final class Vzo implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_VZO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_VZO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Wad.java b/bindings/java/src/main/java/org/wickra/Wad.java index b6e73843..e6de19d3 100644 --- a/bindings/java/src/main/java/org/wickra/Wad.java +++ b/bindings/java/src/main/java/org/wickra/Wad.java @@ -71,6 +71,26 @@ public final class Wad implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WAD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WAD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WavePm.java b/bindings/java/src/main/java/org/wickra/WavePm.java index d8c3832a..cf9336b8 100644 --- a/bindings/java/src/main/java/org/wickra/WavePm.java +++ b/bindings/java/src/main/java/org/wickra/WavePm.java @@ -57,6 +57,26 @@ public final class WavePm implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WAVE_PM_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WAVE_PM_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WaveTrend.java b/bindings/java/src/main/java/org/wickra/WaveTrend.java index 196feec2..2bc3cc79 100644 --- a/bindings/java/src/main/java/org/wickra/WaveTrend.java +++ b/bindings/java/src/main/java/org/wickra/WaveTrend.java @@ -52,6 +52,26 @@ public final class WaveTrend implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WAVE_TREND_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WAVE_TREND_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Wedge.java b/bindings/java/src/main/java/org/wickra/Wedge.java index 00f08635..58c9fb8a 100644 --- a/bindings/java/src/main/java/org/wickra/Wedge.java +++ b/bindings/java/src/main/java/org/wickra/Wedge.java @@ -71,6 +71,26 @@ public final class Wedge implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WEDGE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WEDGE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WeightedClose.java b/bindings/java/src/main/java/org/wickra/WeightedClose.java index 52d461e0..a09090e1 100644 --- a/bindings/java/src/main/java/org/wickra/WeightedClose.java +++ b/bindings/java/src/main/java/org/wickra/WeightedClose.java @@ -71,6 +71,26 @@ public final class WeightedClose implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WEIGHTED_CLOSE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WEIGHTED_CLOSE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WickRatio.java b/bindings/java/src/main/java/org/wickra/WickRatio.java index cee0599d..aadb3a0b 100644 --- a/bindings/java/src/main/java/org/wickra/WickRatio.java +++ b/bindings/java/src/main/java/org/wickra/WickRatio.java @@ -71,6 +71,26 @@ public final class WickRatio implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WICK_RATIO_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WICK_RATIO_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WilliamsFractals.java b/bindings/java/src/main/java/org/wickra/WilliamsFractals.java index fe7efa1b..45c31f3b 100644 --- a/bindings/java/src/main/java/org/wickra/WilliamsFractals.java +++ b/bindings/java/src/main/java/org/wickra/WilliamsFractals.java @@ -43,6 +43,26 @@ public final class WilliamsFractals implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WILLIAMS_FRACTALS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WILLIAMS_FRACTALS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WilliamsR.java b/bindings/java/src/main/java/org/wickra/WilliamsR.java index 949354fb..2e46dc5f 100644 --- a/bindings/java/src/main/java/org/wickra/WilliamsR.java +++ b/bindings/java/src/main/java/org/wickra/WilliamsR.java @@ -74,6 +74,26 @@ public final class WilliamsR implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WILLIAMS_R_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WILLIAMS_R_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WinRate.java b/bindings/java/src/main/java/org/wickra/WinRate.java index 1ca4d699..de49c94b 100644 --- a/bindings/java/src/main/java/org/wickra/WinRate.java +++ b/bindings/java/src/main/java/org/wickra/WinRate.java @@ -54,6 +54,26 @@ public final class WinRate implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WIN_RATE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WIN_RATE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Wma.java b/bindings/java/src/main/java/org/wickra/Wma.java index 53f76844..7acc7c18 100644 --- a/bindings/java/src/main/java/org/wickra/Wma.java +++ b/bindings/java/src/main/java/org/wickra/Wma.java @@ -54,6 +54,26 @@ public final class Wma implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/WoodiePivots.java b/bindings/java/src/main/java/org/wickra/WoodiePivots.java index 5714b0fa..50a9e05c 100644 --- a/bindings/java/src/main/java/org/wickra/WoodiePivots.java +++ b/bindings/java/src/main/java/org/wickra/WoodiePivots.java @@ -46,6 +46,26 @@ public final class WoodiePivots implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_WOODIE_PIVOTS_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_WOODIE_PIVOTS_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/YangZhangVolatility.java b/bindings/java/src/main/java/org/wickra/YangZhangVolatility.java index 4587dd0e..785cbc32 100644 --- a/bindings/java/src/main/java/org/wickra/YangZhangVolatility.java +++ b/bindings/java/src/main/java/org/wickra/YangZhangVolatility.java @@ -77,6 +77,26 @@ public final class YangZhangVolatility implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_YANG_ZHANG_VOLATILITY_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_YANG_ZHANG_VOLATILITY_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/YoyoExit.java b/bindings/java/src/main/java/org/wickra/YoyoExit.java index 2642e27c..6e2c66c9 100644 --- a/bindings/java/src/main/java/org/wickra/YoyoExit.java +++ b/bindings/java/src/main/java/org/wickra/YoyoExit.java @@ -74,6 +74,26 @@ public final class YoyoExit implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_YOYO_EXIT_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_YOYO_EXIT_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ZScore.java b/bindings/java/src/main/java/org/wickra/ZScore.java index d9464b64..737b6ddb 100644 --- a/bindings/java/src/main/java/org/wickra/ZScore.java +++ b/bindings/java/src/main/java/org/wickra/ZScore.java @@ -54,6 +54,26 @@ public final class ZScore implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_Z_SCORE_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_Z_SCORE_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ZeroLagMacd.java b/bindings/java/src/main/java/org/wickra/ZeroLagMacd.java index 04a98291..c84d2fc1 100644 --- a/bindings/java/src/main/java/org/wickra/ZeroLagMacd.java +++ b/bindings/java/src/main/java/org/wickra/ZeroLagMacd.java @@ -53,6 +53,26 @@ public final class ZeroLagMacd implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ZERO_LAG_MACD_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ZERO_LAG_MACD_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/ZigZag.java b/bindings/java/src/main/java/org/wickra/ZigZag.java index e2c6545d..0834ddc8 100644 --- a/bindings/java/src/main/java/org/wickra/ZigZag.java +++ b/bindings/java/src/main/java/org/wickra/ZigZag.java @@ -43,6 +43,26 @@ public final class ZigZag implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ZIG_ZAG_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ZIG_ZAG_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/Zlema.java b/bindings/java/src/main/java/org/wickra/Zlema.java index 22a5d6fd..e862ba75 100644 --- a/bindings/java/src/main/java/org/wickra/Zlema.java +++ b/bindings/java/src/main/java/org/wickra/Zlema.java @@ -54,6 +54,26 @@ public final class Zlema implements AutoCloseable { } } + /** Number of updates required before update() yields a value. */ + public int warmupPeriod() { + try { + long n = (long) NativeMethods.WICKRA_ZLEMA_WARMUP_PERIOD.invokeExact(handle); + return (int) n; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + + /** Whether the indicator has consumed enough input to emit a value. */ + public boolean isReady() { + try { + byte r = (byte) NativeMethods.WICKRA_ZLEMA_IS_READY.invokeExact(handle); + return r != 0; + } catch (Throwable t) { + throw WickraNative.rethrow(t); + } + } + /** Reset to the just-constructed state. */ public void reset() { try { diff --git a/bindings/java/src/main/java/org/wickra/internal/NativeMethods.java b/bindings/java/src/main/java/org/wickra/internal/NativeMethods.java index bc0cf02d..c4a0e6a1 100644 --- a/bindings/java/src/main/java/org/wickra/internal/NativeMethods.java +++ b/bindings/java/src/main/java/org/wickra/internal/NativeMethods.java @@ -16,2365 +16,3369 @@ public final class NativeMethods { public static MethodHandle WICKRA_ADAPTIVE_CYCLE_NEW; public static MethodHandle WICKRA_ADAPTIVE_CYCLE_UPDATE; public static MethodHandle WICKRA_ADAPTIVE_CYCLE_BATCH; + public static MethodHandle WICKRA_ADAPTIVE_CYCLE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADAPTIVE_CYCLE_IS_READY; public static MethodHandle WICKRA_ADAPTIVE_CYCLE_RESET; public static MethodHandle WICKRA_ADAPTIVE_CYCLE_FREE; public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_NEW; public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_UPDATE; public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_BATCH; + public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_IS_READY; public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_RESET; public static MethodHandle WICKRA_ADAPTIVE_LAGUERRE_FILTER_FREE; public static MethodHandle WICKRA_ADAPTIVE_RSI_NEW; public static MethodHandle WICKRA_ADAPTIVE_RSI_UPDATE; public static MethodHandle WICKRA_ADAPTIVE_RSI_BATCH; + public static MethodHandle WICKRA_ADAPTIVE_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADAPTIVE_RSI_IS_READY; public static MethodHandle WICKRA_ADAPTIVE_RSI_RESET; public static MethodHandle WICKRA_ADAPTIVE_RSI_FREE; public static MethodHandle WICKRA_ALMA_NEW; public static MethodHandle WICKRA_ALMA_UPDATE; public static MethodHandle WICKRA_ALMA_BATCH; + public static MethodHandle WICKRA_ALMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_ALMA_IS_READY; public static MethodHandle WICKRA_ALMA_RESET; public static MethodHandle WICKRA_ALMA_FREE; public static MethodHandle WICKRA_ANCHORED_RSI_NEW; public static MethodHandle WICKRA_ANCHORED_RSI_UPDATE; public static MethodHandle WICKRA_ANCHORED_RSI_BATCH; + public static MethodHandle WICKRA_ANCHORED_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_ANCHORED_RSI_IS_READY; public static MethodHandle WICKRA_ANCHORED_RSI_RESET; public static MethodHandle WICKRA_ANCHORED_RSI_FREE; public static MethodHandle WICKRA_APO_NEW; public static MethodHandle WICKRA_APO_UPDATE; public static MethodHandle WICKRA_APO_BATCH; + public static MethodHandle WICKRA_APO_WARMUP_PERIOD; + public static MethodHandle WICKRA_APO_IS_READY; public static MethodHandle WICKRA_APO_RESET; public static MethodHandle WICKRA_APO_FREE; public static MethodHandle WICKRA_AUTOCORRELATION_NEW; public static MethodHandle WICKRA_AUTOCORRELATION_UPDATE; public static MethodHandle WICKRA_AUTOCORRELATION_BATCH; + public static MethodHandle WICKRA_AUTOCORRELATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_AUTOCORRELATION_IS_READY; public static MethodHandle WICKRA_AUTOCORRELATION_RESET; public static MethodHandle WICKRA_AUTOCORRELATION_FREE; public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_NEW; public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_UPDATE; public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_BATCH; + public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_WARMUP_PERIOD; + public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_IS_READY; public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_RESET; public static MethodHandle WICKRA_AUTOCORRELATION_PERIODOGRAM_FREE; public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_NEW; public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_UPDATE; public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_BATCH; + public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_WARMUP_PERIOD; + public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_IS_READY; public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_RESET; public static MethodHandle WICKRA_AVERAGE_DRAWDOWN_FREE; public static MethodHandle WICKRA_BANDPASS_FILTER_NEW; public static MethodHandle WICKRA_BANDPASS_FILTER_UPDATE; public static MethodHandle WICKRA_BANDPASS_FILTER_BATCH; + public static MethodHandle WICKRA_BANDPASS_FILTER_WARMUP_PERIOD; + public static MethodHandle WICKRA_BANDPASS_FILTER_IS_READY; public static MethodHandle WICKRA_BANDPASS_FILTER_RESET; public static MethodHandle WICKRA_BANDPASS_FILTER_FREE; public static MethodHandle WICKRA_BIPOWER_VARIATION_NEW; public static MethodHandle WICKRA_BIPOWER_VARIATION_UPDATE; public static MethodHandle WICKRA_BIPOWER_VARIATION_BATCH; + public static MethodHandle WICKRA_BIPOWER_VARIATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_BIPOWER_VARIATION_IS_READY; public static MethodHandle WICKRA_BIPOWER_VARIATION_RESET; public static MethodHandle WICKRA_BIPOWER_VARIATION_FREE; public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_NEW; public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_UPDATE; public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_BATCH; + public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_WARMUP_PERIOD; + public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_IS_READY; public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_RESET; public static MethodHandle WICKRA_BOLLINGER_BANDWIDTH_FREE; public static MethodHandle WICKRA_BURKE_RATIO_NEW; public static MethodHandle WICKRA_BURKE_RATIO_UPDATE; public static MethodHandle WICKRA_BURKE_RATIO_BATCH; + public static MethodHandle WICKRA_BURKE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_BURKE_RATIO_IS_READY; public static MethodHandle WICKRA_BURKE_RATIO_RESET; public static MethodHandle WICKRA_BURKE_RATIO_FREE; public static MethodHandle WICKRA_CALMAR_RATIO_NEW; public static MethodHandle WICKRA_CALMAR_RATIO_UPDATE; public static MethodHandle WICKRA_CALMAR_RATIO_BATCH; + public static MethodHandle WICKRA_CALMAR_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_CALMAR_RATIO_IS_READY; public static MethodHandle WICKRA_CALMAR_RATIO_RESET; public static MethodHandle WICKRA_CALMAR_RATIO_FREE; public static MethodHandle WICKRA_CENTER_OF_GRAVITY_NEW; public static MethodHandle WICKRA_CENTER_OF_GRAVITY_UPDATE; public static MethodHandle WICKRA_CENTER_OF_GRAVITY_BATCH; + public static MethodHandle WICKRA_CENTER_OF_GRAVITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_CENTER_OF_GRAVITY_IS_READY; public static MethodHandle WICKRA_CENTER_OF_GRAVITY_RESET; public static MethodHandle WICKRA_CENTER_OF_GRAVITY_FREE; public static MethodHandle WICKRA_CFO_NEW; public static MethodHandle WICKRA_CFO_UPDATE; public static MethodHandle WICKRA_CFO_BATCH; + public static MethodHandle WICKRA_CFO_WARMUP_PERIOD; + public static MethodHandle WICKRA_CFO_IS_READY; public static MethodHandle WICKRA_CFO_RESET; public static MethodHandle WICKRA_CFO_FREE; public static MethodHandle WICKRA_CMO_NEW; public static MethodHandle WICKRA_CMO_UPDATE; public static MethodHandle WICKRA_CMO_BATCH; + public static MethodHandle WICKRA_CMO_WARMUP_PERIOD; + public static MethodHandle WICKRA_CMO_IS_READY; public static MethodHandle WICKRA_CMO_RESET; public static MethodHandle WICKRA_CMO_FREE; public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_NEW; public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_UPDATE; public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_BATCH; + public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_IS_READY; public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_RESET; public static MethodHandle WICKRA_COEFFICIENT_OF_VARIATION_FREE; public static MethodHandle WICKRA_COMMON_SENSE_RATIO_NEW; public static MethodHandle WICKRA_COMMON_SENSE_RATIO_UPDATE; public static MethodHandle WICKRA_COMMON_SENSE_RATIO_BATCH; + public static MethodHandle WICKRA_COMMON_SENSE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_COMMON_SENSE_RATIO_IS_READY; public static MethodHandle WICKRA_COMMON_SENSE_RATIO_RESET; public static MethodHandle WICKRA_COMMON_SENSE_RATIO_FREE; public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_NEW; public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_UPDATE; public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_BATCH; + public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_WARMUP_PERIOD; + public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_IS_READY; public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_RESET; public static MethodHandle WICKRA_CONDITIONAL_VALUE_AT_RISK_FREE; public static MethodHandle WICKRA_CONNORS_RSI_NEW; public static MethodHandle WICKRA_CONNORS_RSI_UPDATE; public static MethodHandle WICKRA_CONNORS_RSI_BATCH; + public static MethodHandle WICKRA_CONNORS_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_CONNORS_RSI_IS_READY; public static MethodHandle WICKRA_CONNORS_RSI_RESET; public static MethodHandle WICKRA_CONNORS_RSI_FREE; public static MethodHandle WICKRA_COPPOCK_NEW; public static MethodHandle WICKRA_COPPOCK_UPDATE; public static MethodHandle WICKRA_COPPOCK_BATCH; + public static MethodHandle WICKRA_COPPOCK_WARMUP_PERIOD; + public static MethodHandle WICKRA_COPPOCK_IS_READY; public static MethodHandle WICKRA_COPPOCK_RESET; public static MethodHandle WICKRA_COPPOCK_FREE; public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_NEW; public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_UPDATE; public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_BATCH; + public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_IS_READY; public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_RESET; public static MethodHandle WICKRA_CORRELATION_TREND_INDICATOR_FREE; public static MethodHandle WICKRA_CYBERNETIC_CYCLE_NEW; public static MethodHandle WICKRA_CYBERNETIC_CYCLE_UPDATE; public static MethodHandle WICKRA_CYBERNETIC_CYCLE_BATCH; + public static MethodHandle WICKRA_CYBERNETIC_CYCLE_WARMUP_PERIOD; + public static MethodHandle WICKRA_CYBERNETIC_CYCLE_IS_READY; public static MethodHandle WICKRA_CYBERNETIC_CYCLE_RESET; public static MethodHandle WICKRA_CYBERNETIC_CYCLE_FREE; public static MethodHandle WICKRA_DECYCLER_NEW; public static MethodHandle WICKRA_DECYCLER_UPDATE; public static MethodHandle WICKRA_DECYCLER_BATCH; + public static MethodHandle WICKRA_DECYCLER_WARMUP_PERIOD; + public static MethodHandle WICKRA_DECYCLER_IS_READY; public static MethodHandle WICKRA_DECYCLER_RESET; public static MethodHandle WICKRA_DECYCLER_FREE; public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_NEW; public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_RESET; public static MethodHandle WICKRA_DECYCLER_OSCILLATOR_FREE; public static MethodHandle WICKRA_DEMA_NEW; public static MethodHandle WICKRA_DEMA_UPDATE; public static MethodHandle WICKRA_DEMA_BATCH; + public static MethodHandle WICKRA_DEMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_DEMA_IS_READY; public static MethodHandle WICKRA_DEMA_RESET; public static MethodHandle WICKRA_DEMA_FREE; public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_NEW; public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_RESET; public static MethodHandle WICKRA_DERIVATIVE_OSCILLATOR_FREE; public static MethodHandle WICKRA_DETRENDED_STD_DEV_NEW; public static MethodHandle WICKRA_DETRENDED_STD_DEV_UPDATE; public static MethodHandle WICKRA_DETRENDED_STD_DEV_BATCH; + public static MethodHandle WICKRA_DETRENDED_STD_DEV_WARMUP_PERIOD; + public static MethodHandle WICKRA_DETRENDED_STD_DEV_IS_READY; public static MethodHandle WICKRA_DETRENDED_STD_DEV_RESET; public static MethodHandle WICKRA_DETRENDED_STD_DEV_FREE; public static MethodHandle WICKRA_DISPARITY_INDEX_NEW; public static MethodHandle WICKRA_DISPARITY_INDEX_UPDATE; public static MethodHandle WICKRA_DISPARITY_INDEX_BATCH; + public static MethodHandle WICKRA_DISPARITY_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_DISPARITY_INDEX_IS_READY; public static MethodHandle WICKRA_DISPARITY_INDEX_RESET; public static MethodHandle WICKRA_DISPARITY_INDEX_FREE; public static MethodHandle WICKRA_DPO_NEW; public static MethodHandle WICKRA_DPO_UPDATE; public static MethodHandle WICKRA_DPO_BATCH; + public static MethodHandle WICKRA_DPO_WARMUP_PERIOD; + public static MethodHandle WICKRA_DPO_IS_READY; public static MethodHandle WICKRA_DPO_RESET; public static MethodHandle WICKRA_DPO_FREE; public static MethodHandle WICKRA_DRAWDOWN_DURATION_NEW; public static MethodHandle WICKRA_DRAWDOWN_DURATION_UPDATE; public static MethodHandle WICKRA_DRAWDOWN_DURATION_BATCH; + public static MethodHandle WICKRA_DRAWDOWN_DURATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_DRAWDOWN_DURATION_IS_READY; public static MethodHandle WICKRA_DRAWDOWN_DURATION_RESET; public static MethodHandle WICKRA_DRAWDOWN_DURATION_FREE; public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_NEW; public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_UPDATE; public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_BATCH; + public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_IS_READY; public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_RESET; public static MethodHandle WICKRA_DYNAMIC_MOMENTUM_INDEX_FREE; public static MethodHandle WICKRA_EHLERS_STOCHASTIC_NEW; public static MethodHandle WICKRA_EHLERS_STOCHASTIC_UPDATE; public static MethodHandle WICKRA_EHLERS_STOCHASTIC_BATCH; + public static MethodHandle WICKRA_EHLERS_STOCHASTIC_WARMUP_PERIOD; + public static MethodHandle WICKRA_EHLERS_STOCHASTIC_IS_READY; public static MethodHandle WICKRA_EHLERS_STOCHASTIC_RESET; public static MethodHandle WICKRA_EHLERS_STOCHASTIC_FREE; public static MethodHandle WICKRA_EHMA_NEW; public static MethodHandle WICKRA_EHMA_UPDATE; public static MethodHandle WICKRA_EHMA_BATCH; + public static MethodHandle WICKRA_EHMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_EHMA_IS_READY; public static MethodHandle WICKRA_EHMA_RESET; public static MethodHandle WICKRA_EHMA_FREE; public static MethodHandle WICKRA_ELDER_IMPULSE_NEW; public static MethodHandle WICKRA_ELDER_IMPULSE_UPDATE; public static MethodHandle WICKRA_ELDER_IMPULSE_BATCH; + public static MethodHandle WICKRA_ELDER_IMPULSE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ELDER_IMPULSE_IS_READY; public static MethodHandle WICKRA_ELDER_IMPULSE_RESET; public static MethodHandle WICKRA_ELDER_IMPULSE_FREE; public static MethodHandle WICKRA_EMA_NEW; public static MethodHandle WICKRA_EMA_UPDATE; public static MethodHandle WICKRA_EMA_BATCH; + public static MethodHandle WICKRA_EMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_EMA_IS_READY; public static MethodHandle WICKRA_EMA_RESET; public static MethodHandle WICKRA_EMA_FREE; public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_NEW; public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_UPDATE; public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_BATCH; + public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_WARMUP_PERIOD; + public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_IS_READY; public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_RESET; public static MethodHandle WICKRA_EMPIRICAL_MODE_DECOMPOSITION_FREE; public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_NEW; public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_UPDATE; public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_BATCH; + public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_WARMUP_PERIOD; + public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_IS_READY; public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_RESET; public static MethodHandle WICKRA_EVEN_BETTER_SINEWAVE_FREE; public static MethodHandle WICKRA_EWMA_VOLATILITY_NEW; public static MethodHandle WICKRA_EWMA_VOLATILITY_UPDATE; public static MethodHandle WICKRA_EWMA_VOLATILITY_BATCH; + public static MethodHandle WICKRA_EWMA_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_EWMA_VOLATILITY_IS_READY; public static MethodHandle WICKRA_EWMA_VOLATILITY_RESET; public static MethodHandle WICKRA_EWMA_VOLATILITY_FREE; public static MethodHandle WICKRA_EXPECTANCY_NEW; public static MethodHandle WICKRA_EXPECTANCY_UPDATE; public static MethodHandle WICKRA_EXPECTANCY_BATCH; + public static MethodHandle WICKRA_EXPECTANCY_WARMUP_PERIOD; + public static MethodHandle WICKRA_EXPECTANCY_IS_READY; public static MethodHandle WICKRA_EXPECTANCY_RESET; public static MethodHandle WICKRA_EXPECTANCY_FREE; public static MethodHandle WICKRA_FAMA_NEW; public static MethodHandle WICKRA_FAMA_UPDATE; public static MethodHandle WICKRA_FAMA_BATCH; + public static MethodHandle WICKRA_FAMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_FAMA_IS_READY; public static MethodHandle WICKRA_FAMA_RESET; public static MethodHandle WICKRA_FAMA_FREE; public static MethodHandle WICKRA_FISHER_RSI_NEW; public static MethodHandle WICKRA_FISHER_RSI_UPDATE; public static MethodHandle WICKRA_FISHER_RSI_BATCH; + public static MethodHandle WICKRA_FISHER_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_FISHER_RSI_IS_READY; public static MethodHandle WICKRA_FISHER_RSI_RESET; public static MethodHandle WICKRA_FISHER_RSI_FREE; public static MethodHandle WICKRA_FISHER_TRANSFORM_NEW; public static MethodHandle WICKRA_FISHER_TRANSFORM_UPDATE; public static MethodHandle WICKRA_FISHER_TRANSFORM_BATCH; + public static MethodHandle WICKRA_FISHER_TRANSFORM_WARMUP_PERIOD; + public static MethodHandle WICKRA_FISHER_TRANSFORM_IS_READY; public static MethodHandle WICKRA_FISHER_TRANSFORM_RESET; public static MethodHandle WICKRA_FISHER_TRANSFORM_FREE; public static MethodHandle WICKRA_FRAMA_NEW; public static MethodHandle WICKRA_FRAMA_UPDATE; public static MethodHandle WICKRA_FRAMA_BATCH; + public static MethodHandle WICKRA_FRAMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_FRAMA_IS_READY; public static MethodHandle WICKRA_FRAMA_RESET; public static MethodHandle WICKRA_FRAMA_FREE; public static MethodHandle WICKRA_GAIN_LOSS_RATIO_NEW; public static MethodHandle WICKRA_GAIN_LOSS_RATIO_UPDATE; public static MethodHandle WICKRA_GAIN_LOSS_RATIO_BATCH; + public static MethodHandle WICKRA_GAIN_LOSS_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_GAIN_LOSS_RATIO_IS_READY; public static MethodHandle WICKRA_GAIN_LOSS_RATIO_RESET; public static MethodHandle WICKRA_GAIN_LOSS_RATIO_FREE; public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_NEW; public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_UPDATE; public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_BATCH; + public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_IS_READY; public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_RESET; public static MethodHandle WICKRA_GAIN_TO_PAIN_RATIO_FREE; public static MethodHandle WICKRA_GARCH11_NEW; public static MethodHandle WICKRA_GARCH11_UPDATE; public static MethodHandle WICKRA_GARCH11_BATCH; + public static MethodHandle WICKRA_GARCH11_WARMUP_PERIOD; + public static MethodHandle WICKRA_GARCH11_IS_READY; public static MethodHandle WICKRA_GARCH11_RESET; public static MethodHandle WICKRA_GARCH11_FREE; public static MethodHandle WICKRA_GENERALIZED_DEMA_NEW; public static MethodHandle WICKRA_GENERALIZED_DEMA_UPDATE; public static MethodHandle WICKRA_GENERALIZED_DEMA_BATCH; + public static MethodHandle WICKRA_GENERALIZED_DEMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_GENERALIZED_DEMA_IS_READY; public static MethodHandle WICKRA_GENERALIZED_DEMA_RESET; public static MethodHandle WICKRA_GENERALIZED_DEMA_FREE; public static MethodHandle WICKRA_GEOMETRIC_MA_NEW; public static MethodHandle WICKRA_GEOMETRIC_MA_UPDATE; public static MethodHandle WICKRA_GEOMETRIC_MA_BATCH; + public static MethodHandle WICKRA_GEOMETRIC_MA_WARMUP_PERIOD; + public static MethodHandle WICKRA_GEOMETRIC_MA_IS_READY; public static MethodHandle WICKRA_GEOMETRIC_MA_RESET; public static MethodHandle WICKRA_GEOMETRIC_MA_FREE; public static MethodHandle WICKRA_HIGHPASS_FILTER_NEW; public static MethodHandle WICKRA_HIGHPASS_FILTER_UPDATE; public static MethodHandle WICKRA_HIGHPASS_FILTER_BATCH; + public static MethodHandle WICKRA_HIGHPASS_FILTER_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIGHPASS_FILTER_IS_READY; public static MethodHandle WICKRA_HIGHPASS_FILTER_RESET; public static MethodHandle WICKRA_HIGHPASS_FILTER_FREE; public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_NEW; public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_UPDATE; public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_BATCH; + public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_IS_READY; public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_RESET; public static MethodHandle WICKRA_HILBERT_DOMINANT_CYCLE_FREE; public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_NEW; public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_UPDATE; public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_BATCH; + public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_IS_READY; public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_RESET; public static MethodHandle WICKRA_HISTORICAL_VOLATILITY_FREE; public static MethodHandle WICKRA_HMA_NEW; public static MethodHandle WICKRA_HMA_UPDATE; public static MethodHandle WICKRA_HMA_BATCH; + public static MethodHandle WICKRA_HMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_HMA_IS_READY; public static MethodHandle WICKRA_HMA_RESET; public static MethodHandle WICKRA_HMA_FREE; public static MethodHandle WICKRA_HOLT_WINTERS_NEW; public static MethodHandle WICKRA_HOLT_WINTERS_UPDATE; public static MethodHandle WICKRA_HOLT_WINTERS_BATCH; + public static MethodHandle WICKRA_HOLT_WINTERS_WARMUP_PERIOD; + public static MethodHandle WICKRA_HOLT_WINTERS_IS_READY; public static MethodHandle WICKRA_HOLT_WINTERS_RESET; public static MethodHandle WICKRA_HOLT_WINTERS_FREE; public static MethodHandle WICKRA_HT_DC_PHASE_NEW; public static MethodHandle WICKRA_HT_DC_PHASE_UPDATE; public static MethodHandle WICKRA_HT_DC_PHASE_BATCH; + public static MethodHandle WICKRA_HT_DC_PHASE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HT_DC_PHASE_IS_READY; public static MethodHandle WICKRA_HT_DC_PHASE_RESET; public static MethodHandle WICKRA_HT_DC_PHASE_FREE; public static MethodHandle WICKRA_HT_TREND_MODE_NEW; public static MethodHandle WICKRA_HT_TREND_MODE_UPDATE; public static MethodHandle WICKRA_HT_TREND_MODE_BATCH; + public static MethodHandle WICKRA_HT_TREND_MODE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HT_TREND_MODE_IS_READY; public static MethodHandle WICKRA_HT_TREND_MODE_RESET; public static MethodHandle WICKRA_HT_TREND_MODE_FREE; public static MethodHandle WICKRA_HURST_EXPONENT_NEW; public static MethodHandle WICKRA_HURST_EXPONENT_UPDATE; public static MethodHandle WICKRA_HURST_EXPONENT_BATCH; + public static MethodHandle WICKRA_HURST_EXPONENT_WARMUP_PERIOD; + public static MethodHandle WICKRA_HURST_EXPONENT_IS_READY; public static MethodHandle WICKRA_HURST_EXPONENT_RESET; public static MethodHandle WICKRA_HURST_EXPONENT_FREE; public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_NEW; public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_UPDATE; public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_BATCH; + public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_WARMUP_PERIOD; + public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_IS_READY; public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_RESET; public static MethodHandle WICKRA_INSTANTANEOUS_TRENDLINE_FREE; public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_NEW; public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_UPDATE; public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_BATCH; + public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_WARMUP_PERIOD; + public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_IS_READY; public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_RESET; public static MethodHandle WICKRA_INVERSE_FISHER_TRANSFORM_FREE; public static MethodHandle WICKRA_JARQUE_BERA_NEW; public static MethodHandle WICKRA_JARQUE_BERA_UPDATE; public static MethodHandle WICKRA_JARQUE_BERA_BATCH; + public static MethodHandle WICKRA_JARQUE_BERA_WARMUP_PERIOD; + public static MethodHandle WICKRA_JARQUE_BERA_IS_READY; public static MethodHandle WICKRA_JARQUE_BERA_RESET; public static MethodHandle WICKRA_JARQUE_BERA_FREE; public static MethodHandle WICKRA_JMA_NEW; public static MethodHandle WICKRA_JMA_UPDATE; public static MethodHandle WICKRA_JMA_BATCH; + public static MethodHandle WICKRA_JMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_JMA_IS_READY; public static MethodHandle WICKRA_JMA_RESET; public static MethodHandle WICKRA_JMA_FREE; public static MethodHandle WICKRA_JUMP_INDICATOR_NEW; public static MethodHandle WICKRA_JUMP_INDICATOR_UPDATE; public static MethodHandle WICKRA_JUMP_INDICATOR_BATCH; + public static MethodHandle WICKRA_JUMP_INDICATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_JUMP_INDICATOR_IS_READY; public static MethodHandle WICKRA_JUMP_INDICATOR_RESET; public static MethodHandle WICKRA_JUMP_INDICATOR_FREE; public static MethodHandle WICKRA_K_RATIO_NEW; public static MethodHandle WICKRA_K_RATIO_UPDATE; public static MethodHandle WICKRA_K_RATIO_BATCH; + public static MethodHandle WICKRA_K_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_K_RATIO_IS_READY; public static MethodHandle WICKRA_K_RATIO_RESET; public static MethodHandle WICKRA_K_RATIO_FREE; public static MethodHandle WICKRA_KAMA_NEW; public static MethodHandle WICKRA_KAMA_UPDATE; public static MethodHandle WICKRA_KAMA_BATCH; + public static MethodHandle WICKRA_KAMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_KAMA_IS_READY; public static MethodHandle WICKRA_KAMA_RESET; public static MethodHandle WICKRA_KAMA_FREE; public static MethodHandle WICKRA_KELLY_CRITERION_NEW; public static MethodHandle WICKRA_KELLY_CRITERION_UPDATE; public static MethodHandle WICKRA_KELLY_CRITERION_BATCH; + public static MethodHandle WICKRA_KELLY_CRITERION_WARMUP_PERIOD; + public static MethodHandle WICKRA_KELLY_CRITERION_IS_READY; public static MethodHandle WICKRA_KELLY_CRITERION_RESET; public static MethodHandle WICKRA_KELLY_CRITERION_FREE; public static MethodHandle WICKRA_KURTOSIS_NEW; public static MethodHandle WICKRA_KURTOSIS_UPDATE; public static MethodHandle WICKRA_KURTOSIS_BATCH; + public static MethodHandle WICKRA_KURTOSIS_WARMUP_PERIOD; + public static MethodHandle WICKRA_KURTOSIS_IS_READY; public static MethodHandle WICKRA_KURTOSIS_RESET; public static MethodHandle WICKRA_KURTOSIS_FREE; public static MethodHandle WICKRA_LAGUERRE_RSI_NEW; public static MethodHandle WICKRA_LAGUERRE_RSI_UPDATE; public static MethodHandle WICKRA_LAGUERRE_RSI_BATCH; + public static MethodHandle WICKRA_LAGUERRE_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_LAGUERRE_RSI_IS_READY; public static MethodHandle WICKRA_LAGUERRE_RSI_RESET; public static MethodHandle WICKRA_LAGUERRE_RSI_FREE; public static MethodHandle WICKRA_LINEAR_REGRESSION_NEW; public static MethodHandle WICKRA_LINEAR_REGRESSION_UPDATE; public static MethodHandle WICKRA_LINEAR_REGRESSION_BATCH; + public static MethodHandle WICKRA_LINEAR_REGRESSION_WARMUP_PERIOD; + public static MethodHandle WICKRA_LINEAR_REGRESSION_IS_READY; public static MethodHandle WICKRA_LINEAR_REGRESSION_RESET; public static MethodHandle WICKRA_LINEAR_REGRESSION_FREE; public static MethodHandle WICKRA_LIN_REG_ANGLE_NEW; public static MethodHandle WICKRA_LIN_REG_ANGLE_UPDATE; public static MethodHandle WICKRA_LIN_REG_ANGLE_BATCH; + public static MethodHandle WICKRA_LIN_REG_ANGLE_WARMUP_PERIOD; + public static MethodHandle WICKRA_LIN_REG_ANGLE_IS_READY; public static MethodHandle WICKRA_LIN_REG_ANGLE_RESET; public static MethodHandle WICKRA_LIN_REG_ANGLE_FREE; public static MethodHandle WICKRA_LIN_REG_INTERCEPT_NEW; public static MethodHandle WICKRA_LIN_REG_INTERCEPT_UPDATE; public static MethodHandle WICKRA_LIN_REG_INTERCEPT_BATCH; + public static MethodHandle WICKRA_LIN_REG_INTERCEPT_WARMUP_PERIOD; + public static MethodHandle WICKRA_LIN_REG_INTERCEPT_IS_READY; public static MethodHandle WICKRA_LIN_REG_INTERCEPT_RESET; public static MethodHandle WICKRA_LIN_REG_INTERCEPT_FREE; public static MethodHandle WICKRA_LIN_REG_SLOPE_NEW; public static MethodHandle WICKRA_LIN_REG_SLOPE_UPDATE; public static MethodHandle WICKRA_LIN_REG_SLOPE_BATCH; + public static MethodHandle WICKRA_LIN_REG_SLOPE_WARMUP_PERIOD; + public static MethodHandle WICKRA_LIN_REG_SLOPE_IS_READY; public static MethodHandle WICKRA_LIN_REG_SLOPE_RESET; public static MethodHandle WICKRA_LIN_REG_SLOPE_FREE; public static MethodHandle WICKRA_LOG_RETURN_NEW; public static MethodHandle WICKRA_LOG_RETURN_UPDATE; public static MethodHandle WICKRA_LOG_RETURN_BATCH; + public static MethodHandle WICKRA_LOG_RETURN_WARMUP_PERIOD; + public static MethodHandle WICKRA_LOG_RETURN_IS_READY; public static MethodHandle WICKRA_LOG_RETURN_RESET; public static MethodHandle WICKRA_LOG_RETURN_FREE; public static MethodHandle WICKRA_M2_MEASURE_NEW; public static MethodHandle WICKRA_M2_MEASURE_UPDATE; public static MethodHandle WICKRA_M2_MEASURE_BATCH; + public static MethodHandle WICKRA_M2_MEASURE_WARMUP_PERIOD; + public static MethodHandle WICKRA_M2_MEASURE_IS_READY; public static MethodHandle WICKRA_M2_MEASURE_RESET; public static MethodHandle WICKRA_M2_MEASURE_FREE; public static MethodHandle WICKRA_MACD_HISTOGRAM_NEW; public static MethodHandle WICKRA_MACD_HISTOGRAM_UPDATE; public static MethodHandle WICKRA_MACD_HISTOGRAM_BATCH; + public static MethodHandle WICKRA_MACD_HISTOGRAM_WARMUP_PERIOD; + public static MethodHandle WICKRA_MACD_HISTOGRAM_IS_READY; public static MethodHandle WICKRA_MACD_HISTOGRAM_RESET; public static MethodHandle WICKRA_MACD_HISTOGRAM_FREE; public static MethodHandle WICKRA_MARTIN_RATIO_NEW; public static MethodHandle WICKRA_MARTIN_RATIO_UPDATE; public static MethodHandle WICKRA_MARTIN_RATIO_BATCH; + public static MethodHandle WICKRA_MARTIN_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_MARTIN_RATIO_IS_READY; public static MethodHandle WICKRA_MARTIN_RATIO_RESET; public static MethodHandle WICKRA_MARTIN_RATIO_FREE; public static MethodHandle WICKRA_MAX_DRAWDOWN_NEW; public static MethodHandle WICKRA_MAX_DRAWDOWN_UPDATE; public static MethodHandle WICKRA_MAX_DRAWDOWN_BATCH; + public static MethodHandle WICKRA_MAX_DRAWDOWN_WARMUP_PERIOD; + public static MethodHandle WICKRA_MAX_DRAWDOWN_IS_READY; public static MethodHandle WICKRA_MAX_DRAWDOWN_RESET; public static MethodHandle WICKRA_MAX_DRAWDOWN_FREE; public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_NEW; public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_UPDATE; public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_BATCH; + public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_WARMUP_PERIOD; + public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_IS_READY; public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_RESET; public static MethodHandle WICKRA_MC_GINLEY_DYNAMIC_FREE; public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_NEW; public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_UPDATE; public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_BATCH; + public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_IS_READY; public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_RESET; public static MethodHandle WICKRA_MEDIAN_ABSOLUTE_DEVIATION_FREE; public static MethodHandle WICKRA_MEDIAN_MA_NEW; public static MethodHandle WICKRA_MEDIAN_MA_UPDATE; public static MethodHandle WICKRA_MEDIAN_MA_BATCH; + public static MethodHandle WICKRA_MEDIAN_MA_WARMUP_PERIOD; + public static MethodHandle WICKRA_MEDIAN_MA_IS_READY; public static MethodHandle WICKRA_MEDIAN_MA_RESET; public static MethodHandle WICKRA_MEDIAN_MA_FREE; public static MethodHandle WICKRA_MID_POINT_NEW; public static MethodHandle WICKRA_MID_POINT_UPDATE; public static MethodHandle WICKRA_MID_POINT_BATCH; + public static MethodHandle WICKRA_MID_POINT_WARMUP_PERIOD; + public static MethodHandle WICKRA_MID_POINT_IS_READY; public static MethodHandle WICKRA_MID_POINT_RESET; public static MethodHandle WICKRA_MID_POINT_FREE; public static MethodHandle WICKRA_MOM_NEW; public static MethodHandle WICKRA_MOM_UPDATE; public static MethodHandle WICKRA_MOM_BATCH; + public static MethodHandle WICKRA_MOM_WARMUP_PERIOD; + public static MethodHandle WICKRA_MOM_IS_READY; public static MethodHandle WICKRA_MOM_RESET; public static MethodHandle WICKRA_MOM_FREE; public static MethodHandle WICKRA_OMEGA_RATIO_NEW; public static MethodHandle WICKRA_OMEGA_RATIO_UPDATE; public static MethodHandle WICKRA_OMEGA_RATIO_BATCH; + public static MethodHandle WICKRA_OMEGA_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_OMEGA_RATIO_IS_READY; public static MethodHandle WICKRA_OMEGA_RATIO_RESET; public static MethodHandle WICKRA_OMEGA_RATIO_FREE; public static MethodHandle WICKRA_PAIN_INDEX_NEW; public static MethodHandle WICKRA_PAIN_INDEX_UPDATE; public static MethodHandle WICKRA_PAIN_INDEX_BATCH; + public static MethodHandle WICKRA_PAIN_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_PAIN_INDEX_IS_READY; public static MethodHandle WICKRA_PAIN_INDEX_RESET; public static MethodHandle WICKRA_PAIN_INDEX_FREE; public static MethodHandle WICKRA_PERCENT_B_NEW; public static MethodHandle WICKRA_PERCENT_B_UPDATE; public static MethodHandle WICKRA_PERCENT_B_BATCH; + public static MethodHandle WICKRA_PERCENT_B_WARMUP_PERIOD; + public static MethodHandle WICKRA_PERCENT_B_IS_READY; public static MethodHandle WICKRA_PERCENT_B_RESET; public static MethodHandle WICKRA_PERCENT_B_FREE; public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_NEW; public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_UPDATE; public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_BATCH; + public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_IS_READY; public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_RESET; public static MethodHandle WICKRA_PERCENTAGE_TRAILING_STOP_FREE; public static MethodHandle WICKRA_PMO_NEW; public static MethodHandle WICKRA_PMO_UPDATE; public static MethodHandle WICKRA_PMO_BATCH; + public static MethodHandle WICKRA_PMO_WARMUP_PERIOD; + public static MethodHandle WICKRA_PMO_IS_READY; public static MethodHandle WICKRA_PMO_RESET; public static MethodHandle WICKRA_PMO_FREE; public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_NEW; public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_UPDATE; public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_BATCH; + public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_WARMUP_PERIOD; + public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_IS_READY; public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_RESET; public static MethodHandle WICKRA_POLARIZED_FRACTAL_EFFICIENCY_FREE; public static MethodHandle WICKRA_PPO_NEW; public static MethodHandle WICKRA_PPO_UPDATE; public static MethodHandle WICKRA_PPO_BATCH; + public static MethodHandle WICKRA_PPO_WARMUP_PERIOD; + public static MethodHandle WICKRA_PPO_IS_READY; public static MethodHandle WICKRA_PPO_RESET; public static MethodHandle WICKRA_PPO_FREE; public static MethodHandle WICKRA_PPO_HISTOGRAM_NEW; public static MethodHandle WICKRA_PPO_HISTOGRAM_UPDATE; public static MethodHandle WICKRA_PPO_HISTOGRAM_BATCH; + public static MethodHandle WICKRA_PPO_HISTOGRAM_WARMUP_PERIOD; + public static MethodHandle WICKRA_PPO_HISTOGRAM_IS_READY; public static MethodHandle WICKRA_PPO_HISTOGRAM_RESET; public static MethodHandle WICKRA_PPO_HISTOGRAM_FREE; public static MethodHandle WICKRA_PROFIT_FACTOR_NEW; public static MethodHandle WICKRA_PROFIT_FACTOR_UPDATE; public static MethodHandle WICKRA_PROFIT_FACTOR_BATCH; + public static MethodHandle WICKRA_PROFIT_FACTOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_PROFIT_FACTOR_IS_READY; public static MethodHandle WICKRA_PROFIT_FACTOR_RESET; public static MethodHandle WICKRA_PROFIT_FACTOR_FREE; public static MethodHandle WICKRA_R_SQUARED_NEW; public static MethodHandle WICKRA_R_SQUARED_UPDATE; public static MethodHandle WICKRA_R_SQUARED_BATCH; + public static MethodHandle WICKRA_R_SQUARED_WARMUP_PERIOD; + public static MethodHandle WICKRA_R_SQUARED_IS_READY; public static MethodHandle WICKRA_R_SQUARED_RESET; public static MethodHandle WICKRA_R_SQUARED_FREE; public static MethodHandle WICKRA_REALIZED_VOLATILITY_NEW; public static MethodHandle WICKRA_REALIZED_VOLATILITY_UPDATE; public static MethodHandle WICKRA_REALIZED_VOLATILITY_BATCH; + public static MethodHandle WICKRA_REALIZED_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_REALIZED_VOLATILITY_IS_READY; public static MethodHandle WICKRA_REALIZED_VOLATILITY_RESET; public static MethodHandle WICKRA_REALIZED_VOLATILITY_FREE; public static MethodHandle WICKRA_RECOVERY_FACTOR_NEW; public static MethodHandle WICKRA_RECOVERY_FACTOR_UPDATE; public static MethodHandle WICKRA_RECOVERY_FACTOR_BATCH; + public static MethodHandle WICKRA_RECOVERY_FACTOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_RECOVERY_FACTOR_IS_READY; public static MethodHandle WICKRA_RECOVERY_FACTOR_RESET; public static MethodHandle WICKRA_RECOVERY_FACTOR_FREE; public static MethodHandle WICKRA_REFLEX_NEW; public static MethodHandle WICKRA_REFLEX_UPDATE; public static MethodHandle WICKRA_REFLEX_BATCH; + public static MethodHandle WICKRA_REFLEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_REFLEX_IS_READY; public static MethodHandle WICKRA_REFLEX_RESET; public static MethodHandle WICKRA_REFLEX_FREE; public static MethodHandle WICKRA_REGIME_LABEL_NEW; public static MethodHandle WICKRA_REGIME_LABEL_UPDATE; public static MethodHandle WICKRA_REGIME_LABEL_BATCH; + public static MethodHandle WICKRA_REGIME_LABEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_REGIME_LABEL_IS_READY; public static MethodHandle WICKRA_REGIME_LABEL_RESET; public static MethodHandle WICKRA_REGIME_LABEL_FREE; public static MethodHandle WICKRA_RENKO_TRAILING_STOP_NEW; public static MethodHandle WICKRA_RENKO_TRAILING_STOP_UPDATE; public static MethodHandle WICKRA_RENKO_TRAILING_STOP_BATCH; + public static MethodHandle WICKRA_RENKO_TRAILING_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_RENKO_TRAILING_STOP_IS_READY; public static MethodHandle WICKRA_RENKO_TRAILING_STOP_RESET; public static MethodHandle WICKRA_RENKO_TRAILING_STOP_FREE; public static MethodHandle WICKRA_RMI_NEW; public static MethodHandle WICKRA_RMI_UPDATE; public static MethodHandle WICKRA_RMI_BATCH; + public static MethodHandle WICKRA_RMI_WARMUP_PERIOD; + public static MethodHandle WICKRA_RMI_IS_READY; public static MethodHandle WICKRA_RMI_RESET; public static MethodHandle WICKRA_RMI_FREE; public static MethodHandle WICKRA_ROC_NEW; public static MethodHandle WICKRA_ROC_UPDATE; public static MethodHandle WICKRA_ROC_BATCH; + public static MethodHandle WICKRA_ROC_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROC_IS_READY; public static MethodHandle WICKRA_ROC_RESET; public static MethodHandle WICKRA_ROC_FREE; public static MethodHandle WICKRA_ROCP_NEW; public static MethodHandle WICKRA_ROCP_UPDATE; public static MethodHandle WICKRA_ROCP_BATCH; + public static MethodHandle WICKRA_ROCP_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROCP_IS_READY; public static MethodHandle WICKRA_ROCP_RESET; public static MethodHandle WICKRA_ROCP_FREE; public static MethodHandle WICKRA_ROCR_NEW; public static MethodHandle WICKRA_ROCR_UPDATE; public static MethodHandle WICKRA_ROCR_BATCH; + public static MethodHandle WICKRA_ROCR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROCR_IS_READY; public static MethodHandle WICKRA_ROCR_RESET; public static MethodHandle WICKRA_ROCR_FREE; public static MethodHandle WICKRA_ROCR100_NEW; public static MethodHandle WICKRA_ROCR100_UPDATE; public static MethodHandle WICKRA_ROCR100_BATCH; + public static MethodHandle WICKRA_ROCR100_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROCR100_IS_READY; public static MethodHandle WICKRA_ROCR100_RESET; public static MethodHandle WICKRA_ROCR100_FREE; public static MethodHandle WICKRA_ROLLING_IQR_NEW; public static MethodHandle WICKRA_ROLLING_IQR_UPDATE; public static MethodHandle WICKRA_ROLLING_IQR_BATCH; + public static MethodHandle WICKRA_ROLLING_IQR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_IQR_IS_READY; public static MethodHandle WICKRA_ROLLING_IQR_RESET; public static MethodHandle WICKRA_ROLLING_IQR_FREE; public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_NEW; public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_UPDATE; public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_BATCH; + public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_IS_READY; public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_RESET; public static MethodHandle WICKRA_ROLLING_MIN_MAX_SCALER_FREE; public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_NEW; public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_UPDATE; public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_BATCH; + public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_IS_READY; public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_RESET; public static MethodHandle WICKRA_ROLLING_PERCENTILE_RANK_FREE; public static MethodHandle WICKRA_ROLLING_QUANTILE_NEW; public static MethodHandle WICKRA_ROLLING_QUANTILE_UPDATE; public static MethodHandle WICKRA_ROLLING_QUANTILE_BATCH; + public static MethodHandle WICKRA_ROLLING_QUANTILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_QUANTILE_IS_READY; public static MethodHandle WICKRA_ROLLING_QUANTILE_RESET; public static MethodHandle WICKRA_ROLLING_QUANTILE_FREE; public static MethodHandle WICKRA_ROOFING_FILTER_NEW; public static MethodHandle WICKRA_ROOFING_FILTER_UPDATE; public static MethodHandle WICKRA_ROOFING_FILTER_BATCH; + public static MethodHandle WICKRA_ROOFING_FILTER_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROOFING_FILTER_IS_READY; public static MethodHandle WICKRA_ROOFING_FILTER_RESET; public static MethodHandle WICKRA_ROOFING_FILTER_FREE; public static MethodHandle WICKRA_RSI_NEW; public static MethodHandle WICKRA_RSI_UPDATE; public static MethodHandle WICKRA_RSI_BATCH; + public static MethodHandle WICKRA_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_RSI_IS_READY; public static MethodHandle WICKRA_RSI_RESET; public static MethodHandle WICKRA_RSI_FREE; public static MethodHandle WICKRA_RSX_NEW; public static MethodHandle WICKRA_RSX_UPDATE; public static MethodHandle WICKRA_RSX_BATCH; + public static MethodHandle WICKRA_RSX_WARMUP_PERIOD; + public static MethodHandle WICKRA_RSX_IS_READY; public static MethodHandle WICKRA_RSX_RESET; public static MethodHandle WICKRA_RSX_FREE; public static MethodHandle WICKRA_RVI_VOLATILITY_NEW; public static MethodHandle WICKRA_RVI_VOLATILITY_UPDATE; public static MethodHandle WICKRA_RVI_VOLATILITY_BATCH; + public static MethodHandle WICKRA_RVI_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_RVI_VOLATILITY_IS_READY; public static MethodHandle WICKRA_RVI_VOLATILITY_RESET; public static MethodHandle WICKRA_RVI_VOLATILITY_FREE; public static MethodHandle WICKRA_SAMPLE_ENTROPY_NEW; public static MethodHandle WICKRA_SAMPLE_ENTROPY_UPDATE; public static MethodHandle WICKRA_SAMPLE_ENTROPY_BATCH; + public static MethodHandle WICKRA_SAMPLE_ENTROPY_WARMUP_PERIOD; + public static MethodHandle WICKRA_SAMPLE_ENTROPY_IS_READY; public static MethodHandle WICKRA_SAMPLE_ENTROPY_RESET; public static MethodHandle WICKRA_SAMPLE_ENTROPY_FREE; public static MethodHandle WICKRA_SHANNON_ENTROPY_NEW; public static MethodHandle WICKRA_SHANNON_ENTROPY_UPDATE; public static MethodHandle WICKRA_SHANNON_ENTROPY_BATCH; + public static MethodHandle WICKRA_SHANNON_ENTROPY_WARMUP_PERIOD; + public static MethodHandle WICKRA_SHANNON_ENTROPY_IS_READY; public static MethodHandle WICKRA_SHANNON_ENTROPY_RESET; public static MethodHandle WICKRA_SHANNON_ENTROPY_FREE; public static MethodHandle WICKRA_SHARPE_RATIO_NEW; public static MethodHandle WICKRA_SHARPE_RATIO_UPDATE; public static MethodHandle WICKRA_SHARPE_RATIO_BATCH; + public static MethodHandle WICKRA_SHARPE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_SHARPE_RATIO_IS_READY; public static MethodHandle WICKRA_SHARPE_RATIO_RESET; public static MethodHandle WICKRA_SHARPE_RATIO_FREE; public static MethodHandle WICKRA_SINE_WAVE_NEW; public static MethodHandle WICKRA_SINE_WAVE_UPDATE; public static MethodHandle WICKRA_SINE_WAVE_BATCH; + public static MethodHandle WICKRA_SINE_WAVE_WARMUP_PERIOD; + public static MethodHandle WICKRA_SINE_WAVE_IS_READY; public static MethodHandle WICKRA_SINE_WAVE_RESET; public static MethodHandle WICKRA_SINE_WAVE_FREE; public static MethodHandle WICKRA_SINE_WEIGHTED_MA_NEW; public static MethodHandle WICKRA_SINE_WEIGHTED_MA_UPDATE; public static MethodHandle WICKRA_SINE_WEIGHTED_MA_BATCH; + public static MethodHandle WICKRA_SINE_WEIGHTED_MA_WARMUP_PERIOD; + public static MethodHandle WICKRA_SINE_WEIGHTED_MA_IS_READY; public static MethodHandle WICKRA_SINE_WEIGHTED_MA_RESET; public static MethodHandle WICKRA_SINE_WEIGHTED_MA_FREE; public static MethodHandle WICKRA_SKEWNESS_NEW; public static MethodHandle WICKRA_SKEWNESS_UPDATE; public static MethodHandle WICKRA_SKEWNESS_BATCH; + public static MethodHandle WICKRA_SKEWNESS_WARMUP_PERIOD; + public static MethodHandle WICKRA_SKEWNESS_IS_READY; public static MethodHandle WICKRA_SKEWNESS_RESET; public static MethodHandle WICKRA_SKEWNESS_FREE; public static MethodHandle WICKRA_SMA_NEW; public static MethodHandle WICKRA_SMA_UPDATE; public static MethodHandle WICKRA_SMA_BATCH; + public static MethodHandle WICKRA_SMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_SMA_IS_READY; public static MethodHandle WICKRA_SMA_RESET; public static MethodHandle WICKRA_SMA_FREE; public static MethodHandle WICKRA_SMMA_NEW; public static MethodHandle WICKRA_SMMA_UPDATE; public static MethodHandle WICKRA_SMMA_BATCH; + public static MethodHandle WICKRA_SMMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_SMMA_IS_READY; public static MethodHandle WICKRA_SMMA_RESET; public static MethodHandle WICKRA_SMMA_FREE; public static MethodHandle WICKRA_SORTINO_RATIO_NEW; public static MethodHandle WICKRA_SORTINO_RATIO_UPDATE; public static MethodHandle WICKRA_SORTINO_RATIO_BATCH; + public static MethodHandle WICKRA_SORTINO_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_SORTINO_RATIO_IS_READY; public static MethodHandle WICKRA_SORTINO_RATIO_RESET; public static MethodHandle WICKRA_SORTINO_RATIO_FREE; public static MethodHandle WICKRA_STANDARD_ERROR_NEW; public static MethodHandle WICKRA_STANDARD_ERROR_UPDATE; public static MethodHandle WICKRA_STANDARD_ERROR_BATCH; + public static MethodHandle WICKRA_STANDARD_ERROR_WARMUP_PERIOD; + public static MethodHandle WICKRA_STANDARD_ERROR_IS_READY; public static MethodHandle WICKRA_STANDARD_ERROR_RESET; public static MethodHandle WICKRA_STANDARD_ERROR_FREE; public static MethodHandle WICKRA_STC_NEW; public static MethodHandle WICKRA_STC_UPDATE; public static MethodHandle WICKRA_STC_BATCH; + public static MethodHandle WICKRA_STC_WARMUP_PERIOD; + public static MethodHandle WICKRA_STC_IS_READY; public static MethodHandle WICKRA_STC_RESET; public static MethodHandle WICKRA_STC_FREE; public static MethodHandle WICKRA_STD_DEV_NEW; public static MethodHandle WICKRA_STD_DEV_UPDATE; public static MethodHandle WICKRA_STD_DEV_BATCH; + public static MethodHandle WICKRA_STD_DEV_WARMUP_PERIOD; + public static MethodHandle WICKRA_STD_DEV_IS_READY; public static MethodHandle WICKRA_STD_DEV_RESET; public static MethodHandle WICKRA_STD_DEV_FREE; public static MethodHandle WICKRA_STEP_TRAILING_STOP_NEW; public static MethodHandle WICKRA_STEP_TRAILING_STOP_UPDATE; public static MethodHandle WICKRA_STEP_TRAILING_STOP_BATCH; + public static MethodHandle WICKRA_STEP_TRAILING_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_STEP_TRAILING_STOP_IS_READY; public static MethodHandle WICKRA_STEP_TRAILING_STOP_RESET; public static MethodHandle WICKRA_STEP_TRAILING_STOP_FREE; public static MethodHandle WICKRA_STERLING_RATIO_NEW; public static MethodHandle WICKRA_STERLING_RATIO_UPDATE; public static MethodHandle WICKRA_STERLING_RATIO_BATCH; + public static MethodHandle WICKRA_STERLING_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_STERLING_RATIO_IS_READY; public static MethodHandle WICKRA_STERLING_RATIO_RESET; public static MethodHandle WICKRA_STERLING_RATIO_FREE; public static MethodHandle WICKRA_STOCH_RSI_NEW; public static MethodHandle WICKRA_STOCH_RSI_UPDATE; public static MethodHandle WICKRA_STOCH_RSI_BATCH; + public static MethodHandle WICKRA_STOCH_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_STOCH_RSI_IS_READY; public static MethodHandle WICKRA_STOCH_RSI_RESET; public static MethodHandle WICKRA_STOCH_RSI_FREE; public static MethodHandle WICKRA_SUPER_SMOOTHER_NEW; public static MethodHandle WICKRA_SUPER_SMOOTHER_UPDATE; public static MethodHandle WICKRA_SUPER_SMOOTHER_BATCH; + public static MethodHandle WICKRA_SUPER_SMOOTHER_WARMUP_PERIOD; + public static MethodHandle WICKRA_SUPER_SMOOTHER_IS_READY; public static MethodHandle WICKRA_SUPER_SMOOTHER_RESET; public static MethodHandle WICKRA_SUPER_SMOOTHER_FREE; public static MethodHandle WICKRA_T3_NEW; public static MethodHandle WICKRA_T3_UPDATE; public static MethodHandle WICKRA_T3_BATCH; + public static MethodHandle WICKRA_T3_WARMUP_PERIOD; + public static MethodHandle WICKRA_T3_IS_READY; public static MethodHandle WICKRA_T3_RESET; public static MethodHandle WICKRA_T3_FREE; public static MethodHandle WICKRA_TAIL_RATIO_NEW; public static MethodHandle WICKRA_TAIL_RATIO_UPDATE; public static MethodHandle WICKRA_TAIL_RATIO_BATCH; + public static MethodHandle WICKRA_TAIL_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_TAIL_RATIO_IS_READY; public static MethodHandle WICKRA_TAIL_RATIO_RESET; public static MethodHandle WICKRA_TAIL_RATIO_FREE; public static MethodHandle WICKRA_TEMA_NEW; public static MethodHandle WICKRA_TEMA_UPDATE; public static MethodHandle WICKRA_TEMA_BATCH; + public static MethodHandle WICKRA_TEMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_TEMA_IS_READY; public static MethodHandle WICKRA_TEMA_RESET; public static MethodHandle WICKRA_TEMA_FREE; public static MethodHandle WICKRA_TII_NEW; public static MethodHandle WICKRA_TII_UPDATE; public static MethodHandle WICKRA_TII_BATCH; + public static MethodHandle WICKRA_TII_WARMUP_PERIOD; + public static MethodHandle WICKRA_TII_IS_READY; public static MethodHandle WICKRA_TII_RESET; public static MethodHandle WICKRA_TII_FREE; public static MethodHandle WICKRA_TREND_LABEL_NEW; public static MethodHandle WICKRA_TREND_LABEL_UPDATE; public static MethodHandle WICKRA_TREND_LABEL_BATCH; + public static MethodHandle WICKRA_TREND_LABEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_TREND_LABEL_IS_READY; public static MethodHandle WICKRA_TREND_LABEL_RESET; public static MethodHandle WICKRA_TREND_LABEL_FREE; public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_NEW; public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_UPDATE; public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_BATCH; + public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_IS_READY; public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_RESET; public static MethodHandle WICKRA_TREND_STRENGTH_INDEX_FREE; public static MethodHandle WICKRA_TRENDFLEX_NEW; public static MethodHandle WICKRA_TRENDFLEX_UPDATE; public static MethodHandle WICKRA_TRENDFLEX_BATCH; + public static MethodHandle WICKRA_TRENDFLEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRENDFLEX_IS_READY; public static MethodHandle WICKRA_TRENDFLEX_RESET; public static MethodHandle WICKRA_TRENDFLEX_FREE; public static MethodHandle WICKRA_TRIMA_NEW; public static MethodHandle WICKRA_TRIMA_UPDATE; public static MethodHandle WICKRA_TRIMA_BATCH; + public static MethodHandle WICKRA_TRIMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRIMA_IS_READY; public static MethodHandle WICKRA_TRIMA_RESET; public static MethodHandle WICKRA_TRIMA_FREE; public static MethodHandle WICKRA_TRIX_NEW; public static MethodHandle WICKRA_TRIX_UPDATE; public static MethodHandle WICKRA_TRIX_BATCH; + public static MethodHandle WICKRA_TRIX_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRIX_IS_READY; public static MethodHandle WICKRA_TRIX_RESET; public static MethodHandle WICKRA_TRIX_FREE; public static MethodHandle WICKRA_TSF_NEW; public static MethodHandle WICKRA_TSF_UPDATE; public static MethodHandle WICKRA_TSF_BATCH; + public static MethodHandle WICKRA_TSF_WARMUP_PERIOD; + public static MethodHandle WICKRA_TSF_IS_READY; public static MethodHandle WICKRA_TSF_RESET; public static MethodHandle WICKRA_TSF_FREE; public static MethodHandle WICKRA_TSF_OSCILLATOR_NEW; public static MethodHandle WICKRA_TSF_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_TSF_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_TSF_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_TSF_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_TSF_OSCILLATOR_RESET; public static MethodHandle WICKRA_TSF_OSCILLATOR_FREE; public static MethodHandle WICKRA_TSI_NEW; public static MethodHandle WICKRA_TSI_UPDATE; public static MethodHandle WICKRA_TSI_BATCH; + public static MethodHandle WICKRA_TSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_TSI_IS_READY; public static MethodHandle WICKRA_TSI_RESET; public static MethodHandle WICKRA_TSI_FREE; public static MethodHandle WICKRA_ULCER_INDEX_NEW; public static MethodHandle WICKRA_ULCER_INDEX_UPDATE; public static MethodHandle WICKRA_ULCER_INDEX_BATCH; + public static MethodHandle WICKRA_ULCER_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_ULCER_INDEX_IS_READY; public static MethodHandle WICKRA_ULCER_INDEX_RESET; public static MethodHandle WICKRA_ULCER_INDEX_FREE; public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_NEW; public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_RESET; public static MethodHandle WICKRA_UNIVERSAL_OSCILLATOR_FREE; public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_NEW; public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_UPDATE; public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_BATCH; + public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_IS_READY; public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_RESET; public static MethodHandle WICKRA_UPSIDE_POTENTIAL_RATIO_FREE; public static MethodHandle WICKRA_VALUE_AT_RISK_NEW; public static MethodHandle WICKRA_VALUE_AT_RISK_UPDATE; public static MethodHandle WICKRA_VALUE_AT_RISK_BATCH; + public static MethodHandle WICKRA_VALUE_AT_RISK_WARMUP_PERIOD; + public static MethodHandle WICKRA_VALUE_AT_RISK_IS_READY; public static MethodHandle WICKRA_VALUE_AT_RISK_RESET; public static MethodHandle WICKRA_VALUE_AT_RISK_FREE; public static MethodHandle WICKRA_VARIANCE_NEW; public static MethodHandle WICKRA_VARIANCE_UPDATE; public static MethodHandle WICKRA_VARIANCE_BATCH; + public static MethodHandle WICKRA_VARIANCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_VARIANCE_IS_READY; public static MethodHandle WICKRA_VARIANCE_RESET; public static MethodHandle WICKRA_VARIANCE_FREE; public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_NEW; public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_UPDATE; public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_BATCH; + public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_WARMUP_PERIOD; + public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_IS_READY; public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_RESET; public static MethodHandle WICKRA_VERTICAL_HORIZONTAL_FILTER_FREE; public static MethodHandle WICKRA_VIDYA_NEW; public static MethodHandle WICKRA_VIDYA_UPDATE; public static MethodHandle WICKRA_VIDYA_BATCH; + public static MethodHandle WICKRA_VIDYA_WARMUP_PERIOD; + public static MethodHandle WICKRA_VIDYA_IS_READY; public static MethodHandle WICKRA_VIDYA_RESET; public static MethodHandle WICKRA_VIDYA_FREE; public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_NEW; public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_UPDATE; public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_BATCH; + public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_IS_READY; public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_RESET; public static MethodHandle WICKRA_VOLATILITY_OF_VOLATILITY_FREE; public static MethodHandle WICKRA_WAVE_PM_NEW; public static MethodHandle WICKRA_WAVE_PM_UPDATE; public static MethodHandle WICKRA_WAVE_PM_BATCH; + public static MethodHandle WICKRA_WAVE_PM_WARMUP_PERIOD; + public static MethodHandle WICKRA_WAVE_PM_IS_READY; public static MethodHandle WICKRA_WAVE_PM_RESET; public static MethodHandle WICKRA_WAVE_PM_FREE; public static MethodHandle WICKRA_WIN_RATE_NEW; public static MethodHandle WICKRA_WIN_RATE_UPDATE; public static MethodHandle WICKRA_WIN_RATE_BATCH; + public static MethodHandle WICKRA_WIN_RATE_WARMUP_PERIOD; + public static MethodHandle WICKRA_WIN_RATE_IS_READY; public static MethodHandle WICKRA_WIN_RATE_RESET; public static MethodHandle WICKRA_WIN_RATE_FREE; public static MethodHandle WICKRA_WMA_NEW; public static MethodHandle WICKRA_WMA_UPDATE; public static MethodHandle WICKRA_WMA_BATCH; + public static MethodHandle WICKRA_WMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_WMA_IS_READY; public static MethodHandle WICKRA_WMA_RESET; public static MethodHandle WICKRA_WMA_FREE; public static MethodHandle WICKRA_Z_SCORE_NEW; public static MethodHandle WICKRA_Z_SCORE_UPDATE; public static MethodHandle WICKRA_Z_SCORE_BATCH; + public static MethodHandle WICKRA_Z_SCORE_WARMUP_PERIOD; + public static MethodHandle WICKRA_Z_SCORE_IS_READY; public static MethodHandle WICKRA_Z_SCORE_RESET; public static MethodHandle WICKRA_Z_SCORE_FREE; public static MethodHandle WICKRA_ZLEMA_NEW; public static MethodHandle WICKRA_ZLEMA_UPDATE; public static MethodHandle WICKRA_ZLEMA_BATCH; + public static MethodHandle WICKRA_ZLEMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_ZLEMA_IS_READY; public static MethodHandle WICKRA_ZLEMA_RESET; public static MethodHandle WICKRA_ZLEMA_FREE; public static MethodHandle WICKRA_ALPHA_NEW; public static MethodHandle WICKRA_ALPHA_UPDATE; public static MethodHandle WICKRA_ALPHA_BATCH; + public static MethodHandle WICKRA_ALPHA_WARMUP_PERIOD; + public static MethodHandle WICKRA_ALPHA_IS_READY; public static MethodHandle WICKRA_ALPHA_RESET; public static MethodHandle WICKRA_ALPHA_FREE; public static MethodHandle WICKRA_BETA_NEW; public static MethodHandle WICKRA_BETA_UPDATE; public static MethodHandle WICKRA_BETA_BATCH; + public static MethodHandle WICKRA_BETA_WARMUP_PERIOD; + public static MethodHandle WICKRA_BETA_IS_READY; public static MethodHandle WICKRA_BETA_RESET; public static MethodHandle WICKRA_BETA_FREE; public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_NEW; public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_UPDATE; public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_BATCH; + public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_WARMUP_PERIOD; + public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_IS_READY; public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_RESET; public static MethodHandle WICKRA_BETA_NEUTRAL_SPREAD_FREE; public static MethodHandle WICKRA_DISTANCE_SSD_NEW; public static MethodHandle WICKRA_DISTANCE_SSD_UPDATE; public static MethodHandle WICKRA_DISTANCE_SSD_BATCH; + public static MethodHandle WICKRA_DISTANCE_SSD_WARMUP_PERIOD; + public static MethodHandle WICKRA_DISTANCE_SSD_IS_READY; public static MethodHandle WICKRA_DISTANCE_SSD_RESET; public static MethodHandle WICKRA_DISTANCE_SSD_FREE; public static MethodHandle WICKRA_GRANGER_CAUSALITY_NEW; public static MethodHandle WICKRA_GRANGER_CAUSALITY_UPDATE; public static MethodHandle WICKRA_GRANGER_CAUSALITY_BATCH; + public static MethodHandle WICKRA_GRANGER_CAUSALITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_GRANGER_CAUSALITY_IS_READY; public static MethodHandle WICKRA_GRANGER_CAUSALITY_RESET; public static MethodHandle WICKRA_GRANGER_CAUSALITY_FREE; public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_NEW; public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_UPDATE; public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_BATCH; + public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_IS_READY; public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_RESET; public static MethodHandle WICKRA_HASBROUCK_INFORMATION_SHARE_FREE; public static MethodHandle WICKRA_INFORMATION_RATIO_NEW; public static MethodHandle WICKRA_INFORMATION_RATIO_UPDATE; public static MethodHandle WICKRA_INFORMATION_RATIO_BATCH; + public static MethodHandle WICKRA_INFORMATION_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_INFORMATION_RATIO_IS_READY; public static MethodHandle WICKRA_INFORMATION_RATIO_RESET; public static MethodHandle WICKRA_INFORMATION_RATIO_FREE; public static MethodHandle WICKRA_KENDALL_TAU_NEW; public static MethodHandle WICKRA_KENDALL_TAU_UPDATE; public static MethodHandle WICKRA_KENDALL_TAU_BATCH; + public static MethodHandle WICKRA_KENDALL_TAU_WARMUP_PERIOD; + public static MethodHandle WICKRA_KENDALL_TAU_IS_READY; public static MethodHandle WICKRA_KENDALL_TAU_RESET; public static MethodHandle WICKRA_KENDALL_TAU_FREE; public static MethodHandle WICKRA_OU_HALF_LIFE_NEW; public static MethodHandle WICKRA_OU_HALF_LIFE_UPDATE; public static MethodHandle WICKRA_OU_HALF_LIFE_BATCH; + public static MethodHandle WICKRA_OU_HALF_LIFE_WARMUP_PERIOD; + public static MethodHandle WICKRA_OU_HALF_LIFE_IS_READY; public static MethodHandle WICKRA_OU_HALF_LIFE_RESET; public static MethodHandle WICKRA_OU_HALF_LIFE_FREE; public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_NEW; public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_UPDATE; public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_BATCH; + public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_WARMUP_PERIOD; + public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_IS_READY; public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_RESET; public static MethodHandle WICKRA_PAIR_SPREAD_Z_SCORE_FREE; public static MethodHandle WICKRA_PAIRWISE_BETA_NEW; public static MethodHandle WICKRA_PAIRWISE_BETA_UPDATE; public static MethodHandle WICKRA_PAIRWISE_BETA_BATCH; + public static MethodHandle WICKRA_PAIRWISE_BETA_WARMUP_PERIOD; + public static MethodHandle WICKRA_PAIRWISE_BETA_IS_READY; public static MethodHandle WICKRA_PAIRWISE_BETA_RESET; public static MethodHandle WICKRA_PAIRWISE_BETA_FREE; public static MethodHandle WICKRA_PEARSON_CORRELATION_NEW; public static MethodHandle WICKRA_PEARSON_CORRELATION_UPDATE; public static MethodHandle WICKRA_PEARSON_CORRELATION_BATCH; + public static MethodHandle WICKRA_PEARSON_CORRELATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_PEARSON_CORRELATION_IS_READY; public static MethodHandle WICKRA_PEARSON_CORRELATION_RESET; public static MethodHandle WICKRA_PEARSON_CORRELATION_FREE; public static MethodHandle WICKRA_ROLLING_CORRELATION_NEW; public static MethodHandle WICKRA_ROLLING_CORRELATION_UPDATE; public static MethodHandle WICKRA_ROLLING_CORRELATION_BATCH; + public static MethodHandle WICKRA_ROLLING_CORRELATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_CORRELATION_IS_READY; public static MethodHandle WICKRA_ROLLING_CORRELATION_RESET; public static MethodHandle WICKRA_ROLLING_CORRELATION_FREE; public static MethodHandle WICKRA_ROLLING_COVARIANCE_NEW; public static MethodHandle WICKRA_ROLLING_COVARIANCE_UPDATE; public static MethodHandle WICKRA_ROLLING_COVARIANCE_BATCH; + public static MethodHandle WICKRA_ROLLING_COVARIANCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_COVARIANCE_IS_READY; public static MethodHandle WICKRA_ROLLING_COVARIANCE_RESET; public static MethodHandle WICKRA_ROLLING_COVARIANCE_FREE; public static MethodHandle WICKRA_SPEARMAN_CORRELATION_NEW; public static MethodHandle WICKRA_SPEARMAN_CORRELATION_UPDATE; public static MethodHandle WICKRA_SPEARMAN_CORRELATION_BATCH; + public static MethodHandle WICKRA_SPEARMAN_CORRELATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_SPEARMAN_CORRELATION_IS_READY; public static MethodHandle WICKRA_SPEARMAN_CORRELATION_RESET; public static MethodHandle WICKRA_SPEARMAN_CORRELATION_FREE; public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_NEW; public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_UPDATE; public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_BATCH; + public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_WARMUP_PERIOD; + public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_IS_READY; public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_RESET; public static MethodHandle WICKRA_SPREAD_AR1_COEFFICIENT_FREE; public static MethodHandle WICKRA_SPREAD_HURST_NEW; public static MethodHandle WICKRA_SPREAD_HURST_UPDATE; public static MethodHandle WICKRA_SPREAD_HURST_BATCH; + public static MethodHandle WICKRA_SPREAD_HURST_WARMUP_PERIOD; + public static MethodHandle WICKRA_SPREAD_HURST_IS_READY; public static MethodHandle WICKRA_SPREAD_HURST_RESET; public static MethodHandle WICKRA_SPREAD_HURST_FREE; public static MethodHandle WICKRA_TREYNOR_RATIO_NEW; public static MethodHandle WICKRA_TREYNOR_RATIO_UPDATE; public static MethodHandle WICKRA_TREYNOR_RATIO_BATCH; + public static MethodHandle WICKRA_TREYNOR_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_TREYNOR_RATIO_IS_READY; public static MethodHandle WICKRA_TREYNOR_RATIO_RESET; public static MethodHandle WICKRA_TREYNOR_RATIO_FREE; public static MethodHandle WICKRA_VARIANCE_RATIO_NEW; public static MethodHandle WICKRA_VARIANCE_RATIO_UPDATE; public static MethodHandle WICKRA_VARIANCE_RATIO_BATCH; + public static MethodHandle WICKRA_VARIANCE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_VARIANCE_RATIO_IS_READY; public static MethodHandle WICKRA_VARIANCE_RATIO_RESET; public static MethodHandle WICKRA_VARIANCE_RATIO_FREE; public static MethodHandle WICKRA_ABANDONED_BABY_NEW; public static MethodHandle WICKRA_ABANDONED_BABY_UPDATE; public static MethodHandle WICKRA_ABANDONED_BABY_BATCH; + public static MethodHandle WICKRA_ABANDONED_BABY_WARMUP_PERIOD; + public static MethodHandle WICKRA_ABANDONED_BABY_IS_READY; public static MethodHandle WICKRA_ABANDONED_BABY_RESET; public static MethodHandle WICKRA_ABANDONED_BABY_FREE; public static MethodHandle WICKRA_ABCD_NEW; public static MethodHandle WICKRA_ABCD_UPDATE; public static MethodHandle WICKRA_ABCD_BATCH; + public static MethodHandle WICKRA_ABCD_WARMUP_PERIOD; + public static MethodHandle WICKRA_ABCD_IS_READY; public static MethodHandle WICKRA_ABCD_RESET; public static MethodHandle WICKRA_ABCD_FREE; public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_NEW; public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_RESET; public static MethodHandle WICKRA_ACCELERATOR_OSCILLATOR_FREE; public static MethodHandle WICKRA_AD_OSCILLATOR_NEW; public static MethodHandle WICKRA_AD_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_AD_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_AD_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_AD_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_AD_OSCILLATOR_RESET; public static MethodHandle WICKRA_AD_OSCILLATOR_FREE; public static MethodHandle WICKRA_ADAPTIVE_CCI_NEW; public static MethodHandle WICKRA_ADAPTIVE_CCI_UPDATE; public static MethodHandle WICKRA_ADAPTIVE_CCI_BATCH; + public static MethodHandle WICKRA_ADAPTIVE_CCI_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADAPTIVE_CCI_IS_READY; public static MethodHandle WICKRA_ADAPTIVE_CCI_RESET; public static MethodHandle WICKRA_ADAPTIVE_CCI_FREE; public static MethodHandle WICKRA_ADL_NEW; public static MethodHandle WICKRA_ADL_UPDATE; public static MethodHandle WICKRA_ADL_BATCH; + public static MethodHandle WICKRA_ADL_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADL_IS_READY; public static MethodHandle WICKRA_ADL_RESET; public static MethodHandle WICKRA_ADL_FREE; public static MethodHandle WICKRA_ADVANCE_BLOCK_NEW; public static MethodHandle WICKRA_ADVANCE_BLOCK_UPDATE; public static MethodHandle WICKRA_ADVANCE_BLOCK_BATCH; + public static MethodHandle WICKRA_ADVANCE_BLOCK_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADVANCE_BLOCK_IS_READY; public static MethodHandle WICKRA_ADVANCE_BLOCK_RESET; public static MethodHandle WICKRA_ADVANCE_BLOCK_FREE; public static MethodHandle WICKRA_ADXR_NEW; public static MethodHandle WICKRA_ADXR_UPDATE; public static MethodHandle WICKRA_ADXR_BATCH; + public static MethodHandle WICKRA_ADXR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADXR_IS_READY; public static MethodHandle WICKRA_ADXR_RESET; public static MethodHandle WICKRA_ADXR_FREE; public static MethodHandle WICKRA_ANCHORED_VWAP_NEW; public static MethodHandle WICKRA_ANCHORED_VWAP_UPDATE; public static MethodHandle WICKRA_ANCHORED_VWAP_BATCH; + public static MethodHandle WICKRA_ANCHORED_VWAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_ANCHORED_VWAP_IS_READY; public static MethodHandle WICKRA_ANCHORED_VWAP_RESET; public static MethodHandle WICKRA_ANCHORED_VWAP_FREE; public static MethodHandle WICKRA_AROON_OSCILLATOR_NEW; public static MethodHandle WICKRA_AROON_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_AROON_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_AROON_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_AROON_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_AROON_OSCILLATOR_RESET; public static MethodHandle WICKRA_AROON_OSCILLATOR_FREE; public static MethodHandle WICKRA_ATR_NEW; public static MethodHandle WICKRA_ATR_UPDATE; public static MethodHandle WICKRA_ATR_BATCH; + public static MethodHandle WICKRA_ATR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ATR_IS_READY; public static MethodHandle WICKRA_ATR_RESET; public static MethodHandle WICKRA_ATR_FREE; public static MethodHandle WICKRA_ATR_TRAILING_STOP_NEW; public static MethodHandle WICKRA_ATR_TRAILING_STOP_UPDATE; public static MethodHandle WICKRA_ATR_TRAILING_STOP_BATCH; + public static MethodHandle WICKRA_ATR_TRAILING_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_ATR_TRAILING_STOP_IS_READY; public static MethodHandle WICKRA_ATR_TRAILING_STOP_RESET; public static MethodHandle WICKRA_ATR_TRAILING_STOP_FREE; public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_NEW; public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_UPDATE; public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_BATCH; + public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_IS_READY; public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_RESET; public static MethodHandle WICKRA_AVERAGE_DAILY_RANGE_FREE; public static MethodHandle WICKRA_AVG_PRICE_NEW; public static MethodHandle WICKRA_AVG_PRICE_UPDATE; public static MethodHandle WICKRA_AVG_PRICE_BATCH; + public static MethodHandle WICKRA_AVG_PRICE_WARMUP_PERIOD; + public static MethodHandle WICKRA_AVG_PRICE_IS_READY; public static MethodHandle WICKRA_AVG_PRICE_RESET; public static MethodHandle WICKRA_AVG_PRICE_FREE; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_NEW; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_AWESOME_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_AWESOME_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_RESET; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_FREE; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NEW; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_UPDATE; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_BATCH; + public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_WARMUP_PERIOD; + public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_IS_READY; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_RESET; public static MethodHandle WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_FREE; public static MethodHandle WICKRA_BALANCE_OF_POWER_NEW; public static MethodHandle WICKRA_BALANCE_OF_POWER_UPDATE; public static MethodHandle WICKRA_BALANCE_OF_POWER_BATCH; + public static MethodHandle WICKRA_BALANCE_OF_POWER_WARMUP_PERIOD; + public static MethodHandle WICKRA_BALANCE_OF_POWER_IS_READY; public static MethodHandle WICKRA_BALANCE_OF_POWER_RESET; public static MethodHandle WICKRA_BALANCE_OF_POWER_FREE; public static MethodHandle WICKRA_BAT_NEW; public static MethodHandle WICKRA_BAT_UPDATE; public static MethodHandle WICKRA_BAT_BATCH; + public static MethodHandle WICKRA_BAT_WARMUP_PERIOD; + public static MethodHandle WICKRA_BAT_IS_READY; public static MethodHandle WICKRA_BAT_RESET; public static MethodHandle WICKRA_BAT_FREE; public static MethodHandle WICKRA_BELT_HOLD_NEW; public static MethodHandle WICKRA_BELT_HOLD_UPDATE; public static MethodHandle WICKRA_BELT_HOLD_BATCH; + public static MethodHandle WICKRA_BELT_HOLD_WARMUP_PERIOD; + public static MethodHandle WICKRA_BELT_HOLD_IS_READY; public static MethodHandle WICKRA_BELT_HOLD_RESET; public static MethodHandle WICKRA_BELT_HOLD_FREE; public static MethodHandle WICKRA_BETTER_VOLUME_NEW; public static MethodHandle WICKRA_BETTER_VOLUME_UPDATE; public static MethodHandle WICKRA_BETTER_VOLUME_BATCH; + public static MethodHandle WICKRA_BETTER_VOLUME_WARMUP_PERIOD; + public static MethodHandle WICKRA_BETTER_VOLUME_IS_READY; public static MethodHandle WICKRA_BETTER_VOLUME_RESET; public static MethodHandle WICKRA_BETTER_VOLUME_FREE; public static MethodHandle WICKRA_BODY_SIZE_PCT_NEW; public static MethodHandle WICKRA_BODY_SIZE_PCT_UPDATE; public static MethodHandle WICKRA_BODY_SIZE_PCT_BATCH; + public static MethodHandle WICKRA_BODY_SIZE_PCT_WARMUP_PERIOD; + public static MethodHandle WICKRA_BODY_SIZE_PCT_IS_READY; public static MethodHandle WICKRA_BODY_SIZE_PCT_RESET; public static MethodHandle WICKRA_BODY_SIZE_PCT_FREE; public static MethodHandle WICKRA_BREAKAWAY_NEW; public static MethodHandle WICKRA_BREAKAWAY_UPDATE; public static MethodHandle WICKRA_BREAKAWAY_BATCH; + public static MethodHandle WICKRA_BREAKAWAY_WARMUP_PERIOD; + public static MethodHandle WICKRA_BREAKAWAY_IS_READY; public static MethodHandle WICKRA_BREAKAWAY_RESET; public static MethodHandle WICKRA_BREAKAWAY_FREE; public static MethodHandle WICKRA_BUTTERFLY_NEW; public static MethodHandle WICKRA_BUTTERFLY_UPDATE; public static MethodHandle WICKRA_BUTTERFLY_BATCH; + public static MethodHandle WICKRA_BUTTERFLY_WARMUP_PERIOD; + public static MethodHandle WICKRA_BUTTERFLY_IS_READY; public static MethodHandle WICKRA_BUTTERFLY_RESET; public static MethodHandle WICKRA_BUTTERFLY_FREE; public static MethodHandle WICKRA_CCI_NEW; public static MethodHandle WICKRA_CCI_UPDATE; public static MethodHandle WICKRA_CCI_BATCH; + public static MethodHandle WICKRA_CCI_WARMUP_PERIOD; + public static MethodHandle WICKRA_CCI_IS_READY; public static MethodHandle WICKRA_CCI_RESET; public static MethodHandle WICKRA_CCI_FREE; public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_NEW; public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_RESET; public static MethodHandle WICKRA_CHAIKIN_OSCILLATOR_FREE; public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_NEW; public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_UPDATE; public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_BATCH; + public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_IS_READY; public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_RESET; public static MethodHandle WICKRA_CHAIKIN_VOLATILITY_FREE; public static MethodHandle WICKRA_CHOPPINESS_INDEX_NEW; public static MethodHandle WICKRA_CHOPPINESS_INDEX_UPDATE; public static MethodHandle WICKRA_CHOPPINESS_INDEX_BATCH; + public static MethodHandle WICKRA_CHOPPINESS_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_CHOPPINESS_INDEX_IS_READY; public static MethodHandle WICKRA_CHOPPINESS_INDEX_RESET; public static MethodHandle WICKRA_CHOPPINESS_INDEX_FREE; public static MethodHandle WICKRA_CLOSE_VS_OPEN_NEW; public static MethodHandle WICKRA_CLOSE_VS_OPEN_UPDATE; public static MethodHandle WICKRA_CLOSE_VS_OPEN_BATCH; + public static MethodHandle WICKRA_CLOSE_VS_OPEN_WARMUP_PERIOD; + public static MethodHandle WICKRA_CLOSE_VS_OPEN_IS_READY; public static MethodHandle WICKRA_CLOSE_VS_OPEN_RESET; public static MethodHandle WICKRA_CLOSE_VS_OPEN_FREE; public static MethodHandle WICKRA_CLOSING_MARUBOZU_NEW; public static MethodHandle WICKRA_CLOSING_MARUBOZU_UPDATE; public static MethodHandle WICKRA_CLOSING_MARUBOZU_BATCH; + public static MethodHandle WICKRA_CLOSING_MARUBOZU_WARMUP_PERIOD; + public static MethodHandle WICKRA_CLOSING_MARUBOZU_IS_READY; public static MethodHandle WICKRA_CLOSING_MARUBOZU_RESET; public static MethodHandle WICKRA_CLOSING_MARUBOZU_FREE; public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_NEW; public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_UPDATE; public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_BATCH; + public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_WARMUP_PERIOD; + public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_IS_READY; public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_RESET; public static MethodHandle WICKRA_CHAIKIN_MONEY_FLOW_FREE; public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_NEW; public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_UPDATE; public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_BATCH; + public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_WARMUP_PERIOD; + public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_IS_READY; public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_RESET; public static MethodHandle WICKRA_CONCEALING_BABY_SWALLOW_FREE; public static MethodHandle WICKRA_COUNTERATTACK_NEW; public static MethodHandle WICKRA_COUNTERATTACK_UPDATE; public static MethodHandle WICKRA_COUNTERATTACK_BATCH; + public static MethodHandle WICKRA_COUNTERATTACK_WARMUP_PERIOD; + public static MethodHandle WICKRA_COUNTERATTACK_IS_READY; public static MethodHandle WICKRA_COUNTERATTACK_RESET; public static MethodHandle WICKRA_COUNTERATTACK_FREE; public static MethodHandle WICKRA_CRAB_NEW; public static MethodHandle WICKRA_CRAB_UPDATE; public static MethodHandle WICKRA_CRAB_BATCH; + public static MethodHandle WICKRA_CRAB_WARMUP_PERIOD; + public static MethodHandle WICKRA_CRAB_IS_READY; public static MethodHandle WICKRA_CRAB_RESET; public static MethodHandle WICKRA_CRAB_FREE; public static MethodHandle WICKRA_CUP_AND_HANDLE_NEW; public static MethodHandle WICKRA_CUP_AND_HANDLE_UPDATE; public static MethodHandle WICKRA_CUP_AND_HANDLE_BATCH; + public static MethodHandle WICKRA_CUP_AND_HANDLE_WARMUP_PERIOD; + public static MethodHandle WICKRA_CUP_AND_HANDLE_IS_READY; public static MethodHandle WICKRA_CUP_AND_HANDLE_RESET; public static MethodHandle WICKRA_CUP_AND_HANDLE_FREE; public static MethodHandle WICKRA_CYPHER_NEW; public static MethodHandle WICKRA_CYPHER_UPDATE; public static MethodHandle WICKRA_CYPHER_BATCH; + public static MethodHandle WICKRA_CYPHER_WARMUP_PERIOD; + public static MethodHandle WICKRA_CYPHER_IS_READY; public static MethodHandle WICKRA_CYPHER_RESET; public static MethodHandle WICKRA_CYPHER_FREE; public static MethodHandle WICKRA_DEMAND_INDEX_NEW; public static MethodHandle WICKRA_DEMAND_INDEX_UPDATE; public static MethodHandle WICKRA_DEMAND_INDEX_BATCH; + public static MethodHandle WICKRA_DEMAND_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_DEMAND_INDEX_IS_READY; public static MethodHandle WICKRA_DEMAND_INDEX_RESET; public static MethodHandle WICKRA_DEMAND_INDEX_FREE; public static MethodHandle WICKRA_DOJI_NEW; public static MethodHandle WICKRA_DOJI_UPDATE; public static MethodHandle WICKRA_DOJI_BATCH; + public static MethodHandle WICKRA_DOJI_WARMUP_PERIOD; + public static MethodHandle WICKRA_DOJI_IS_READY; public static MethodHandle WICKRA_DOJI_RESET; public static MethodHandle WICKRA_DOJI_FREE; public static MethodHandle WICKRA_DOJI_STAR_NEW; public static MethodHandle WICKRA_DOJI_STAR_UPDATE; public static MethodHandle WICKRA_DOJI_STAR_BATCH; + public static MethodHandle WICKRA_DOJI_STAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_DOJI_STAR_IS_READY; public static MethodHandle WICKRA_DOJI_STAR_RESET; public static MethodHandle WICKRA_DOJI_STAR_FREE; public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_NEW; public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_UPDATE; public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_BATCH; + public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_WARMUP_PERIOD; + public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_IS_READY; public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_RESET; public static MethodHandle WICKRA_DOUBLE_TOP_BOTTOM_FREE; public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_NEW; public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_UPDATE; public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_BATCH; + public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_WARMUP_PERIOD; + public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_IS_READY; public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_RESET; public static MethodHandle WICKRA_DOWNSIDE_GAP_THREE_METHODS_FREE; public static MethodHandle WICKRA_DRAGONFLY_DOJI_NEW; public static MethodHandle WICKRA_DRAGONFLY_DOJI_UPDATE; public static MethodHandle WICKRA_DRAGONFLY_DOJI_BATCH; + public static MethodHandle WICKRA_DRAGONFLY_DOJI_WARMUP_PERIOD; + public static MethodHandle WICKRA_DRAGONFLY_DOJI_IS_READY; public static MethodHandle WICKRA_DRAGONFLY_DOJI_RESET; public static MethodHandle WICKRA_DRAGONFLY_DOJI_FREE; public static MethodHandle WICKRA_DUMPLING_TOP_NEW; public static MethodHandle WICKRA_DUMPLING_TOP_UPDATE; public static MethodHandle WICKRA_DUMPLING_TOP_BATCH; + public static MethodHandle WICKRA_DUMPLING_TOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_DUMPLING_TOP_IS_READY; public static MethodHandle WICKRA_DUMPLING_TOP_RESET; public static MethodHandle WICKRA_DUMPLING_TOP_FREE; public static MethodHandle WICKRA_DX_NEW; public static MethodHandle WICKRA_DX_UPDATE; public static MethodHandle WICKRA_DX_BATCH; + public static MethodHandle WICKRA_DX_WARMUP_PERIOD; + public static MethodHandle WICKRA_DX_IS_READY; public static MethodHandle WICKRA_DX_RESET; public static MethodHandle WICKRA_DX_FREE; public static MethodHandle WICKRA_EASE_OF_MOVEMENT_NEW; public static MethodHandle WICKRA_EASE_OF_MOVEMENT_UPDATE; public static MethodHandle WICKRA_EASE_OF_MOVEMENT_BATCH; + public static MethodHandle WICKRA_EASE_OF_MOVEMENT_WARMUP_PERIOD; + public static MethodHandle WICKRA_EASE_OF_MOVEMENT_IS_READY; public static MethodHandle WICKRA_EASE_OF_MOVEMENT_RESET; public static MethodHandle WICKRA_EASE_OF_MOVEMENT_FREE; public static MethodHandle WICKRA_ENGULFING_NEW; public static MethodHandle WICKRA_ENGULFING_UPDATE; public static MethodHandle WICKRA_ENGULFING_BATCH; + public static MethodHandle WICKRA_ENGULFING_WARMUP_PERIOD; + public static MethodHandle WICKRA_ENGULFING_IS_READY; public static MethodHandle WICKRA_ENGULFING_RESET; public static MethodHandle WICKRA_ENGULFING_FREE; public static MethodHandle WICKRA_EVENING_DOJI_STAR_NEW; public static MethodHandle WICKRA_EVENING_DOJI_STAR_UPDATE; public static MethodHandle WICKRA_EVENING_DOJI_STAR_BATCH; + public static MethodHandle WICKRA_EVENING_DOJI_STAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_EVENING_DOJI_STAR_IS_READY; public static MethodHandle WICKRA_EVENING_DOJI_STAR_RESET; public static MethodHandle WICKRA_EVENING_DOJI_STAR_FREE; public static MethodHandle WICKRA_EVWMA_NEW; public static MethodHandle WICKRA_EVWMA_UPDATE; public static MethodHandle WICKRA_EVWMA_BATCH; + public static MethodHandle WICKRA_EVWMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_EVWMA_IS_READY; public static MethodHandle WICKRA_EVWMA_RESET; public static MethodHandle WICKRA_EVWMA_FREE; public static MethodHandle WICKRA_FALLING_THREE_METHODS_NEW; public static MethodHandle WICKRA_FALLING_THREE_METHODS_UPDATE; public static MethodHandle WICKRA_FALLING_THREE_METHODS_BATCH; + public static MethodHandle WICKRA_FALLING_THREE_METHODS_WARMUP_PERIOD; + public static MethodHandle WICKRA_FALLING_THREE_METHODS_IS_READY; public static MethodHandle WICKRA_FALLING_THREE_METHODS_RESET; public static MethodHandle WICKRA_FALLING_THREE_METHODS_FREE; public static MethodHandle WICKRA_FLAG_PENNANT_NEW; public static MethodHandle WICKRA_FLAG_PENNANT_UPDATE; public static MethodHandle WICKRA_FLAG_PENNANT_BATCH; + public static MethodHandle WICKRA_FLAG_PENNANT_WARMUP_PERIOD; + public static MethodHandle WICKRA_FLAG_PENNANT_IS_READY; public static MethodHandle WICKRA_FLAG_PENNANT_RESET; public static MethodHandle WICKRA_FLAG_PENNANT_FREE; public static MethodHandle WICKRA_FORCE_INDEX_NEW; public static MethodHandle WICKRA_FORCE_INDEX_UPDATE; public static MethodHandle WICKRA_FORCE_INDEX_BATCH; + public static MethodHandle WICKRA_FORCE_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_FORCE_INDEX_IS_READY; public static MethodHandle WICKRA_FORCE_INDEX_RESET; public static MethodHandle WICKRA_FORCE_INDEX_FREE; public static MethodHandle WICKRA_FRY_PAN_BOTTOM_NEW; public static MethodHandle WICKRA_FRY_PAN_BOTTOM_UPDATE; public static MethodHandle WICKRA_FRY_PAN_BOTTOM_BATCH; + public static MethodHandle WICKRA_FRY_PAN_BOTTOM_WARMUP_PERIOD; + public static MethodHandle WICKRA_FRY_PAN_BOTTOM_IS_READY; public static MethodHandle WICKRA_FRY_PAN_BOTTOM_RESET; public static MethodHandle WICKRA_FRY_PAN_BOTTOM_FREE; public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_NEW; public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_UPDATE; public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_BATCH; + public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_WARMUP_PERIOD; + public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_IS_READY; public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_RESET; public static MethodHandle WICKRA_GAP_SIDE_BY_SIDE_WHITE_FREE; public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_NEW; public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_UPDATE; public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_BATCH; + public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_IS_READY; public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_RESET; public static MethodHandle WICKRA_GARMAN_KLASS_VOLATILITY_FREE; public static MethodHandle WICKRA_GARTLEY_NEW; public static MethodHandle WICKRA_GARTLEY_UPDATE; public static MethodHandle WICKRA_GARTLEY_BATCH; + public static MethodHandle WICKRA_GARTLEY_WARMUP_PERIOD; + public static MethodHandle WICKRA_GARTLEY_IS_READY; public static MethodHandle WICKRA_GARTLEY_RESET; public static MethodHandle WICKRA_GARTLEY_FREE; public static MethodHandle WICKRA_GRAVESTONE_DOJI_NEW; public static MethodHandle WICKRA_GRAVESTONE_DOJI_UPDATE; public static MethodHandle WICKRA_GRAVESTONE_DOJI_BATCH; + public static MethodHandle WICKRA_GRAVESTONE_DOJI_WARMUP_PERIOD; + public static MethodHandle WICKRA_GRAVESTONE_DOJI_IS_READY; public static MethodHandle WICKRA_GRAVESTONE_DOJI_RESET; public static MethodHandle WICKRA_GRAVESTONE_DOJI_FREE; public static MethodHandle WICKRA_HAMMER_NEW; public static MethodHandle WICKRA_HAMMER_UPDATE; public static MethodHandle WICKRA_HAMMER_BATCH; + public static MethodHandle WICKRA_HAMMER_WARMUP_PERIOD; + public static MethodHandle WICKRA_HAMMER_IS_READY; public static MethodHandle WICKRA_HAMMER_RESET; public static MethodHandle WICKRA_HAMMER_FREE; public static MethodHandle WICKRA_HANGING_MAN_NEW; public static MethodHandle WICKRA_HANGING_MAN_UPDATE; public static MethodHandle WICKRA_HANGING_MAN_BATCH; + public static MethodHandle WICKRA_HANGING_MAN_WARMUP_PERIOD; + public static MethodHandle WICKRA_HANGING_MAN_IS_READY; public static MethodHandle WICKRA_HANGING_MAN_RESET; public static MethodHandle WICKRA_HANGING_MAN_FREE; public static MethodHandle WICKRA_HARAMI_NEW; public static MethodHandle WICKRA_HARAMI_UPDATE; public static MethodHandle WICKRA_HARAMI_BATCH; + public static MethodHandle WICKRA_HARAMI_WARMUP_PERIOD; + public static MethodHandle WICKRA_HARAMI_IS_READY; public static MethodHandle WICKRA_HARAMI_RESET; public static MethodHandle WICKRA_HARAMI_FREE; public static MethodHandle WICKRA_HARAMI_CROSS_NEW; public static MethodHandle WICKRA_HARAMI_CROSS_UPDATE; public static MethodHandle WICKRA_HARAMI_CROSS_BATCH; + public static MethodHandle WICKRA_HARAMI_CROSS_WARMUP_PERIOD; + public static MethodHandle WICKRA_HARAMI_CROSS_IS_READY; public static MethodHandle WICKRA_HARAMI_CROSS_RESET; public static MethodHandle WICKRA_HARAMI_CROSS_FREE; public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_NEW; public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_UPDATE; public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_BATCH; + public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_WARMUP_PERIOD; + public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_IS_READY; public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_RESET; public static MethodHandle WICKRA_HEAD_AND_SHOULDERS_FREE; public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_NEW; public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_RESET; public static MethodHandle WICKRA_HEIKIN_ASHI_OSCILLATOR_FREE; public static MethodHandle WICKRA_HIGH_LOW_RANGE_NEW; public static MethodHandle WICKRA_HIGH_LOW_RANGE_UPDATE; public static MethodHandle WICKRA_HIGH_LOW_RANGE_BATCH; + public static MethodHandle WICKRA_HIGH_LOW_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIGH_LOW_RANGE_IS_READY; public static MethodHandle WICKRA_HIGH_LOW_RANGE_RESET; public static MethodHandle WICKRA_HIGH_LOW_RANGE_FREE; public static MethodHandle WICKRA_HIGH_WAVE_NEW; public static MethodHandle WICKRA_HIGH_WAVE_UPDATE; public static MethodHandle WICKRA_HIGH_WAVE_BATCH; + public static MethodHandle WICKRA_HIGH_WAVE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIGH_WAVE_IS_READY; public static MethodHandle WICKRA_HIGH_WAVE_RESET; public static MethodHandle WICKRA_HIGH_WAVE_FREE; public static MethodHandle WICKRA_HIKKAKE_NEW; public static MethodHandle WICKRA_HIKKAKE_UPDATE; public static MethodHandle WICKRA_HIKKAKE_BATCH; + public static MethodHandle WICKRA_HIKKAKE_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIKKAKE_IS_READY; public static MethodHandle WICKRA_HIKKAKE_RESET; public static MethodHandle WICKRA_HIKKAKE_FREE; public static MethodHandle WICKRA_HIKKAKE_MODIFIED_NEW; public static MethodHandle WICKRA_HIKKAKE_MODIFIED_UPDATE; public static MethodHandle WICKRA_HIKKAKE_MODIFIED_BATCH; + public static MethodHandle WICKRA_HIKKAKE_MODIFIED_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIKKAKE_MODIFIED_IS_READY; public static MethodHandle WICKRA_HIKKAKE_MODIFIED_RESET; public static MethodHandle WICKRA_HIKKAKE_MODIFIED_FREE; public static MethodHandle WICKRA_HI_LO_ACTIVATOR_NEW; public static MethodHandle WICKRA_HI_LO_ACTIVATOR_UPDATE; public static MethodHandle WICKRA_HI_LO_ACTIVATOR_BATCH; + public static MethodHandle WICKRA_HI_LO_ACTIVATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_HI_LO_ACTIVATOR_IS_READY; public static MethodHandle WICKRA_HI_LO_ACTIVATOR_RESET; public static MethodHandle WICKRA_HI_LO_ACTIVATOR_FREE; public static MethodHandle WICKRA_HOMING_PIGEON_NEW; public static MethodHandle WICKRA_HOMING_PIGEON_UPDATE; public static MethodHandle WICKRA_HOMING_PIGEON_BATCH; + public static MethodHandle WICKRA_HOMING_PIGEON_WARMUP_PERIOD; + public static MethodHandle WICKRA_HOMING_PIGEON_IS_READY; public static MethodHandle WICKRA_HOMING_PIGEON_RESET; public static MethodHandle WICKRA_HOMING_PIGEON_FREE; public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_NEW; public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_UPDATE; public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_BATCH; + public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_WARMUP_PERIOD; + public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_IS_READY; public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_RESET; public static MethodHandle WICKRA_IDENTICAL_THREE_CROWS_FREE; public static MethodHandle WICKRA_IN_NECK_NEW; public static MethodHandle WICKRA_IN_NECK_UPDATE; public static MethodHandle WICKRA_IN_NECK_BATCH; + public static MethodHandle WICKRA_IN_NECK_WARMUP_PERIOD; + public static MethodHandle WICKRA_IN_NECK_IS_READY; public static MethodHandle WICKRA_IN_NECK_RESET; public static MethodHandle WICKRA_IN_NECK_FREE; public static MethodHandle WICKRA_INERTIA_NEW; public static MethodHandle WICKRA_INERTIA_UPDATE; public static MethodHandle WICKRA_INERTIA_BATCH; + public static MethodHandle WICKRA_INERTIA_WARMUP_PERIOD; + public static MethodHandle WICKRA_INERTIA_IS_READY; public static MethodHandle WICKRA_INERTIA_RESET; public static MethodHandle WICKRA_INERTIA_FREE; public static MethodHandle WICKRA_INTRADAY_INTENSITY_NEW; public static MethodHandle WICKRA_INTRADAY_INTENSITY_UPDATE; public static MethodHandle WICKRA_INTRADAY_INTENSITY_BATCH; + public static MethodHandle WICKRA_INTRADAY_INTENSITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_INTRADAY_INTENSITY_IS_READY; public static MethodHandle WICKRA_INTRADAY_INTENSITY_RESET; public static MethodHandle WICKRA_INTRADAY_INTENSITY_FREE; public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_NEW; public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_UPDATE; public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_BATCH; + public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_IS_READY; public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_RESET; public static MethodHandle WICKRA_INTRADAY_MOMENTUM_INDEX_FREE; public static MethodHandle WICKRA_INVERTED_HAMMER_NEW; public static MethodHandle WICKRA_INVERTED_HAMMER_UPDATE; public static MethodHandle WICKRA_INVERTED_HAMMER_BATCH; + public static MethodHandle WICKRA_INVERTED_HAMMER_WARMUP_PERIOD; + public static MethodHandle WICKRA_INVERTED_HAMMER_IS_READY; public static MethodHandle WICKRA_INVERTED_HAMMER_RESET; public static MethodHandle WICKRA_INVERTED_HAMMER_FREE; public static MethodHandle WICKRA_KICKING_NEW; public static MethodHandle WICKRA_KICKING_UPDATE; public static MethodHandle WICKRA_KICKING_BATCH; + public static MethodHandle WICKRA_KICKING_WARMUP_PERIOD; + public static MethodHandle WICKRA_KICKING_IS_READY; public static MethodHandle WICKRA_KICKING_RESET; public static MethodHandle WICKRA_KICKING_FREE; public static MethodHandle WICKRA_KICKING_BY_LENGTH_NEW; public static MethodHandle WICKRA_KICKING_BY_LENGTH_UPDATE; public static MethodHandle WICKRA_KICKING_BY_LENGTH_BATCH; + public static MethodHandle WICKRA_KICKING_BY_LENGTH_WARMUP_PERIOD; + public static MethodHandle WICKRA_KICKING_BY_LENGTH_IS_READY; public static MethodHandle WICKRA_KICKING_BY_LENGTH_RESET; public static MethodHandle WICKRA_KICKING_BY_LENGTH_FREE; public static MethodHandle WICKRA_KVO_NEW; public static MethodHandle WICKRA_KVO_UPDATE; public static MethodHandle WICKRA_KVO_BATCH; + public static MethodHandle WICKRA_KVO_WARMUP_PERIOD; + public static MethodHandle WICKRA_KVO_IS_READY; public static MethodHandle WICKRA_KVO_RESET; public static MethodHandle WICKRA_KVO_FREE; public static MethodHandle WICKRA_LADDER_BOTTOM_NEW; public static MethodHandle WICKRA_LADDER_BOTTOM_UPDATE; public static MethodHandle WICKRA_LADDER_BOTTOM_BATCH; + public static MethodHandle WICKRA_LADDER_BOTTOM_WARMUP_PERIOD; + public static MethodHandle WICKRA_LADDER_BOTTOM_IS_READY; public static MethodHandle WICKRA_LADDER_BOTTOM_RESET; public static MethodHandle WICKRA_LADDER_BOTTOM_FREE; public static MethodHandle WICKRA_LONG_LEGGED_DOJI_NEW; public static MethodHandle WICKRA_LONG_LEGGED_DOJI_UPDATE; public static MethodHandle WICKRA_LONG_LEGGED_DOJI_BATCH; + public static MethodHandle WICKRA_LONG_LEGGED_DOJI_WARMUP_PERIOD; + public static MethodHandle WICKRA_LONG_LEGGED_DOJI_IS_READY; public static MethodHandle WICKRA_LONG_LEGGED_DOJI_RESET; public static MethodHandle WICKRA_LONG_LEGGED_DOJI_FREE; public static MethodHandle WICKRA_LONG_LINE_NEW; public static MethodHandle WICKRA_LONG_LINE_UPDATE; public static MethodHandle WICKRA_LONG_LINE_BATCH; + public static MethodHandle WICKRA_LONG_LINE_WARMUP_PERIOD; + public static MethodHandle WICKRA_LONG_LINE_IS_READY; public static MethodHandle WICKRA_LONG_LINE_RESET; public static MethodHandle WICKRA_LONG_LINE_FREE; public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_NEW; public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_UPDATE; public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_BATCH; + public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_IS_READY; public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_RESET; public static MethodHandle WICKRA_MARKET_FACILITATION_INDEX_FREE; public static MethodHandle WICKRA_MARUBOZU_NEW; public static MethodHandle WICKRA_MARUBOZU_UPDATE; public static MethodHandle WICKRA_MARUBOZU_BATCH; + public static MethodHandle WICKRA_MARUBOZU_WARMUP_PERIOD; + public static MethodHandle WICKRA_MARUBOZU_IS_READY; public static MethodHandle WICKRA_MARUBOZU_RESET; public static MethodHandle WICKRA_MARUBOZU_FREE; public static MethodHandle WICKRA_MASS_INDEX_NEW; public static MethodHandle WICKRA_MASS_INDEX_UPDATE; public static MethodHandle WICKRA_MASS_INDEX_BATCH; + public static MethodHandle WICKRA_MASS_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_MASS_INDEX_IS_READY; public static MethodHandle WICKRA_MASS_INDEX_RESET; public static MethodHandle WICKRA_MASS_INDEX_FREE; public static MethodHandle WICKRA_MAT_HOLD_NEW; public static MethodHandle WICKRA_MAT_HOLD_UPDATE; public static MethodHandle WICKRA_MAT_HOLD_BATCH; + public static MethodHandle WICKRA_MAT_HOLD_WARMUP_PERIOD; + public static MethodHandle WICKRA_MAT_HOLD_IS_READY; public static MethodHandle WICKRA_MAT_HOLD_RESET; public static MethodHandle WICKRA_MAT_HOLD_FREE; public static MethodHandle WICKRA_MATCHING_LOW_NEW; public static MethodHandle WICKRA_MATCHING_LOW_UPDATE; public static MethodHandle WICKRA_MATCHING_LOW_BATCH; + public static MethodHandle WICKRA_MATCHING_LOW_WARMUP_PERIOD; + public static MethodHandle WICKRA_MATCHING_LOW_IS_READY; public static MethodHandle WICKRA_MATCHING_LOW_RESET; public static MethodHandle WICKRA_MATCHING_LOW_FREE; public static MethodHandle WICKRA_MEDIAN_PRICE_NEW; public static MethodHandle WICKRA_MEDIAN_PRICE_UPDATE; public static MethodHandle WICKRA_MEDIAN_PRICE_BATCH; + public static MethodHandle WICKRA_MEDIAN_PRICE_WARMUP_PERIOD; + public static MethodHandle WICKRA_MEDIAN_PRICE_IS_READY; public static MethodHandle WICKRA_MEDIAN_PRICE_RESET; public static MethodHandle WICKRA_MEDIAN_PRICE_FREE; public static MethodHandle WICKRA_MFI_NEW; public static MethodHandle WICKRA_MFI_UPDATE; public static MethodHandle WICKRA_MFI_BATCH; + public static MethodHandle WICKRA_MFI_WARMUP_PERIOD; + public static MethodHandle WICKRA_MFI_IS_READY; public static MethodHandle WICKRA_MFI_RESET; public static MethodHandle WICKRA_MFI_FREE; public static MethodHandle WICKRA_MID_PRICE_NEW; public static MethodHandle WICKRA_MID_PRICE_UPDATE; public static MethodHandle WICKRA_MID_PRICE_BATCH; + public static MethodHandle WICKRA_MID_PRICE_WARMUP_PERIOD; + public static MethodHandle WICKRA_MID_PRICE_IS_READY; public static MethodHandle WICKRA_MID_PRICE_RESET; public static MethodHandle WICKRA_MID_PRICE_FREE; public static MethodHandle WICKRA_MINUS_DI_NEW; public static MethodHandle WICKRA_MINUS_DI_UPDATE; public static MethodHandle WICKRA_MINUS_DI_BATCH; + public static MethodHandle WICKRA_MINUS_DI_WARMUP_PERIOD; + public static MethodHandle WICKRA_MINUS_DI_IS_READY; public static MethodHandle WICKRA_MINUS_DI_RESET; public static MethodHandle WICKRA_MINUS_DI_FREE; public static MethodHandle WICKRA_MINUS_DM_NEW; public static MethodHandle WICKRA_MINUS_DM_UPDATE; public static MethodHandle WICKRA_MINUS_DM_BATCH; + public static MethodHandle WICKRA_MINUS_DM_WARMUP_PERIOD; + public static MethodHandle WICKRA_MINUS_DM_IS_READY; public static MethodHandle WICKRA_MINUS_DM_RESET; public static MethodHandle WICKRA_MINUS_DM_FREE; public static MethodHandle WICKRA_MORNING_DOJI_STAR_NEW; public static MethodHandle WICKRA_MORNING_DOJI_STAR_UPDATE; public static MethodHandle WICKRA_MORNING_DOJI_STAR_BATCH; + public static MethodHandle WICKRA_MORNING_DOJI_STAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_MORNING_DOJI_STAR_IS_READY; public static MethodHandle WICKRA_MORNING_DOJI_STAR_RESET; public static MethodHandle WICKRA_MORNING_DOJI_STAR_FREE; public static MethodHandle WICKRA_MORNING_EVENING_STAR_NEW; public static MethodHandle WICKRA_MORNING_EVENING_STAR_UPDATE; public static MethodHandle WICKRA_MORNING_EVENING_STAR_BATCH; + public static MethodHandle WICKRA_MORNING_EVENING_STAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_MORNING_EVENING_STAR_IS_READY; public static MethodHandle WICKRA_MORNING_EVENING_STAR_RESET; public static MethodHandle WICKRA_MORNING_EVENING_STAR_FREE; public static MethodHandle WICKRA_NAKED_POC_NEW; public static MethodHandle WICKRA_NAKED_POC_UPDATE; public static MethodHandle WICKRA_NAKED_POC_BATCH; + public static MethodHandle WICKRA_NAKED_POC_WARMUP_PERIOD; + public static MethodHandle WICKRA_NAKED_POC_IS_READY; public static MethodHandle WICKRA_NAKED_POC_RESET; public static MethodHandle WICKRA_NAKED_POC_FREE; public static MethodHandle WICKRA_NATR_NEW; public static MethodHandle WICKRA_NATR_UPDATE; public static MethodHandle WICKRA_NATR_BATCH; + public static MethodHandle WICKRA_NATR_WARMUP_PERIOD; + public static MethodHandle WICKRA_NATR_IS_READY; public static MethodHandle WICKRA_NATR_RESET; public static MethodHandle WICKRA_NATR_FREE; public static MethodHandle WICKRA_NEW_PRICE_LINES_NEW; public static MethodHandle WICKRA_NEW_PRICE_LINES_UPDATE; public static MethodHandle WICKRA_NEW_PRICE_LINES_BATCH; + public static MethodHandle WICKRA_NEW_PRICE_LINES_WARMUP_PERIOD; + public static MethodHandle WICKRA_NEW_PRICE_LINES_IS_READY; public static MethodHandle WICKRA_NEW_PRICE_LINES_RESET; public static MethodHandle WICKRA_NEW_PRICE_LINES_FREE; public static MethodHandle WICKRA_NVI_NEW; public static MethodHandle WICKRA_NVI_UPDATE; public static MethodHandle WICKRA_NVI_BATCH; + public static MethodHandle WICKRA_NVI_WARMUP_PERIOD; + public static MethodHandle WICKRA_NVI_IS_READY; public static MethodHandle WICKRA_NVI_RESET; public static MethodHandle WICKRA_NVI_FREE; public static MethodHandle WICKRA_OBV_NEW; public static MethodHandle WICKRA_OBV_UPDATE; public static MethodHandle WICKRA_OBV_BATCH; + public static MethodHandle WICKRA_OBV_WARMUP_PERIOD; + public static MethodHandle WICKRA_OBV_IS_READY; public static MethodHandle WICKRA_OBV_RESET; public static MethodHandle WICKRA_OBV_FREE; public static MethodHandle WICKRA_ON_NECK_NEW; public static MethodHandle WICKRA_ON_NECK_UPDATE; public static MethodHandle WICKRA_ON_NECK_BATCH; + public static MethodHandle WICKRA_ON_NECK_WARMUP_PERIOD; + public static MethodHandle WICKRA_ON_NECK_IS_READY; public static MethodHandle WICKRA_ON_NECK_RESET; public static MethodHandle WICKRA_ON_NECK_FREE; public static MethodHandle WICKRA_OPENING_MARUBOZU_NEW; public static MethodHandle WICKRA_OPENING_MARUBOZU_UPDATE; public static MethodHandle WICKRA_OPENING_MARUBOZU_BATCH; + public static MethodHandle WICKRA_OPENING_MARUBOZU_WARMUP_PERIOD; + public static MethodHandle WICKRA_OPENING_MARUBOZU_IS_READY; public static MethodHandle WICKRA_OPENING_MARUBOZU_RESET; public static MethodHandle WICKRA_OPENING_MARUBOZU_FREE; public static MethodHandle WICKRA_OVERNIGHT_GAP_NEW; public static MethodHandle WICKRA_OVERNIGHT_GAP_UPDATE; public static MethodHandle WICKRA_OVERNIGHT_GAP_BATCH; + public static MethodHandle WICKRA_OVERNIGHT_GAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_OVERNIGHT_GAP_IS_READY; public static MethodHandle WICKRA_OVERNIGHT_GAP_RESET; public static MethodHandle WICKRA_OVERNIGHT_GAP_FREE; public static MethodHandle WICKRA_PARKINSON_VOLATILITY_NEW; public static MethodHandle WICKRA_PARKINSON_VOLATILITY_UPDATE; public static MethodHandle WICKRA_PARKINSON_VOLATILITY_BATCH; + public static MethodHandle WICKRA_PARKINSON_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_PARKINSON_VOLATILITY_IS_READY; public static MethodHandle WICKRA_PARKINSON_VOLATILITY_RESET; public static MethodHandle WICKRA_PARKINSON_VOLATILITY_FREE; public static MethodHandle WICKRA_PGO_NEW; public static MethodHandle WICKRA_PGO_UPDATE; public static MethodHandle WICKRA_PGO_BATCH; + public static MethodHandle WICKRA_PGO_WARMUP_PERIOD; + public static MethodHandle WICKRA_PGO_IS_READY; public static MethodHandle WICKRA_PGO_RESET; public static MethodHandle WICKRA_PGO_FREE; public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_NEW; public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_UPDATE; public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_BATCH; + public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_WARMUP_PERIOD; + public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_IS_READY; public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_RESET; public static MethodHandle WICKRA_PIERCING_DARK_CLOUD_FREE; public static MethodHandle WICKRA_PIVOT_REVERSAL_NEW; public static MethodHandle WICKRA_PIVOT_REVERSAL_UPDATE; public static MethodHandle WICKRA_PIVOT_REVERSAL_BATCH; + public static MethodHandle WICKRA_PIVOT_REVERSAL_WARMUP_PERIOD; + public static MethodHandle WICKRA_PIVOT_REVERSAL_IS_READY; public static MethodHandle WICKRA_PIVOT_REVERSAL_RESET; public static MethodHandle WICKRA_PIVOT_REVERSAL_FREE; public static MethodHandle WICKRA_PLUS_DI_NEW; public static MethodHandle WICKRA_PLUS_DI_UPDATE; public static MethodHandle WICKRA_PLUS_DI_BATCH; + public static MethodHandle WICKRA_PLUS_DI_WARMUP_PERIOD; + public static MethodHandle WICKRA_PLUS_DI_IS_READY; public static MethodHandle WICKRA_PLUS_DI_RESET; public static MethodHandle WICKRA_PLUS_DI_FREE; public static MethodHandle WICKRA_PLUS_DM_NEW; public static MethodHandle WICKRA_PLUS_DM_UPDATE; public static MethodHandle WICKRA_PLUS_DM_BATCH; + public static MethodHandle WICKRA_PLUS_DM_WARMUP_PERIOD; + public static MethodHandle WICKRA_PLUS_DM_IS_READY; public static MethodHandle WICKRA_PLUS_DM_RESET; public static MethodHandle WICKRA_PLUS_DM_FREE; public static MethodHandle WICKRA_PROFILE_SHAPE_NEW; public static MethodHandle WICKRA_PROFILE_SHAPE_UPDATE; public static MethodHandle WICKRA_PROFILE_SHAPE_BATCH; + public static MethodHandle WICKRA_PROFILE_SHAPE_WARMUP_PERIOD; + public static MethodHandle WICKRA_PROFILE_SHAPE_IS_READY; public static MethodHandle WICKRA_PROFILE_SHAPE_RESET; public static MethodHandle WICKRA_PROFILE_SHAPE_FREE; public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_NEW; public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_RESET; public static MethodHandle WICKRA_PROJECTION_OSCILLATOR_FREE; public static MethodHandle WICKRA_PSAR_NEW; public static MethodHandle WICKRA_PSAR_UPDATE; public static MethodHandle WICKRA_PSAR_BATCH; + public static MethodHandle WICKRA_PSAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_PSAR_IS_READY; public static MethodHandle WICKRA_PSAR_RESET; public static MethodHandle WICKRA_PSAR_FREE; public static MethodHandle WICKRA_PVI_NEW; public static MethodHandle WICKRA_PVI_UPDATE; public static MethodHandle WICKRA_PVI_BATCH; + public static MethodHandle WICKRA_PVI_WARMUP_PERIOD; + public static MethodHandle WICKRA_PVI_IS_READY; public static MethodHandle WICKRA_PVI_RESET; public static MethodHandle WICKRA_PVI_FREE; public static MethodHandle WICKRA_QSTICK_NEW; public static MethodHandle WICKRA_QSTICK_UPDATE; public static MethodHandle WICKRA_QSTICK_BATCH; + public static MethodHandle WICKRA_QSTICK_WARMUP_PERIOD; + public static MethodHandle WICKRA_QSTICK_IS_READY; public static MethodHandle WICKRA_QSTICK_RESET; public static MethodHandle WICKRA_QSTICK_FREE; public static MethodHandle WICKRA_RECTANGLE_RANGE_NEW; public static MethodHandle WICKRA_RECTANGLE_RANGE_UPDATE; public static MethodHandle WICKRA_RECTANGLE_RANGE_BATCH; + public static MethodHandle WICKRA_RECTANGLE_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_RECTANGLE_RANGE_IS_READY; public static MethodHandle WICKRA_RECTANGLE_RANGE_RESET; public static MethodHandle WICKRA_RECTANGLE_RANGE_FREE; public static MethodHandle WICKRA_RICKSHAW_MAN_NEW; public static MethodHandle WICKRA_RICKSHAW_MAN_UPDATE; public static MethodHandle WICKRA_RICKSHAW_MAN_BATCH; + public static MethodHandle WICKRA_RICKSHAW_MAN_WARMUP_PERIOD; + public static MethodHandle WICKRA_RICKSHAW_MAN_IS_READY; public static MethodHandle WICKRA_RICKSHAW_MAN_RESET; public static MethodHandle WICKRA_RICKSHAW_MAN_FREE; public static MethodHandle WICKRA_RISING_THREE_METHODS_NEW; public static MethodHandle WICKRA_RISING_THREE_METHODS_UPDATE; public static MethodHandle WICKRA_RISING_THREE_METHODS_BATCH; + public static MethodHandle WICKRA_RISING_THREE_METHODS_WARMUP_PERIOD; + public static MethodHandle WICKRA_RISING_THREE_METHODS_IS_READY; public static MethodHandle WICKRA_RISING_THREE_METHODS_RESET; public static MethodHandle WICKRA_RISING_THREE_METHODS_FREE; public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_NEW; public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_UPDATE; public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_BATCH; + public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_IS_READY; public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_RESET; public static MethodHandle WICKRA_ROGERS_SATCHELL_VOLATILITY_FREE; public static MethodHandle WICKRA_RVI_NEW; public static MethodHandle WICKRA_RVI_UPDATE; public static MethodHandle WICKRA_RVI_BATCH; + public static MethodHandle WICKRA_RVI_WARMUP_PERIOD; + public static MethodHandle WICKRA_RVI_IS_READY; public static MethodHandle WICKRA_RVI_RESET; public static MethodHandle WICKRA_RVI_FREE; public static MethodHandle WICKRA_SAR_EXT_NEW; public static MethodHandle WICKRA_SAR_EXT_UPDATE; public static MethodHandle WICKRA_SAR_EXT_BATCH; + public static MethodHandle WICKRA_SAR_EXT_WARMUP_PERIOD; + public static MethodHandle WICKRA_SAR_EXT_IS_READY; public static MethodHandle WICKRA_SAR_EXT_RESET; public static MethodHandle WICKRA_SAR_EXT_FREE; public static MethodHandle WICKRA_SEASONAL_Z_SCORE_NEW; public static MethodHandle WICKRA_SEASONAL_Z_SCORE_UPDATE; public static MethodHandle WICKRA_SEASONAL_Z_SCORE_BATCH; + public static MethodHandle WICKRA_SEASONAL_Z_SCORE_WARMUP_PERIOD; + public static MethodHandle WICKRA_SEASONAL_Z_SCORE_IS_READY; public static MethodHandle WICKRA_SEASONAL_Z_SCORE_RESET; public static MethodHandle WICKRA_SEASONAL_Z_SCORE_FREE; public static MethodHandle WICKRA_SEPARATING_LINES_NEW; public static MethodHandle WICKRA_SEPARATING_LINES_UPDATE; public static MethodHandle WICKRA_SEPARATING_LINES_BATCH; + public static MethodHandle WICKRA_SEPARATING_LINES_WARMUP_PERIOD; + public static MethodHandle WICKRA_SEPARATING_LINES_IS_READY; public static MethodHandle WICKRA_SEPARATING_LINES_RESET; public static MethodHandle WICKRA_SEPARATING_LINES_FREE; public static MethodHandle WICKRA_SESSION_VWAP_NEW; public static MethodHandle WICKRA_SESSION_VWAP_UPDATE; public static MethodHandle WICKRA_SESSION_VWAP_BATCH; + public static MethodHandle WICKRA_SESSION_VWAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_SESSION_VWAP_IS_READY; public static MethodHandle WICKRA_SESSION_VWAP_RESET; public static MethodHandle WICKRA_SESSION_VWAP_FREE; public static MethodHandle WICKRA_SHARK_NEW; public static MethodHandle WICKRA_SHARK_UPDATE; public static MethodHandle WICKRA_SHARK_BATCH; + public static MethodHandle WICKRA_SHARK_WARMUP_PERIOD; + public static MethodHandle WICKRA_SHARK_IS_READY; public static MethodHandle WICKRA_SHARK_RESET; public static MethodHandle WICKRA_SHARK_FREE; public static MethodHandle WICKRA_SHOOTING_STAR_NEW; public static MethodHandle WICKRA_SHOOTING_STAR_UPDATE; public static MethodHandle WICKRA_SHOOTING_STAR_BATCH; + public static MethodHandle WICKRA_SHOOTING_STAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_SHOOTING_STAR_IS_READY; public static MethodHandle WICKRA_SHOOTING_STAR_RESET; public static MethodHandle WICKRA_SHOOTING_STAR_FREE; public static MethodHandle WICKRA_SHORT_LINE_NEW; public static MethodHandle WICKRA_SHORT_LINE_UPDATE; public static MethodHandle WICKRA_SHORT_LINE_BATCH; + public static MethodHandle WICKRA_SHORT_LINE_WARMUP_PERIOD; + public static MethodHandle WICKRA_SHORT_LINE_IS_READY; public static MethodHandle WICKRA_SHORT_LINE_RESET; public static MethodHandle WICKRA_SHORT_LINE_FREE; public static MethodHandle WICKRA_SINGLE_PRINTS_NEW; public static MethodHandle WICKRA_SINGLE_PRINTS_UPDATE; public static MethodHandle WICKRA_SINGLE_PRINTS_BATCH; + public static MethodHandle WICKRA_SINGLE_PRINTS_WARMUP_PERIOD; + public static MethodHandle WICKRA_SINGLE_PRINTS_IS_READY; public static MethodHandle WICKRA_SINGLE_PRINTS_RESET; public static MethodHandle WICKRA_SINGLE_PRINTS_FREE; public static MethodHandle WICKRA_SMI_NEW; public static MethodHandle WICKRA_SMI_UPDATE; public static MethodHandle WICKRA_SMI_BATCH; + public static MethodHandle WICKRA_SMI_WARMUP_PERIOD; + public static MethodHandle WICKRA_SMI_IS_READY; public static MethodHandle WICKRA_SMI_RESET; public static MethodHandle WICKRA_SMI_FREE; public static MethodHandle WICKRA_SPINNING_TOP_NEW; public static MethodHandle WICKRA_SPINNING_TOP_UPDATE; public static MethodHandle WICKRA_SPINNING_TOP_BATCH; + public static MethodHandle WICKRA_SPINNING_TOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_SPINNING_TOP_IS_READY; public static MethodHandle WICKRA_SPINNING_TOP_RESET; public static MethodHandle WICKRA_SPINNING_TOP_FREE; public static MethodHandle WICKRA_STALLED_PATTERN_NEW; public static MethodHandle WICKRA_STALLED_PATTERN_UPDATE; public static MethodHandle WICKRA_STALLED_PATTERN_BATCH; + public static MethodHandle WICKRA_STALLED_PATTERN_WARMUP_PERIOD; + public static MethodHandle WICKRA_STALLED_PATTERN_IS_READY; public static MethodHandle WICKRA_STALLED_PATTERN_RESET; public static MethodHandle WICKRA_STALLED_PATTERN_FREE; public static MethodHandle WICKRA_STICK_SANDWICH_NEW; public static MethodHandle WICKRA_STICK_SANDWICH_UPDATE; public static MethodHandle WICKRA_STICK_SANDWICH_BATCH; + public static MethodHandle WICKRA_STICK_SANDWICH_WARMUP_PERIOD; + public static MethodHandle WICKRA_STICK_SANDWICH_IS_READY; public static MethodHandle WICKRA_STICK_SANDWICH_RESET; public static MethodHandle WICKRA_STICK_SANDWICH_FREE; public static MethodHandle WICKRA_STOCHASTIC_CCI_NEW; public static MethodHandle WICKRA_STOCHASTIC_CCI_UPDATE; public static MethodHandle WICKRA_STOCHASTIC_CCI_BATCH; + public static MethodHandle WICKRA_STOCHASTIC_CCI_WARMUP_PERIOD; + public static MethodHandle WICKRA_STOCHASTIC_CCI_IS_READY; public static MethodHandle WICKRA_STOCHASTIC_CCI_RESET; public static MethodHandle WICKRA_STOCHASTIC_CCI_FREE; public static MethodHandle WICKRA_TAKURI_NEW; public static MethodHandle WICKRA_TAKURI_UPDATE; public static MethodHandle WICKRA_TAKURI_BATCH; + public static MethodHandle WICKRA_TAKURI_WARMUP_PERIOD; + public static MethodHandle WICKRA_TAKURI_IS_READY; public static MethodHandle WICKRA_TAKURI_RESET; public static MethodHandle WICKRA_TAKURI_FREE; public static MethodHandle WICKRA_TASUKI_GAP_NEW; public static MethodHandle WICKRA_TASUKI_GAP_UPDATE; public static MethodHandle WICKRA_TASUKI_GAP_BATCH; + public static MethodHandle WICKRA_TASUKI_GAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_TASUKI_GAP_IS_READY; public static MethodHandle WICKRA_TASUKI_GAP_RESET; public static MethodHandle WICKRA_TASUKI_GAP_FREE; public static MethodHandle WICKRA_TD_CAMOUFLAGE_NEW; public static MethodHandle WICKRA_TD_CAMOUFLAGE_UPDATE; public static MethodHandle WICKRA_TD_CAMOUFLAGE_BATCH; + public static MethodHandle WICKRA_TD_CAMOUFLAGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_CAMOUFLAGE_IS_READY; public static MethodHandle WICKRA_TD_CAMOUFLAGE_RESET; public static MethodHandle WICKRA_TD_CAMOUFLAGE_FREE; public static MethodHandle WICKRA_TD_CLOP_NEW; public static MethodHandle WICKRA_TD_CLOP_UPDATE; public static MethodHandle WICKRA_TD_CLOP_BATCH; + public static MethodHandle WICKRA_TD_CLOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_CLOP_IS_READY; public static MethodHandle WICKRA_TD_CLOP_RESET; public static MethodHandle WICKRA_TD_CLOP_FREE; public static MethodHandle WICKRA_TD_CLOPWIN_NEW; public static MethodHandle WICKRA_TD_CLOPWIN_UPDATE; public static MethodHandle WICKRA_TD_CLOPWIN_BATCH; + public static MethodHandle WICKRA_TD_CLOPWIN_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_CLOPWIN_IS_READY; public static MethodHandle WICKRA_TD_CLOPWIN_RESET; public static MethodHandle WICKRA_TD_CLOPWIN_FREE; public static MethodHandle WICKRA_TD_COMBO_NEW; public static MethodHandle WICKRA_TD_COMBO_UPDATE; public static MethodHandle WICKRA_TD_COMBO_BATCH; + public static MethodHandle WICKRA_TD_COMBO_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_COMBO_IS_READY; public static MethodHandle WICKRA_TD_COMBO_RESET; public static MethodHandle WICKRA_TD_COMBO_FREE; public static MethodHandle WICKRA_TD_COUNTDOWN_NEW; public static MethodHandle WICKRA_TD_COUNTDOWN_UPDATE; public static MethodHandle WICKRA_TD_COUNTDOWN_BATCH; + public static MethodHandle WICKRA_TD_COUNTDOWN_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_COUNTDOWN_IS_READY; public static MethodHandle WICKRA_TD_COUNTDOWN_RESET; public static MethodHandle WICKRA_TD_COUNTDOWN_FREE; public static MethodHandle WICKRA_TD_DE_MARKER_NEW; public static MethodHandle WICKRA_TD_DE_MARKER_UPDATE; public static MethodHandle WICKRA_TD_DE_MARKER_BATCH; + public static MethodHandle WICKRA_TD_DE_MARKER_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_DE_MARKER_IS_READY; public static MethodHandle WICKRA_TD_DE_MARKER_RESET; public static MethodHandle WICKRA_TD_DE_MARKER_FREE; public static MethodHandle WICKRA_TD_DIFFERENTIAL_NEW; public static MethodHandle WICKRA_TD_DIFFERENTIAL_UPDATE; public static MethodHandle WICKRA_TD_DIFFERENTIAL_BATCH; + public static MethodHandle WICKRA_TD_DIFFERENTIAL_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_DIFFERENTIAL_IS_READY; public static MethodHandle WICKRA_TD_DIFFERENTIAL_RESET; public static MethodHandle WICKRA_TD_DIFFERENTIAL_FREE; public static MethodHandle WICKRA_TD_D_WAVE_NEW; public static MethodHandle WICKRA_TD_D_WAVE_UPDATE; public static MethodHandle WICKRA_TD_D_WAVE_BATCH; + public static MethodHandle WICKRA_TD_D_WAVE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_D_WAVE_IS_READY; public static MethodHandle WICKRA_TD_D_WAVE_RESET; public static MethodHandle WICKRA_TD_D_WAVE_FREE; public static MethodHandle WICKRA_TD_OPEN_NEW; public static MethodHandle WICKRA_TD_OPEN_UPDATE; public static MethodHandle WICKRA_TD_OPEN_BATCH; + public static MethodHandle WICKRA_TD_OPEN_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_OPEN_IS_READY; public static MethodHandle WICKRA_TD_OPEN_RESET; public static MethodHandle WICKRA_TD_OPEN_FREE; public static MethodHandle WICKRA_TD_PRESSURE_NEW; public static MethodHandle WICKRA_TD_PRESSURE_UPDATE; public static MethodHandle WICKRA_TD_PRESSURE_BATCH; + public static MethodHandle WICKRA_TD_PRESSURE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_PRESSURE_IS_READY; public static MethodHandle WICKRA_TD_PRESSURE_RESET; public static MethodHandle WICKRA_TD_PRESSURE_FREE; public static MethodHandle WICKRA_TD_PROPULSION_NEW; public static MethodHandle WICKRA_TD_PROPULSION_UPDATE; public static MethodHandle WICKRA_TD_PROPULSION_BATCH; + public static MethodHandle WICKRA_TD_PROPULSION_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_PROPULSION_IS_READY; public static MethodHandle WICKRA_TD_PROPULSION_RESET; public static MethodHandle WICKRA_TD_PROPULSION_FREE; public static MethodHandle WICKRA_TD_REI_NEW; public static MethodHandle WICKRA_TD_REI_UPDATE; public static MethodHandle WICKRA_TD_REI_BATCH; + public static MethodHandle WICKRA_TD_REI_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_REI_IS_READY; public static MethodHandle WICKRA_TD_REI_RESET; public static MethodHandle WICKRA_TD_REI_FREE; public static MethodHandle WICKRA_TD_SETUP_NEW; public static MethodHandle WICKRA_TD_SETUP_UPDATE; public static MethodHandle WICKRA_TD_SETUP_BATCH; + public static MethodHandle WICKRA_TD_SETUP_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_SETUP_IS_READY; public static MethodHandle WICKRA_TD_SETUP_RESET; public static MethodHandle WICKRA_TD_SETUP_FREE; public static MethodHandle WICKRA_TD_TRAP_NEW; public static MethodHandle WICKRA_TD_TRAP_UPDATE; public static MethodHandle WICKRA_TD_TRAP_BATCH; + public static MethodHandle WICKRA_TD_TRAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_TRAP_IS_READY; public static MethodHandle WICKRA_TD_TRAP_RESET; public static MethodHandle WICKRA_TD_TRAP_FREE; public static MethodHandle WICKRA_THREE_DRIVES_NEW; public static MethodHandle WICKRA_THREE_DRIVES_UPDATE; public static MethodHandle WICKRA_THREE_DRIVES_BATCH; + public static MethodHandle WICKRA_THREE_DRIVES_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_DRIVES_IS_READY; public static MethodHandle WICKRA_THREE_DRIVES_RESET; public static MethodHandle WICKRA_THREE_DRIVES_FREE; public static MethodHandle WICKRA_THREE_INSIDE_NEW; public static MethodHandle WICKRA_THREE_INSIDE_UPDATE; public static MethodHandle WICKRA_THREE_INSIDE_BATCH; + public static MethodHandle WICKRA_THREE_INSIDE_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_INSIDE_IS_READY; public static MethodHandle WICKRA_THREE_INSIDE_RESET; public static MethodHandle WICKRA_THREE_INSIDE_FREE; public static MethodHandle WICKRA_THREE_LINE_BREAK_NEW; public static MethodHandle WICKRA_THREE_LINE_BREAK_UPDATE; public static MethodHandle WICKRA_THREE_LINE_BREAK_BATCH; + public static MethodHandle WICKRA_THREE_LINE_BREAK_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_LINE_BREAK_IS_READY; public static MethodHandle WICKRA_THREE_LINE_BREAK_RESET; public static MethodHandle WICKRA_THREE_LINE_BREAK_FREE; public static MethodHandle WICKRA_THREE_LINE_STRIKE_NEW; public static MethodHandle WICKRA_THREE_LINE_STRIKE_UPDATE; public static MethodHandle WICKRA_THREE_LINE_STRIKE_BATCH; + public static MethodHandle WICKRA_THREE_LINE_STRIKE_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_LINE_STRIKE_IS_READY; public static MethodHandle WICKRA_THREE_LINE_STRIKE_RESET; public static MethodHandle WICKRA_THREE_LINE_STRIKE_FREE; public static MethodHandle WICKRA_THREE_OUTSIDE_NEW; public static MethodHandle WICKRA_THREE_OUTSIDE_UPDATE; public static MethodHandle WICKRA_THREE_OUTSIDE_BATCH; + public static MethodHandle WICKRA_THREE_OUTSIDE_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_OUTSIDE_IS_READY; public static MethodHandle WICKRA_THREE_OUTSIDE_RESET; public static MethodHandle WICKRA_THREE_OUTSIDE_FREE; public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_NEW; public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_UPDATE; public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_BATCH; + public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_IS_READY; public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_RESET; public static MethodHandle WICKRA_THREE_SOLDIERS_OR_CROWS_FREE; public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_NEW; public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_UPDATE; public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_BATCH; + public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_WARMUP_PERIOD; + public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_IS_READY; public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_RESET; public static MethodHandle WICKRA_THREE_STARS_IN_SOUTH_FREE; public static MethodHandle WICKRA_THRUSTING_NEW; public static MethodHandle WICKRA_THRUSTING_UPDATE; public static MethodHandle WICKRA_THRUSTING_BATCH; + public static MethodHandle WICKRA_THRUSTING_WARMUP_PERIOD; + public static MethodHandle WICKRA_THRUSTING_IS_READY; public static MethodHandle WICKRA_THRUSTING_RESET; public static MethodHandle WICKRA_THRUSTING_FREE; public static MethodHandle WICKRA_TIME_BASED_STOP_NEW; public static MethodHandle WICKRA_TIME_BASED_STOP_UPDATE; public static MethodHandle WICKRA_TIME_BASED_STOP_BATCH; + public static MethodHandle WICKRA_TIME_BASED_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_TIME_BASED_STOP_IS_READY; public static MethodHandle WICKRA_TIME_BASED_STOP_RESET; public static MethodHandle WICKRA_TIME_BASED_STOP_FREE; public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_NEW; public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_UPDATE; public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_BATCH; + public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_WARMUP_PERIOD; + public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_IS_READY; public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_RESET; public static MethodHandle WICKRA_TOWER_TOP_BOTTOM_FREE; public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_NEW; public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_UPDATE; public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_BATCH; + public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_IS_READY; public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_RESET; public static MethodHandle WICKRA_TRADE_VOLUME_INDEX_FREE; public static MethodHandle WICKRA_TRIANGLE_NEW; public static MethodHandle WICKRA_TRIANGLE_UPDATE; public static MethodHandle WICKRA_TRIANGLE_BATCH; + public static MethodHandle WICKRA_TRIANGLE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRIANGLE_IS_READY; public static MethodHandle WICKRA_TRIANGLE_RESET; public static MethodHandle WICKRA_TRIANGLE_FREE; public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_NEW; public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_UPDATE; public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_BATCH; + public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_IS_READY; public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_RESET; public static MethodHandle WICKRA_TRIPLE_TOP_BOTTOM_FREE; public static MethodHandle WICKRA_TRISTAR_NEW; public static MethodHandle WICKRA_TRISTAR_UPDATE; public static MethodHandle WICKRA_TRISTAR_BATCH; + public static MethodHandle WICKRA_TRISTAR_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRISTAR_IS_READY; public static MethodHandle WICKRA_TRISTAR_RESET; public static MethodHandle WICKRA_TRISTAR_FREE; public static MethodHandle WICKRA_TRUE_RANGE_NEW; public static MethodHandle WICKRA_TRUE_RANGE_UPDATE; public static MethodHandle WICKRA_TRUE_RANGE_BATCH; + public static MethodHandle WICKRA_TRUE_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRUE_RANGE_IS_READY; public static MethodHandle WICKRA_TRUE_RANGE_RESET; public static MethodHandle WICKRA_TRUE_RANGE_FREE; public static MethodHandle WICKRA_TSV_NEW; public static MethodHandle WICKRA_TSV_UPDATE; public static MethodHandle WICKRA_TSV_BATCH; + public static MethodHandle WICKRA_TSV_WARMUP_PERIOD; + public static MethodHandle WICKRA_TSV_IS_READY; public static MethodHandle WICKRA_TSV_RESET; public static MethodHandle WICKRA_TSV_FREE; public static MethodHandle WICKRA_TTM_TREND_NEW; public static MethodHandle WICKRA_TTM_TREND_UPDATE; public static MethodHandle WICKRA_TTM_TREND_BATCH; + public static MethodHandle WICKRA_TTM_TREND_WARMUP_PERIOD; + public static MethodHandle WICKRA_TTM_TREND_IS_READY; public static MethodHandle WICKRA_TTM_TREND_RESET; public static MethodHandle WICKRA_TTM_TREND_FREE; public static MethodHandle WICKRA_TURN_OF_MONTH_NEW; public static MethodHandle WICKRA_TURN_OF_MONTH_UPDATE; public static MethodHandle WICKRA_TURN_OF_MONTH_BATCH; + public static MethodHandle WICKRA_TURN_OF_MONTH_WARMUP_PERIOD; + public static MethodHandle WICKRA_TURN_OF_MONTH_IS_READY; public static MethodHandle WICKRA_TURN_OF_MONTH_RESET; public static MethodHandle WICKRA_TURN_OF_MONTH_FREE; public static MethodHandle WICKRA_TWEEZER_NEW; public static MethodHandle WICKRA_TWEEZER_UPDATE; public static MethodHandle WICKRA_TWEEZER_BATCH; + public static MethodHandle WICKRA_TWEEZER_WARMUP_PERIOD; + public static MethodHandle WICKRA_TWEEZER_IS_READY; public static MethodHandle WICKRA_TWEEZER_RESET; public static MethodHandle WICKRA_TWEEZER_FREE; public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_NEW; public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_UPDATE; public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_BATCH; + public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_WARMUP_PERIOD; + public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_IS_READY; public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_RESET; public static MethodHandle WICKRA_TWIGGS_MONEY_FLOW_FREE; public static MethodHandle WICKRA_TWO_CROWS_NEW; public static MethodHandle WICKRA_TWO_CROWS_UPDATE; public static MethodHandle WICKRA_TWO_CROWS_BATCH; + public static MethodHandle WICKRA_TWO_CROWS_WARMUP_PERIOD; + public static MethodHandle WICKRA_TWO_CROWS_IS_READY; public static MethodHandle WICKRA_TWO_CROWS_RESET; public static MethodHandle WICKRA_TWO_CROWS_FREE; public static MethodHandle WICKRA_TYPICAL_PRICE_NEW; public static MethodHandle WICKRA_TYPICAL_PRICE_UPDATE; public static MethodHandle WICKRA_TYPICAL_PRICE_BATCH; + public static MethodHandle WICKRA_TYPICAL_PRICE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TYPICAL_PRICE_IS_READY; public static MethodHandle WICKRA_TYPICAL_PRICE_RESET; public static MethodHandle WICKRA_TYPICAL_PRICE_FREE; public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_NEW; public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_RESET; public static MethodHandle WICKRA_ULTIMATE_OSCILLATOR_FREE; public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_NEW; public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_UPDATE; public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_BATCH; + public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_WARMUP_PERIOD; + public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_IS_READY; public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_RESET; public static MethodHandle WICKRA_UNIQUE_THREE_RIVER_FREE; public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_NEW; public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_UPDATE; public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_BATCH; + public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_WARMUP_PERIOD; + public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_IS_READY; public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_RESET; public static MethodHandle WICKRA_UPSIDE_GAP_THREE_METHODS_FREE; public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_NEW; public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_UPDATE; public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_BATCH; + public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_WARMUP_PERIOD; + public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_IS_READY; public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_RESET; public static MethodHandle WICKRA_UPSIDE_GAP_TWO_CROWS_FREE; public static MethodHandle WICKRA_VOLATILITY_RATIO_NEW; public static MethodHandle WICKRA_VOLATILITY_RATIO_UPDATE; public static MethodHandle WICKRA_VOLATILITY_RATIO_BATCH; + public static MethodHandle WICKRA_VOLATILITY_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLATILITY_RATIO_IS_READY; public static MethodHandle WICKRA_VOLATILITY_RATIO_RESET; public static MethodHandle WICKRA_VOLATILITY_RATIO_FREE; public static MethodHandle WICKRA_VOLTY_STOP_NEW; public static MethodHandle WICKRA_VOLTY_STOP_UPDATE; public static MethodHandle WICKRA_VOLTY_STOP_BATCH; + public static MethodHandle WICKRA_VOLTY_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLTY_STOP_IS_READY; public static MethodHandle WICKRA_VOLTY_STOP_RESET; public static MethodHandle WICKRA_VOLTY_STOP_FREE; public static MethodHandle WICKRA_VOLUME_OSCILLATOR_NEW; public static MethodHandle WICKRA_VOLUME_OSCILLATOR_UPDATE; public static MethodHandle WICKRA_VOLUME_OSCILLATOR_BATCH; + public static MethodHandle WICKRA_VOLUME_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_VOLUME_OSCILLATOR_RESET; public static MethodHandle WICKRA_VOLUME_OSCILLATOR_FREE; public static MethodHandle WICKRA_VOLUME_RSI_NEW; public static MethodHandle WICKRA_VOLUME_RSI_UPDATE; public static MethodHandle WICKRA_VOLUME_RSI_BATCH; + public static MethodHandle WICKRA_VOLUME_RSI_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_RSI_IS_READY; public static MethodHandle WICKRA_VOLUME_RSI_RESET; public static MethodHandle WICKRA_VOLUME_RSI_FREE; public static MethodHandle WICKRA_VOLUME_PRICE_TREND_NEW; public static MethodHandle WICKRA_VOLUME_PRICE_TREND_UPDATE; public static MethodHandle WICKRA_VOLUME_PRICE_TREND_BATCH; + public static MethodHandle WICKRA_VOLUME_PRICE_TREND_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_PRICE_TREND_IS_READY; public static MethodHandle WICKRA_VOLUME_PRICE_TREND_RESET; public static MethodHandle WICKRA_VOLUME_PRICE_TREND_FREE; public static MethodHandle WICKRA_VWAP_NEW; public static MethodHandle WICKRA_VWAP_UPDATE; public static MethodHandle WICKRA_VWAP_BATCH; + public static MethodHandle WICKRA_VWAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_VWAP_IS_READY; public static MethodHandle WICKRA_VWAP_RESET; public static MethodHandle WICKRA_VWAP_FREE; public static MethodHandle WICKRA_ROLLING_VWAP_NEW; public static MethodHandle WICKRA_ROLLING_VWAP_UPDATE; public static MethodHandle WICKRA_ROLLING_VWAP_BATCH; + public static MethodHandle WICKRA_ROLLING_VWAP_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLLING_VWAP_IS_READY; public static MethodHandle WICKRA_ROLLING_VWAP_RESET; public static MethodHandle WICKRA_ROLLING_VWAP_FREE; public static MethodHandle WICKRA_VWMA_NEW; public static MethodHandle WICKRA_VWMA_UPDATE; public static MethodHandle WICKRA_VWMA_BATCH; + public static MethodHandle WICKRA_VWMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_VWMA_IS_READY; public static MethodHandle WICKRA_VWMA_RESET; public static MethodHandle WICKRA_VWMA_FREE; public static MethodHandle WICKRA_VZO_NEW; public static MethodHandle WICKRA_VZO_UPDATE; public static MethodHandle WICKRA_VZO_BATCH; + public static MethodHandle WICKRA_VZO_WARMUP_PERIOD; + public static MethodHandle WICKRA_VZO_IS_READY; public static MethodHandle WICKRA_VZO_RESET; public static MethodHandle WICKRA_VZO_FREE; public static MethodHandle WICKRA_WAD_NEW; public static MethodHandle WICKRA_WAD_UPDATE; public static MethodHandle WICKRA_WAD_BATCH; + public static MethodHandle WICKRA_WAD_WARMUP_PERIOD; + public static MethodHandle WICKRA_WAD_IS_READY; public static MethodHandle WICKRA_WAD_RESET; public static MethodHandle WICKRA_WAD_FREE; public static MethodHandle WICKRA_WEDGE_NEW; public static MethodHandle WICKRA_WEDGE_UPDATE; public static MethodHandle WICKRA_WEDGE_BATCH; + public static MethodHandle WICKRA_WEDGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_WEDGE_IS_READY; public static MethodHandle WICKRA_WEDGE_RESET; public static MethodHandle WICKRA_WEDGE_FREE; public static MethodHandle WICKRA_WEIGHTED_CLOSE_NEW; public static MethodHandle WICKRA_WEIGHTED_CLOSE_UPDATE; public static MethodHandle WICKRA_WEIGHTED_CLOSE_BATCH; + public static MethodHandle WICKRA_WEIGHTED_CLOSE_WARMUP_PERIOD; + public static MethodHandle WICKRA_WEIGHTED_CLOSE_IS_READY; public static MethodHandle WICKRA_WEIGHTED_CLOSE_RESET; public static MethodHandle WICKRA_WEIGHTED_CLOSE_FREE; public static MethodHandle WICKRA_WICK_RATIO_NEW; public static MethodHandle WICKRA_WICK_RATIO_UPDATE; public static MethodHandle WICKRA_WICK_RATIO_BATCH; + public static MethodHandle WICKRA_WICK_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_WICK_RATIO_IS_READY; public static MethodHandle WICKRA_WICK_RATIO_RESET; public static MethodHandle WICKRA_WICK_RATIO_FREE; public static MethodHandle WICKRA_WILLIAMS_R_NEW; public static MethodHandle WICKRA_WILLIAMS_R_UPDATE; public static MethodHandle WICKRA_WILLIAMS_R_BATCH; + public static MethodHandle WICKRA_WILLIAMS_R_WARMUP_PERIOD; + public static MethodHandle WICKRA_WILLIAMS_R_IS_READY; public static MethodHandle WICKRA_WILLIAMS_R_RESET; public static MethodHandle WICKRA_WILLIAMS_R_FREE; public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_NEW; public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_UPDATE; public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_BATCH; + public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_IS_READY; public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_RESET; public static MethodHandle WICKRA_YANG_ZHANG_VOLATILITY_FREE; public static MethodHandle WICKRA_YOYO_EXIT_NEW; public static MethodHandle WICKRA_YOYO_EXIT_UPDATE; public static MethodHandle WICKRA_YOYO_EXIT_BATCH; + public static MethodHandle WICKRA_YOYO_EXIT_WARMUP_PERIOD; + public static MethodHandle WICKRA_YOYO_EXIT_IS_READY; public static MethodHandle WICKRA_YOYO_EXIT_RESET; public static MethodHandle WICKRA_YOYO_EXIT_FREE; public static MethodHandle WICKRA_AMIHUD_ILLIQUIDITY_NEW; public static MethodHandle WICKRA_AMIHUD_ILLIQUIDITY_UPDATE; + public static MethodHandle WICKRA_AMIHUD_ILLIQUIDITY_WARMUP_PERIOD; + public static MethodHandle WICKRA_AMIHUD_ILLIQUIDITY_IS_READY; public static MethodHandle WICKRA_AMIHUD_ILLIQUIDITY_RESET; public static MethodHandle WICKRA_AMIHUD_ILLIQUIDITY_FREE; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_DELTA_NEW; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_DELTA_UPDATE; + public static MethodHandle WICKRA_CUMULATIVE_VOLUME_DELTA_WARMUP_PERIOD; + public static MethodHandle WICKRA_CUMULATIVE_VOLUME_DELTA_IS_READY; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_DELTA_RESET; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_DELTA_FREE; public static MethodHandle WICKRA_PIN_NEW; public static MethodHandle WICKRA_PIN_UPDATE; + public static MethodHandle WICKRA_PIN_WARMUP_PERIOD; + public static MethodHandle WICKRA_PIN_IS_READY; public static MethodHandle WICKRA_PIN_RESET; public static MethodHandle WICKRA_PIN_FREE; public static MethodHandle WICKRA_ROLL_MEASURE_NEW; public static MethodHandle WICKRA_ROLL_MEASURE_UPDATE; + public static MethodHandle WICKRA_ROLL_MEASURE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ROLL_MEASURE_IS_READY; public static MethodHandle WICKRA_ROLL_MEASURE_RESET; public static MethodHandle WICKRA_ROLL_MEASURE_FREE; public static MethodHandle WICKRA_SIGNED_VOLUME_NEW; public static MethodHandle WICKRA_SIGNED_VOLUME_UPDATE; + public static MethodHandle WICKRA_SIGNED_VOLUME_WARMUP_PERIOD; + public static MethodHandle WICKRA_SIGNED_VOLUME_IS_READY; public static MethodHandle WICKRA_SIGNED_VOLUME_RESET; public static MethodHandle WICKRA_SIGNED_VOLUME_FREE; public static MethodHandle WICKRA_TRADE_IMBALANCE_NEW; public static MethodHandle WICKRA_TRADE_IMBALANCE_UPDATE; + public static MethodHandle WICKRA_TRADE_IMBALANCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRADE_IMBALANCE_IS_READY; public static MethodHandle WICKRA_TRADE_IMBALANCE_RESET; public static MethodHandle WICKRA_TRADE_IMBALANCE_FREE; public static MethodHandle WICKRA_TRADE_SIGN_AUTOCORRELATION_NEW; public static MethodHandle WICKRA_TRADE_SIGN_AUTOCORRELATION_UPDATE; + public static MethodHandle WICKRA_TRADE_SIGN_AUTOCORRELATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRADE_SIGN_AUTOCORRELATION_IS_READY; public static MethodHandle WICKRA_TRADE_SIGN_AUTOCORRELATION_RESET; public static MethodHandle WICKRA_TRADE_SIGN_AUTOCORRELATION_FREE; public static MethodHandle WICKRA_VPIN_NEW; public static MethodHandle WICKRA_VPIN_UPDATE; + public static MethodHandle WICKRA_VPIN_WARMUP_PERIOD; + public static MethodHandle WICKRA_VPIN_IS_READY; public static MethodHandle WICKRA_VPIN_RESET; public static MethodHandle WICKRA_VPIN_FREE; public static MethodHandle WICKRA_EFFECTIVE_SPREAD_NEW; public static MethodHandle WICKRA_EFFECTIVE_SPREAD_UPDATE; + public static MethodHandle WICKRA_EFFECTIVE_SPREAD_WARMUP_PERIOD; + public static MethodHandle WICKRA_EFFECTIVE_SPREAD_IS_READY; public static MethodHandle WICKRA_EFFECTIVE_SPREAD_RESET; public static MethodHandle WICKRA_EFFECTIVE_SPREAD_FREE; public static MethodHandle WICKRA_KYLES_LAMBDA_NEW; public static MethodHandle WICKRA_KYLES_LAMBDA_UPDATE; + public static MethodHandle WICKRA_KYLES_LAMBDA_WARMUP_PERIOD; + public static MethodHandle WICKRA_KYLES_LAMBDA_IS_READY; public static MethodHandle WICKRA_KYLES_LAMBDA_RESET; public static MethodHandle WICKRA_KYLES_LAMBDA_FREE; public static MethodHandle WICKRA_REALIZED_SPREAD_NEW; public static MethodHandle WICKRA_REALIZED_SPREAD_UPDATE; + public static MethodHandle WICKRA_REALIZED_SPREAD_WARMUP_PERIOD; + public static MethodHandle WICKRA_REALIZED_SPREAD_IS_READY; public static MethodHandle WICKRA_REALIZED_SPREAD_RESET; public static MethodHandle WICKRA_REALIZED_SPREAD_FREE; public static MethodHandle WICKRA_CALENDAR_SPREAD_NEW; public static MethodHandle WICKRA_CALENDAR_SPREAD_UPDATE; + public static MethodHandle WICKRA_CALENDAR_SPREAD_WARMUP_PERIOD; + public static MethodHandle WICKRA_CALENDAR_SPREAD_IS_READY; public static MethodHandle WICKRA_CALENDAR_SPREAD_RESET; public static MethodHandle WICKRA_CALENDAR_SPREAD_FREE; public static MethodHandle WICKRA_ESTIMATED_LEVERAGE_RATIO_NEW; public static MethodHandle WICKRA_ESTIMATED_LEVERAGE_RATIO_UPDATE; + public static MethodHandle WICKRA_ESTIMATED_LEVERAGE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_ESTIMATED_LEVERAGE_RATIO_IS_READY; public static MethodHandle WICKRA_ESTIMATED_LEVERAGE_RATIO_RESET; public static MethodHandle WICKRA_ESTIMATED_LEVERAGE_RATIO_FREE; public static MethodHandle WICKRA_FUNDING_BASIS_NEW; public static MethodHandle WICKRA_FUNDING_BASIS_UPDATE; + public static MethodHandle WICKRA_FUNDING_BASIS_WARMUP_PERIOD; + public static MethodHandle WICKRA_FUNDING_BASIS_IS_READY; public static MethodHandle WICKRA_FUNDING_BASIS_RESET; public static MethodHandle WICKRA_FUNDING_BASIS_FREE; public static MethodHandle WICKRA_FUNDING_IMPLIED_APR_NEW; public static MethodHandle WICKRA_FUNDING_IMPLIED_APR_UPDATE; + public static MethodHandle WICKRA_FUNDING_IMPLIED_APR_WARMUP_PERIOD; + public static MethodHandle WICKRA_FUNDING_IMPLIED_APR_IS_READY; public static MethodHandle WICKRA_FUNDING_IMPLIED_APR_RESET; public static MethodHandle WICKRA_FUNDING_IMPLIED_APR_FREE; public static MethodHandle WICKRA_FUNDING_RATE_NEW; public static MethodHandle WICKRA_FUNDING_RATE_UPDATE; + public static MethodHandle WICKRA_FUNDING_RATE_WARMUP_PERIOD; + public static MethodHandle WICKRA_FUNDING_RATE_IS_READY; public static MethodHandle WICKRA_FUNDING_RATE_RESET; public static MethodHandle WICKRA_FUNDING_RATE_FREE; public static MethodHandle WICKRA_FUNDING_RATE_MEAN_NEW; public static MethodHandle WICKRA_FUNDING_RATE_MEAN_UPDATE; + public static MethodHandle WICKRA_FUNDING_RATE_MEAN_WARMUP_PERIOD; + public static MethodHandle WICKRA_FUNDING_RATE_MEAN_IS_READY; public static MethodHandle WICKRA_FUNDING_RATE_MEAN_RESET; public static MethodHandle WICKRA_FUNDING_RATE_MEAN_FREE; public static MethodHandle WICKRA_FUNDING_RATE_Z_SCORE_NEW; public static MethodHandle WICKRA_FUNDING_RATE_Z_SCORE_UPDATE; + public static MethodHandle WICKRA_FUNDING_RATE_Z_SCORE_WARMUP_PERIOD; + public static MethodHandle WICKRA_FUNDING_RATE_Z_SCORE_IS_READY; public static MethodHandle WICKRA_FUNDING_RATE_Z_SCORE_RESET; public static MethodHandle WICKRA_FUNDING_RATE_Z_SCORE_FREE; public static MethodHandle WICKRA_LONG_SHORT_RATIO_NEW; public static MethodHandle WICKRA_LONG_SHORT_RATIO_UPDATE; + public static MethodHandle WICKRA_LONG_SHORT_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_LONG_SHORT_RATIO_IS_READY; public static MethodHandle WICKRA_LONG_SHORT_RATIO_RESET; public static MethodHandle WICKRA_LONG_SHORT_RATIO_FREE; public static MethodHandle WICKRA_OPEN_INTEREST_DELTA_NEW; public static MethodHandle WICKRA_OPEN_INTEREST_DELTA_UPDATE; + public static MethodHandle WICKRA_OPEN_INTEREST_DELTA_WARMUP_PERIOD; + public static MethodHandle WICKRA_OPEN_INTEREST_DELTA_IS_READY; public static MethodHandle WICKRA_OPEN_INTEREST_DELTA_RESET; public static MethodHandle WICKRA_OPEN_INTEREST_DELTA_FREE; public static MethodHandle WICKRA_OI_PRICE_DIVERGENCE_NEW; public static MethodHandle WICKRA_OI_PRICE_DIVERGENCE_UPDATE; + public static MethodHandle WICKRA_OI_PRICE_DIVERGENCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_OI_PRICE_DIVERGENCE_IS_READY; public static MethodHandle WICKRA_OI_PRICE_DIVERGENCE_RESET; public static MethodHandle WICKRA_OI_PRICE_DIVERGENCE_FREE; public static MethodHandle WICKRA_OI_TO_VOLUME_RATIO_NEW; public static MethodHandle WICKRA_OI_TO_VOLUME_RATIO_UPDATE; + public static MethodHandle WICKRA_OI_TO_VOLUME_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_OI_TO_VOLUME_RATIO_IS_READY; public static MethodHandle WICKRA_OI_TO_VOLUME_RATIO_RESET; public static MethodHandle WICKRA_OI_TO_VOLUME_RATIO_FREE; public static MethodHandle WICKRA_OI_WEIGHTED_NEW; public static MethodHandle WICKRA_OI_WEIGHTED_UPDATE; + public static MethodHandle WICKRA_OI_WEIGHTED_WARMUP_PERIOD; + public static MethodHandle WICKRA_OI_WEIGHTED_IS_READY; public static MethodHandle WICKRA_OI_WEIGHTED_RESET; public static MethodHandle WICKRA_OI_WEIGHTED_FREE; public static MethodHandle WICKRA_OPEN_INTEREST_MOMENTUM_NEW; public static MethodHandle WICKRA_OPEN_INTEREST_MOMENTUM_UPDATE; + public static MethodHandle WICKRA_OPEN_INTEREST_MOMENTUM_WARMUP_PERIOD; + public static MethodHandle WICKRA_OPEN_INTEREST_MOMENTUM_IS_READY; public static MethodHandle WICKRA_OPEN_INTEREST_MOMENTUM_RESET; public static MethodHandle WICKRA_OPEN_INTEREST_MOMENTUM_FREE; public static MethodHandle WICKRA_PERPETUAL_PREMIUM_INDEX_NEW; public static MethodHandle WICKRA_PERPETUAL_PREMIUM_INDEX_UPDATE; + public static MethodHandle WICKRA_PERPETUAL_PREMIUM_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_PERPETUAL_PREMIUM_INDEX_IS_READY; public static MethodHandle WICKRA_PERPETUAL_PREMIUM_INDEX_RESET; public static MethodHandle WICKRA_PERPETUAL_PREMIUM_INDEX_FREE; public static MethodHandle WICKRA_TAKER_BUY_SELL_RATIO_NEW; public static MethodHandle WICKRA_TAKER_BUY_SELL_RATIO_UPDATE; + public static MethodHandle WICKRA_TAKER_BUY_SELL_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_TAKER_BUY_SELL_RATIO_IS_READY; public static MethodHandle WICKRA_TAKER_BUY_SELL_RATIO_RESET; public static MethodHandle WICKRA_TAKER_BUY_SELL_RATIO_FREE; public static MethodHandle WICKRA_TERM_STRUCTURE_BASIS_NEW; public static MethodHandle WICKRA_TERM_STRUCTURE_BASIS_UPDATE; + public static MethodHandle WICKRA_TERM_STRUCTURE_BASIS_WARMUP_PERIOD; + public static MethodHandle WICKRA_TERM_STRUCTURE_BASIS_IS_READY; public static MethodHandle WICKRA_TERM_STRUCTURE_BASIS_RESET; public static MethodHandle WICKRA_TERM_STRUCTURE_BASIS_FREE; public static MethodHandle WICKRA_DEPTH_SLOPE_NEW; public static MethodHandle WICKRA_DEPTH_SLOPE_UPDATE; + public static MethodHandle WICKRA_DEPTH_SLOPE_WARMUP_PERIOD; + public static MethodHandle WICKRA_DEPTH_SLOPE_IS_READY; public static MethodHandle WICKRA_DEPTH_SLOPE_RESET; public static MethodHandle WICKRA_DEPTH_SLOPE_FREE; public static MethodHandle WICKRA_MICROPRICE_NEW; public static MethodHandle WICKRA_MICROPRICE_UPDATE; + public static MethodHandle WICKRA_MICROPRICE_WARMUP_PERIOD; + public static MethodHandle WICKRA_MICROPRICE_IS_READY; public static MethodHandle WICKRA_MICROPRICE_RESET; public static MethodHandle WICKRA_MICROPRICE_FREE; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_FULL_NEW; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_FULL_UPDATE; + public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_FULL_WARMUP_PERIOD; + public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_FULL_IS_READY; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_FULL_RESET; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_FULL_FREE; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP1_NEW; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP1_UPDATE; + public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP1_WARMUP_PERIOD; + public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP1_IS_READY; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP1_RESET; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP1_FREE; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_NEW; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_UPDATE; + public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_WARMUP_PERIOD; + public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_IS_READY; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_RESET; public static MethodHandle WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_FREE; public static MethodHandle WICKRA_ORDER_FLOW_IMBALANCE_NEW; public static MethodHandle WICKRA_ORDER_FLOW_IMBALANCE_UPDATE; + public static MethodHandle WICKRA_ORDER_FLOW_IMBALANCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ORDER_FLOW_IMBALANCE_IS_READY; public static MethodHandle WICKRA_ORDER_FLOW_IMBALANCE_RESET; public static MethodHandle WICKRA_ORDER_FLOW_IMBALANCE_FREE; public static MethodHandle WICKRA_QUOTED_SPREAD_NEW; public static MethodHandle WICKRA_QUOTED_SPREAD_UPDATE; + public static MethodHandle WICKRA_QUOTED_SPREAD_WARMUP_PERIOD; + public static MethodHandle WICKRA_QUOTED_SPREAD_IS_READY; public static MethodHandle WICKRA_QUOTED_SPREAD_RESET; public static MethodHandle WICKRA_QUOTED_SPREAD_FREE; public static MethodHandle WICKRA_ABSOLUTE_BREADTH_INDEX_NEW; public static MethodHandle WICKRA_ABSOLUTE_BREADTH_INDEX_UPDATE; + public static MethodHandle WICKRA_ABSOLUTE_BREADTH_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_ABSOLUTE_BREADTH_INDEX_IS_READY; public static MethodHandle WICKRA_ABSOLUTE_BREADTH_INDEX_RESET; public static MethodHandle WICKRA_ABSOLUTE_BREADTH_INDEX_FREE; public static MethodHandle WICKRA_AD_VOLUME_LINE_NEW; public static MethodHandle WICKRA_AD_VOLUME_LINE_UPDATE; + public static MethodHandle WICKRA_AD_VOLUME_LINE_WARMUP_PERIOD; + public static MethodHandle WICKRA_AD_VOLUME_LINE_IS_READY; public static MethodHandle WICKRA_AD_VOLUME_LINE_RESET; public static MethodHandle WICKRA_AD_VOLUME_LINE_FREE; public static MethodHandle WICKRA_ADVANCE_DECLINE_NEW; public static MethodHandle WICKRA_ADVANCE_DECLINE_UPDATE; + public static MethodHandle WICKRA_ADVANCE_DECLINE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADVANCE_DECLINE_IS_READY; public static MethodHandle WICKRA_ADVANCE_DECLINE_RESET; public static MethodHandle WICKRA_ADVANCE_DECLINE_FREE; public static MethodHandle WICKRA_ADVANCE_DECLINE_RATIO_NEW; public static MethodHandle WICKRA_ADVANCE_DECLINE_RATIO_UPDATE; + public static MethodHandle WICKRA_ADVANCE_DECLINE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADVANCE_DECLINE_RATIO_IS_READY; public static MethodHandle WICKRA_ADVANCE_DECLINE_RATIO_RESET; public static MethodHandle WICKRA_ADVANCE_DECLINE_RATIO_FREE; public static MethodHandle WICKRA_BREADTH_THRUST_NEW; public static MethodHandle WICKRA_BREADTH_THRUST_UPDATE; + public static MethodHandle WICKRA_BREADTH_THRUST_WARMUP_PERIOD; + public static MethodHandle WICKRA_BREADTH_THRUST_IS_READY; public static MethodHandle WICKRA_BREADTH_THRUST_RESET; public static MethodHandle WICKRA_BREADTH_THRUST_FREE; public static MethodHandle WICKRA_BULLISH_PERCENT_INDEX_NEW; public static MethodHandle WICKRA_BULLISH_PERCENT_INDEX_UPDATE; + public static MethodHandle WICKRA_BULLISH_PERCENT_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_BULLISH_PERCENT_INDEX_IS_READY; public static MethodHandle WICKRA_BULLISH_PERCENT_INDEX_RESET; public static MethodHandle WICKRA_BULLISH_PERCENT_INDEX_FREE; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_INDEX_NEW; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_INDEX_UPDATE; + public static MethodHandle WICKRA_CUMULATIVE_VOLUME_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_CUMULATIVE_VOLUME_INDEX_IS_READY; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_INDEX_RESET; public static MethodHandle WICKRA_CUMULATIVE_VOLUME_INDEX_FREE; public static MethodHandle WICKRA_HIGH_LOW_INDEX_NEW; public static MethodHandle WICKRA_HIGH_LOW_INDEX_UPDATE; + public static MethodHandle WICKRA_HIGH_LOW_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIGH_LOW_INDEX_IS_READY; public static MethodHandle WICKRA_HIGH_LOW_INDEX_RESET; public static MethodHandle WICKRA_HIGH_LOW_INDEX_FREE; public static MethodHandle WICKRA_MC_CLELLAN_OSCILLATOR_NEW; public static MethodHandle WICKRA_MC_CLELLAN_OSCILLATOR_UPDATE; + public static MethodHandle WICKRA_MC_CLELLAN_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_MC_CLELLAN_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_MC_CLELLAN_OSCILLATOR_RESET; public static MethodHandle WICKRA_MC_CLELLAN_OSCILLATOR_FREE; public static MethodHandle WICKRA_MC_CLELLAN_SUMMATION_INDEX_NEW; public static MethodHandle WICKRA_MC_CLELLAN_SUMMATION_INDEX_UPDATE; + public static MethodHandle WICKRA_MC_CLELLAN_SUMMATION_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_MC_CLELLAN_SUMMATION_INDEX_IS_READY; public static MethodHandle WICKRA_MC_CLELLAN_SUMMATION_INDEX_RESET; public static MethodHandle WICKRA_MC_CLELLAN_SUMMATION_INDEX_FREE; public static MethodHandle WICKRA_NEW_HIGHS_NEW_LOWS_NEW; public static MethodHandle WICKRA_NEW_HIGHS_NEW_LOWS_UPDATE; + public static MethodHandle WICKRA_NEW_HIGHS_NEW_LOWS_WARMUP_PERIOD; + public static MethodHandle WICKRA_NEW_HIGHS_NEW_LOWS_IS_READY; public static MethodHandle WICKRA_NEW_HIGHS_NEW_LOWS_RESET; public static MethodHandle WICKRA_NEW_HIGHS_NEW_LOWS_FREE; public static MethodHandle WICKRA_PERCENT_ABOVE_MA_NEW; public static MethodHandle WICKRA_PERCENT_ABOVE_MA_UPDATE; + public static MethodHandle WICKRA_PERCENT_ABOVE_MA_WARMUP_PERIOD; + public static MethodHandle WICKRA_PERCENT_ABOVE_MA_IS_READY; public static MethodHandle WICKRA_PERCENT_ABOVE_MA_RESET; public static MethodHandle WICKRA_PERCENT_ABOVE_MA_FREE; public static MethodHandle WICKRA_TICK_INDEX_NEW; public static MethodHandle WICKRA_TICK_INDEX_UPDATE; + public static MethodHandle WICKRA_TICK_INDEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_TICK_INDEX_IS_READY; public static MethodHandle WICKRA_TICK_INDEX_RESET; public static MethodHandle WICKRA_TICK_INDEX_FREE; public static MethodHandle WICKRA_TRIN_NEW; public static MethodHandle WICKRA_TRIN_UPDATE; + public static MethodHandle WICKRA_TRIN_WARMUP_PERIOD; + public static MethodHandle WICKRA_TRIN_IS_READY; public static MethodHandle WICKRA_TRIN_RESET; public static MethodHandle WICKRA_TRIN_FREE; public static MethodHandle WICKRA_UP_DOWN_VOLUME_RATIO_NEW; public static MethodHandle WICKRA_UP_DOWN_VOLUME_RATIO_UPDATE; + public static MethodHandle WICKRA_UP_DOWN_VOLUME_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_UP_DOWN_VOLUME_RATIO_IS_READY; public static MethodHandle WICKRA_UP_DOWN_VOLUME_RATIO_RESET; public static MethodHandle WICKRA_UP_DOWN_VOLUME_RATIO_FREE; public static MethodHandle WICKRA_ACCELERATION_BANDS_NEW; public static MethodHandle WICKRA_ACCELERATION_BANDS_UPDATE; + public static MethodHandle WICKRA_ACCELERATION_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_ACCELERATION_BANDS_IS_READY; public static MethodHandle WICKRA_ACCELERATION_BANDS_RESET; public static MethodHandle WICKRA_ACCELERATION_BANDS_FREE; public static MethodHandle WICKRA_ADX_NEW; public static MethodHandle WICKRA_ADX_UPDATE; + public static MethodHandle WICKRA_ADX_WARMUP_PERIOD; + public static MethodHandle WICKRA_ADX_IS_READY; public static MethodHandle WICKRA_ADX_RESET; public static MethodHandle WICKRA_ADX_FREE; public static MethodHandle WICKRA_ALLIGATOR_NEW; public static MethodHandle WICKRA_ALLIGATOR_UPDATE; + public static MethodHandle WICKRA_ALLIGATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_ALLIGATOR_IS_READY; public static MethodHandle WICKRA_ALLIGATOR_RESET; public static MethodHandle WICKRA_ALLIGATOR_FREE; public static MethodHandle WICKRA_ANDREWS_PITCHFORK_NEW; public static MethodHandle WICKRA_ANDREWS_PITCHFORK_UPDATE; + public static MethodHandle WICKRA_ANDREWS_PITCHFORK_WARMUP_PERIOD; + public static MethodHandle WICKRA_ANDREWS_PITCHFORK_IS_READY; public static MethodHandle WICKRA_ANDREWS_PITCHFORK_RESET; public static MethodHandle WICKRA_ANDREWS_PITCHFORK_FREE; public static MethodHandle WICKRA_AROON_NEW; public static MethodHandle WICKRA_AROON_UPDATE; + public static MethodHandle WICKRA_AROON_WARMUP_PERIOD; + public static MethodHandle WICKRA_AROON_IS_READY; public static MethodHandle WICKRA_AROON_RESET; public static MethodHandle WICKRA_AROON_FREE; public static MethodHandle WICKRA_ATR_BANDS_NEW; public static MethodHandle WICKRA_ATR_BANDS_UPDATE; + public static MethodHandle WICKRA_ATR_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_ATR_BANDS_IS_READY; public static MethodHandle WICKRA_ATR_BANDS_RESET; public static MethodHandle WICKRA_ATR_BANDS_FREE; public static MethodHandle WICKRA_ATR_RATCHET_NEW; public static MethodHandle WICKRA_ATR_RATCHET_UPDATE; + public static MethodHandle WICKRA_ATR_RATCHET_WARMUP_PERIOD; + public static MethodHandle WICKRA_ATR_RATCHET_IS_READY; public static MethodHandle WICKRA_ATR_RATCHET_RESET; public static MethodHandle WICKRA_ATR_RATCHET_FREE; public static MethodHandle WICKRA_AUTO_FIB_NEW; public static MethodHandle WICKRA_AUTO_FIB_UPDATE; + public static MethodHandle WICKRA_AUTO_FIB_WARMUP_PERIOD; + public static MethodHandle WICKRA_AUTO_FIB_IS_READY; public static MethodHandle WICKRA_AUTO_FIB_RESET; public static MethodHandle WICKRA_AUTO_FIB_FREE; public static MethodHandle WICKRA_BOLLINGER_BANDS_NEW; public static MethodHandle WICKRA_BOLLINGER_BANDS_UPDATE; + public static MethodHandle WICKRA_BOLLINGER_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_BOLLINGER_BANDS_IS_READY; public static MethodHandle WICKRA_BOLLINGER_BANDS_RESET; public static MethodHandle WICKRA_BOLLINGER_BANDS_FREE; public static MethodHandle WICKRA_BOMAR_BANDS_NEW; public static MethodHandle WICKRA_BOMAR_BANDS_UPDATE; + public static MethodHandle WICKRA_BOMAR_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_BOMAR_BANDS_IS_READY; public static MethodHandle WICKRA_BOMAR_BANDS_RESET; public static MethodHandle WICKRA_BOMAR_BANDS_FREE; public static MethodHandle WICKRA_CAMARILLA_NEW; public static MethodHandle WICKRA_CAMARILLA_UPDATE; + public static MethodHandle WICKRA_CAMARILLA_WARMUP_PERIOD; + public static MethodHandle WICKRA_CAMARILLA_IS_READY; public static MethodHandle WICKRA_CAMARILLA_RESET; public static MethodHandle WICKRA_CAMARILLA_FREE; public static MethodHandle WICKRA_CANDLE_VOLUME_NEW; public static MethodHandle WICKRA_CANDLE_VOLUME_UPDATE; + public static MethodHandle WICKRA_CANDLE_VOLUME_WARMUP_PERIOD; + public static MethodHandle WICKRA_CANDLE_VOLUME_IS_READY; public static MethodHandle WICKRA_CANDLE_VOLUME_RESET; public static MethodHandle WICKRA_CANDLE_VOLUME_FREE; public static MethodHandle WICKRA_CENTRAL_PIVOT_RANGE_NEW; public static MethodHandle WICKRA_CENTRAL_PIVOT_RANGE_UPDATE; + public static MethodHandle WICKRA_CENTRAL_PIVOT_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_CENTRAL_PIVOT_RANGE_IS_READY; public static MethodHandle WICKRA_CENTRAL_PIVOT_RANGE_RESET; public static MethodHandle WICKRA_CENTRAL_PIVOT_RANGE_FREE; public static MethodHandle WICKRA_CHANDE_KROLL_STOP_NEW; public static MethodHandle WICKRA_CHANDE_KROLL_STOP_UPDATE; + public static MethodHandle WICKRA_CHANDE_KROLL_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_CHANDE_KROLL_STOP_IS_READY; public static MethodHandle WICKRA_CHANDE_KROLL_STOP_RESET; public static MethodHandle WICKRA_CHANDE_KROLL_STOP_FREE; public static MethodHandle WICKRA_CHANDELIER_EXIT_NEW; public static MethodHandle WICKRA_CHANDELIER_EXIT_UPDATE; + public static MethodHandle WICKRA_CHANDELIER_EXIT_WARMUP_PERIOD; + public static MethodHandle WICKRA_CHANDELIER_EXIT_IS_READY; public static MethodHandle WICKRA_CHANDELIER_EXIT_RESET; public static MethodHandle WICKRA_CHANDELIER_EXIT_FREE; public static MethodHandle WICKRA_CLASSIC_PIVOTS_NEW; public static MethodHandle WICKRA_CLASSIC_PIVOTS_UPDATE; + public static MethodHandle WICKRA_CLASSIC_PIVOTS_WARMUP_PERIOD; + public static MethodHandle WICKRA_CLASSIC_PIVOTS_IS_READY; public static MethodHandle WICKRA_CLASSIC_PIVOTS_RESET; public static MethodHandle WICKRA_CLASSIC_PIVOTS_FREE; public static MethodHandle WICKRA_COINTEGRATION_NEW; public static MethodHandle WICKRA_COINTEGRATION_UPDATE; + public static MethodHandle WICKRA_COINTEGRATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_COINTEGRATION_IS_READY; public static MethodHandle WICKRA_COINTEGRATION_RESET; public static MethodHandle WICKRA_COINTEGRATION_FREE; public static MethodHandle WICKRA_COMPOSITE_PROFILE_NEW; public static MethodHandle WICKRA_COMPOSITE_PROFILE_UPDATE; + public static MethodHandle WICKRA_COMPOSITE_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_COMPOSITE_PROFILE_IS_READY; public static MethodHandle WICKRA_COMPOSITE_PROFILE_RESET; public static MethodHandle WICKRA_COMPOSITE_PROFILE_FREE; public static MethodHandle WICKRA_DEMARK_PIVOTS_NEW; public static MethodHandle WICKRA_DEMARK_PIVOTS_UPDATE; + public static MethodHandle WICKRA_DEMARK_PIVOTS_WARMUP_PERIOD; + public static MethodHandle WICKRA_DEMARK_PIVOTS_IS_READY; public static MethodHandle WICKRA_DEMARK_PIVOTS_RESET; public static MethodHandle WICKRA_DEMARK_PIVOTS_FREE; public static MethodHandle WICKRA_DONCHIAN_NEW; public static MethodHandle WICKRA_DONCHIAN_UPDATE; + public static MethodHandle WICKRA_DONCHIAN_WARMUP_PERIOD; + public static MethodHandle WICKRA_DONCHIAN_IS_READY; public static MethodHandle WICKRA_DONCHIAN_RESET; public static MethodHandle WICKRA_DONCHIAN_FREE; public static MethodHandle WICKRA_DONCHIAN_STOP_NEW; public static MethodHandle WICKRA_DONCHIAN_STOP_UPDATE; + public static MethodHandle WICKRA_DONCHIAN_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_DONCHIAN_STOP_IS_READY; public static MethodHandle WICKRA_DONCHIAN_STOP_RESET; public static MethodHandle WICKRA_DONCHIAN_STOP_FREE; public static MethodHandle WICKRA_DOUBLE_BOLLINGER_NEW; public static MethodHandle WICKRA_DOUBLE_BOLLINGER_UPDATE; + public static MethodHandle WICKRA_DOUBLE_BOLLINGER_WARMUP_PERIOD; + public static MethodHandle WICKRA_DOUBLE_BOLLINGER_IS_READY; public static MethodHandle WICKRA_DOUBLE_BOLLINGER_RESET; public static MethodHandle WICKRA_DOUBLE_BOLLINGER_FREE; public static MethodHandle WICKRA_ELDER_RAY_NEW; public static MethodHandle WICKRA_ELDER_RAY_UPDATE; + public static MethodHandle WICKRA_ELDER_RAY_WARMUP_PERIOD; + public static MethodHandle WICKRA_ELDER_RAY_IS_READY; public static MethodHandle WICKRA_ELDER_RAY_RESET; public static MethodHandle WICKRA_ELDER_RAY_FREE; public static MethodHandle WICKRA_ELDER_SAFE_ZONE_NEW; public static MethodHandle WICKRA_ELDER_SAFE_ZONE_UPDATE; + public static MethodHandle WICKRA_ELDER_SAFE_ZONE_WARMUP_PERIOD; + public static MethodHandle WICKRA_ELDER_SAFE_ZONE_IS_READY; public static MethodHandle WICKRA_ELDER_SAFE_ZONE_RESET; public static MethodHandle WICKRA_ELDER_SAFE_ZONE_FREE; public static MethodHandle WICKRA_EQUIVOLUME_NEW; public static MethodHandle WICKRA_EQUIVOLUME_UPDATE; + public static MethodHandle WICKRA_EQUIVOLUME_WARMUP_PERIOD; + public static MethodHandle WICKRA_EQUIVOLUME_IS_READY; public static MethodHandle WICKRA_EQUIVOLUME_RESET; public static MethodHandle WICKRA_EQUIVOLUME_FREE; public static MethodHandle WICKRA_FIB_ARCS_NEW; public static MethodHandle WICKRA_FIB_ARCS_UPDATE; + public static MethodHandle WICKRA_FIB_ARCS_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_ARCS_IS_READY; public static MethodHandle WICKRA_FIB_ARCS_RESET; public static MethodHandle WICKRA_FIB_ARCS_FREE; public static MethodHandle WICKRA_FIB_CHANNEL_NEW; public static MethodHandle WICKRA_FIB_CHANNEL_UPDATE; + public static MethodHandle WICKRA_FIB_CHANNEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_CHANNEL_IS_READY; public static MethodHandle WICKRA_FIB_CHANNEL_RESET; public static MethodHandle WICKRA_FIB_CHANNEL_FREE; public static MethodHandle WICKRA_FIB_CONFLUENCE_NEW; public static MethodHandle WICKRA_FIB_CONFLUENCE_UPDATE; + public static MethodHandle WICKRA_FIB_CONFLUENCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_CONFLUENCE_IS_READY; public static MethodHandle WICKRA_FIB_CONFLUENCE_RESET; public static MethodHandle WICKRA_FIB_CONFLUENCE_FREE; public static MethodHandle WICKRA_FIB_EXTENSION_NEW; public static MethodHandle WICKRA_FIB_EXTENSION_UPDATE; + public static MethodHandle WICKRA_FIB_EXTENSION_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_EXTENSION_IS_READY; public static MethodHandle WICKRA_FIB_EXTENSION_RESET; public static MethodHandle WICKRA_FIB_EXTENSION_FREE; public static MethodHandle WICKRA_FIB_FAN_NEW; public static MethodHandle WICKRA_FIB_FAN_UPDATE; + public static MethodHandle WICKRA_FIB_FAN_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_FAN_IS_READY; public static MethodHandle WICKRA_FIB_FAN_RESET; public static MethodHandle WICKRA_FIB_FAN_FREE; public static MethodHandle WICKRA_FIB_PROJECTION_NEW; public static MethodHandle WICKRA_FIB_PROJECTION_UPDATE; + public static MethodHandle WICKRA_FIB_PROJECTION_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_PROJECTION_IS_READY; public static MethodHandle WICKRA_FIB_PROJECTION_RESET; public static MethodHandle WICKRA_FIB_PROJECTION_FREE; public static MethodHandle WICKRA_FIB_RETRACEMENT_NEW; public static MethodHandle WICKRA_FIB_RETRACEMENT_UPDATE; + public static MethodHandle WICKRA_FIB_RETRACEMENT_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_RETRACEMENT_IS_READY; public static MethodHandle WICKRA_FIB_RETRACEMENT_RESET; public static MethodHandle WICKRA_FIB_RETRACEMENT_FREE; public static MethodHandle WICKRA_FIB_TIME_ZONES_NEW; public static MethodHandle WICKRA_FIB_TIME_ZONES_UPDATE; + public static MethodHandle WICKRA_FIB_TIME_ZONES_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIB_TIME_ZONES_IS_READY; public static MethodHandle WICKRA_FIB_TIME_ZONES_RESET; public static MethodHandle WICKRA_FIB_TIME_ZONES_FREE; public static MethodHandle WICKRA_FIBONACCI_PIVOTS_NEW; public static MethodHandle WICKRA_FIBONACCI_PIVOTS_UPDATE; + public static MethodHandle WICKRA_FIBONACCI_PIVOTS_WARMUP_PERIOD; + public static MethodHandle WICKRA_FIBONACCI_PIVOTS_IS_READY; public static MethodHandle WICKRA_FIBONACCI_PIVOTS_RESET; public static MethodHandle WICKRA_FIBONACCI_PIVOTS_FREE; public static MethodHandle WICKRA_FRACTAL_CHAOS_BANDS_NEW; public static MethodHandle WICKRA_FRACTAL_CHAOS_BANDS_UPDATE; + public static MethodHandle WICKRA_FRACTAL_CHAOS_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_FRACTAL_CHAOS_BANDS_IS_READY; public static MethodHandle WICKRA_FRACTAL_CHAOS_BANDS_RESET; public static MethodHandle WICKRA_FRACTAL_CHAOS_BANDS_FREE; public static MethodHandle WICKRA_GATOR_OSCILLATOR_NEW; public static MethodHandle WICKRA_GATOR_OSCILLATOR_UPDATE; + public static MethodHandle WICKRA_GATOR_OSCILLATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_GATOR_OSCILLATOR_IS_READY; public static MethodHandle WICKRA_GATOR_OSCILLATOR_RESET; public static MethodHandle WICKRA_GATOR_OSCILLATOR_FREE; public static MethodHandle WICKRA_GOLDEN_POCKET_NEW; public static MethodHandle WICKRA_GOLDEN_POCKET_UPDATE; + public static MethodHandle WICKRA_GOLDEN_POCKET_WARMUP_PERIOD; + public static MethodHandle WICKRA_GOLDEN_POCKET_IS_READY; public static MethodHandle WICKRA_GOLDEN_POCKET_RESET; public static MethodHandle WICKRA_GOLDEN_POCKET_FREE; public static MethodHandle WICKRA_HEIKIN_ASHI_NEW; public static MethodHandle WICKRA_HEIKIN_ASHI_UPDATE; + public static MethodHandle WICKRA_HEIKIN_ASHI_WARMUP_PERIOD; + public static MethodHandle WICKRA_HEIKIN_ASHI_IS_READY; public static MethodHandle WICKRA_HEIKIN_ASHI_RESET; public static MethodHandle WICKRA_HEIKIN_ASHI_FREE; public static MethodHandle WICKRA_HIGH_LOW_VOLUME_NODES_NEW; public static MethodHandle WICKRA_HIGH_LOW_VOLUME_NODES_UPDATE; + public static MethodHandle WICKRA_HIGH_LOW_VOLUME_NODES_WARMUP_PERIOD; + public static MethodHandle WICKRA_HIGH_LOW_VOLUME_NODES_IS_READY; public static MethodHandle WICKRA_HIGH_LOW_VOLUME_NODES_RESET; public static MethodHandle WICKRA_HIGH_LOW_VOLUME_NODES_FREE; public static MethodHandle WICKRA_HT_PHASOR_NEW; public static MethodHandle WICKRA_HT_PHASOR_UPDATE; + public static MethodHandle WICKRA_HT_PHASOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_HT_PHASOR_IS_READY; public static MethodHandle WICKRA_HT_PHASOR_RESET; public static MethodHandle WICKRA_HT_PHASOR_FREE; public static MethodHandle WICKRA_HURST_CHANNEL_NEW; public static MethodHandle WICKRA_HURST_CHANNEL_UPDATE; + public static MethodHandle WICKRA_HURST_CHANNEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_HURST_CHANNEL_IS_READY; public static MethodHandle WICKRA_HURST_CHANNEL_RESET; public static MethodHandle WICKRA_HURST_CHANNEL_FREE; public static MethodHandle WICKRA_ICHIMOKU_NEW; public static MethodHandle WICKRA_ICHIMOKU_UPDATE; + public static MethodHandle WICKRA_ICHIMOKU_WARMUP_PERIOD; + public static MethodHandle WICKRA_ICHIMOKU_IS_READY; public static MethodHandle WICKRA_ICHIMOKU_RESET; public static MethodHandle WICKRA_ICHIMOKU_FREE; public static MethodHandle WICKRA_INITIAL_BALANCE_NEW; public static MethodHandle WICKRA_INITIAL_BALANCE_UPDATE; + public static MethodHandle WICKRA_INITIAL_BALANCE_WARMUP_PERIOD; + public static MethodHandle WICKRA_INITIAL_BALANCE_IS_READY; public static MethodHandle WICKRA_INITIAL_BALANCE_RESET; public static MethodHandle WICKRA_INITIAL_BALANCE_FREE; public static MethodHandle WICKRA_KALMAN_HEDGE_RATIO_NEW; public static MethodHandle WICKRA_KALMAN_HEDGE_RATIO_UPDATE; + public static MethodHandle WICKRA_KALMAN_HEDGE_RATIO_WARMUP_PERIOD; + public static MethodHandle WICKRA_KALMAN_HEDGE_RATIO_IS_READY; public static MethodHandle WICKRA_KALMAN_HEDGE_RATIO_RESET; public static MethodHandle WICKRA_KALMAN_HEDGE_RATIO_FREE; public static MethodHandle WICKRA_KASE_DEV_STOP_NEW; public static MethodHandle WICKRA_KASE_DEV_STOP_UPDATE; + public static MethodHandle WICKRA_KASE_DEV_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_KASE_DEV_STOP_IS_READY; public static MethodHandle WICKRA_KASE_DEV_STOP_RESET; public static MethodHandle WICKRA_KASE_DEV_STOP_FREE; public static MethodHandle WICKRA_KASE_PERMISSION_STOCHASTIC_NEW; public static MethodHandle WICKRA_KASE_PERMISSION_STOCHASTIC_UPDATE; + public static MethodHandle WICKRA_KASE_PERMISSION_STOCHASTIC_WARMUP_PERIOD; + public static MethodHandle WICKRA_KASE_PERMISSION_STOCHASTIC_IS_READY; public static MethodHandle WICKRA_KASE_PERMISSION_STOCHASTIC_RESET; public static MethodHandle WICKRA_KASE_PERMISSION_STOCHASTIC_FREE; public static MethodHandle WICKRA_KELTNER_NEW; public static MethodHandle WICKRA_KELTNER_UPDATE; + public static MethodHandle WICKRA_KELTNER_WARMUP_PERIOD; + public static MethodHandle WICKRA_KELTNER_IS_READY; public static MethodHandle WICKRA_KELTNER_RESET; public static MethodHandle WICKRA_KELTNER_FREE; public static MethodHandle WICKRA_KST_NEW; public static MethodHandle WICKRA_KST_UPDATE; + public static MethodHandle WICKRA_KST_WARMUP_PERIOD; + public static MethodHandle WICKRA_KST_IS_READY; public static MethodHandle WICKRA_KST_RESET; public static MethodHandle WICKRA_KST_FREE; public static MethodHandle WICKRA_LEAD_LAG_CROSS_CORRELATION_NEW; public static MethodHandle WICKRA_LEAD_LAG_CROSS_CORRELATION_UPDATE; + public static MethodHandle WICKRA_LEAD_LAG_CROSS_CORRELATION_WARMUP_PERIOD; + public static MethodHandle WICKRA_LEAD_LAG_CROSS_CORRELATION_IS_READY; public static MethodHandle WICKRA_LEAD_LAG_CROSS_CORRELATION_RESET; public static MethodHandle WICKRA_LEAD_LAG_CROSS_CORRELATION_FREE; public static MethodHandle WICKRA_LIN_REG_CHANNEL_NEW; public static MethodHandle WICKRA_LIN_REG_CHANNEL_UPDATE; + public static MethodHandle WICKRA_LIN_REG_CHANNEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_LIN_REG_CHANNEL_IS_READY; public static MethodHandle WICKRA_LIN_REG_CHANNEL_RESET; public static MethodHandle WICKRA_LIN_REG_CHANNEL_FREE; public static MethodHandle WICKRA_LIQUIDATION_FEATURES_NEW; public static MethodHandle WICKRA_LIQUIDATION_FEATURES_UPDATE; + public static MethodHandle WICKRA_LIQUIDATION_FEATURES_WARMUP_PERIOD; + public static MethodHandle WICKRA_LIQUIDATION_FEATURES_IS_READY; public static MethodHandle WICKRA_LIQUIDATION_FEATURES_RESET; public static MethodHandle WICKRA_LIQUIDATION_FEATURES_FREE; public static MethodHandle WICKRA_MA_ENVELOPE_NEW; public static MethodHandle WICKRA_MA_ENVELOPE_UPDATE; + public static MethodHandle WICKRA_MA_ENVELOPE_WARMUP_PERIOD; + public static MethodHandle WICKRA_MA_ENVELOPE_IS_READY; public static MethodHandle WICKRA_MA_ENVELOPE_RESET; public static MethodHandle WICKRA_MA_ENVELOPE_FREE; public static MethodHandle WICKRA_MACD_INDICATOR_NEW; public static MethodHandle WICKRA_MACD_INDICATOR_UPDATE; + public static MethodHandle WICKRA_MACD_INDICATOR_WARMUP_PERIOD; + public static MethodHandle WICKRA_MACD_INDICATOR_IS_READY; public static MethodHandle WICKRA_MACD_INDICATOR_RESET; public static MethodHandle WICKRA_MACD_INDICATOR_FREE; public static MethodHandle WICKRA_MACD_FIX_NEW; public static MethodHandle WICKRA_MACD_FIX_UPDATE; + public static MethodHandle WICKRA_MACD_FIX_WARMUP_PERIOD; + public static MethodHandle WICKRA_MACD_FIX_IS_READY; public static MethodHandle WICKRA_MACD_FIX_RESET; public static MethodHandle WICKRA_MACD_FIX_FREE; public static MethodHandle WICKRA_MAMA_NEW; public static MethodHandle WICKRA_MAMA_UPDATE; + public static MethodHandle WICKRA_MAMA_WARMUP_PERIOD; + public static MethodHandle WICKRA_MAMA_IS_READY; public static MethodHandle WICKRA_MAMA_RESET; public static MethodHandle WICKRA_MAMA_FREE; public static MethodHandle WICKRA_MEDIAN_CHANNEL_NEW; public static MethodHandle WICKRA_MEDIAN_CHANNEL_UPDATE; + public static MethodHandle WICKRA_MEDIAN_CHANNEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_MEDIAN_CHANNEL_IS_READY; public static MethodHandle WICKRA_MEDIAN_CHANNEL_RESET; public static MethodHandle WICKRA_MEDIAN_CHANNEL_FREE; public static MethodHandle WICKRA_MODIFIED_MA_STOP_NEW; public static MethodHandle WICKRA_MODIFIED_MA_STOP_UPDATE; + public static MethodHandle WICKRA_MODIFIED_MA_STOP_WARMUP_PERIOD; + public static MethodHandle WICKRA_MODIFIED_MA_STOP_IS_READY; public static MethodHandle WICKRA_MODIFIED_MA_STOP_RESET; public static MethodHandle WICKRA_MODIFIED_MA_STOP_FREE; public static MethodHandle WICKRA_MURREY_MATH_LINES_NEW; public static MethodHandle WICKRA_MURREY_MATH_LINES_UPDATE; + public static MethodHandle WICKRA_MURREY_MATH_LINES_WARMUP_PERIOD; + public static MethodHandle WICKRA_MURREY_MATH_LINES_IS_READY; public static MethodHandle WICKRA_MURREY_MATH_LINES_RESET; public static MethodHandle WICKRA_MURREY_MATH_LINES_FREE; public static MethodHandle WICKRA_NRTR_NEW; public static MethodHandle WICKRA_NRTR_UPDATE; + public static MethodHandle WICKRA_NRTR_WARMUP_PERIOD; + public static MethodHandle WICKRA_NRTR_IS_READY; public static MethodHandle WICKRA_NRTR_RESET; public static MethodHandle WICKRA_NRTR_FREE; public static MethodHandle WICKRA_OPENING_RANGE_NEW; public static MethodHandle WICKRA_OPENING_RANGE_UPDATE; + public static MethodHandle WICKRA_OPENING_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_OPENING_RANGE_IS_READY; public static MethodHandle WICKRA_OPENING_RANGE_RESET; public static MethodHandle WICKRA_OPENING_RANGE_FREE; public static MethodHandle WICKRA_OVERNIGHT_INTRADAY_RETURN_NEW; public static MethodHandle WICKRA_OVERNIGHT_INTRADAY_RETURN_UPDATE; + public static MethodHandle WICKRA_OVERNIGHT_INTRADAY_RETURN_WARMUP_PERIOD; + public static MethodHandle WICKRA_OVERNIGHT_INTRADAY_RETURN_IS_READY; public static MethodHandle WICKRA_OVERNIGHT_INTRADAY_RETURN_RESET; public static MethodHandle WICKRA_OVERNIGHT_INTRADAY_RETURN_FREE; public static MethodHandle WICKRA_PROJECTION_BANDS_NEW; public static MethodHandle WICKRA_PROJECTION_BANDS_UPDATE; + public static MethodHandle WICKRA_PROJECTION_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_PROJECTION_BANDS_IS_READY; public static MethodHandle WICKRA_PROJECTION_BANDS_RESET; public static MethodHandle WICKRA_PROJECTION_BANDS_FREE; public static MethodHandle WICKRA_QQE_NEW; public static MethodHandle WICKRA_QQE_UPDATE; + public static MethodHandle WICKRA_QQE_WARMUP_PERIOD; + public static MethodHandle WICKRA_QQE_IS_READY; public static MethodHandle WICKRA_QQE_RESET; public static MethodHandle WICKRA_QQE_FREE; public static MethodHandle WICKRA_QUARTILE_BANDS_NEW; public static MethodHandle WICKRA_QUARTILE_BANDS_UPDATE; + public static MethodHandle WICKRA_QUARTILE_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_QUARTILE_BANDS_IS_READY; public static MethodHandle WICKRA_QUARTILE_BANDS_RESET; public static MethodHandle WICKRA_QUARTILE_BANDS_FREE; public static MethodHandle WICKRA_RELATIVE_STRENGTH_AB_NEW; public static MethodHandle WICKRA_RELATIVE_STRENGTH_AB_UPDATE; + public static MethodHandle WICKRA_RELATIVE_STRENGTH_AB_WARMUP_PERIOD; + public static MethodHandle WICKRA_RELATIVE_STRENGTH_AB_IS_READY; public static MethodHandle WICKRA_RELATIVE_STRENGTH_AB_RESET; public static MethodHandle WICKRA_RELATIVE_STRENGTH_AB_FREE; public static MethodHandle WICKRA_RWI_NEW; public static MethodHandle WICKRA_RWI_UPDATE; + public static MethodHandle WICKRA_RWI_WARMUP_PERIOD; + public static MethodHandle WICKRA_RWI_IS_READY; public static MethodHandle WICKRA_RWI_RESET; public static MethodHandle WICKRA_RWI_FREE; public static MethodHandle WICKRA_SESSION_HIGH_LOW_NEW; public static MethodHandle WICKRA_SESSION_HIGH_LOW_UPDATE; + public static MethodHandle WICKRA_SESSION_HIGH_LOW_WARMUP_PERIOD; + public static MethodHandle WICKRA_SESSION_HIGH_LOW_IS_READY; public static MethodHandle WICKRA_SESSION_HIGH_LOW_RESET; public static MethodHandle WICKRA_SESSION_HIGH_LOW_FREE; public static MethodHandle WICKRA_SESSION_RANGE_NEW; public static MethodHandle WICKRA_SESSION_RANGE_UPDATE; + public static MethodHandle WICKRA_SESSION_RANGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_SESSION_RANGE_IS_READY; public static MethodHandle WICKRA_SESSION_RANGE_RESET; public static MethodHandle WICKRA_SESSION_RANGE_FREE; public static MethodHandle WICKRA_SMOOTHED_HEIKIN_ASHI_NEW; public static MethodHandle WICKRA_SMOOTHED_HEIKIN_ASHI_UPDATE; + public static MethodHandle WICKRA_SMOOTHED_HEIKIN_ASHI_WARMUP_PERIOD; + public static MethodHandle WICKRA_SMOOTHED_HEIKIN_ASHI_IS_READY; public static MethodHandle WICKRA_SMOOTHED_HEIKIN_ASHI_RESET; public static MethodHandle WICKRA_SMOOTHED_HEIKIN_ASHI_FREE; public static MethodHandle WICKRA_SPREAD_BOLLINGER_BANDS_NEW; public static MethodHandle WICKRA_SPREAD_BOLLINGER_BANDS_UPDATE; + public static MethodHandle WICKRA_SPREAD_BOLLINGER_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_SPREAD_BOLLINGER_BANDS_IS_READY; public static MethodHandle WICKRA_SPREAD_BOLLINGER_BANDS_RESET; public static MethodHandle WICKRA_SPREAD_BOLLINGER_BANDS_FREE; public static MethodHandle WICKRA_STANDARD_ERROR_BANDS_NEW; public static MethodHandle WICKRA_STANDARD_ERROR_BANDS_UPDATE; + public static MethodHandle WICKRA_STANDARD_ERROR_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_STANDARD_ERROR_BANDS_IS_READY; public static MethodHandle WICKRA_STANDARD_ERROR_BANDS_RESET; public static MethodHandle WICKRA_STANDARD_ERROR_BANDS_FREE; public static MethodHandle WICKRA_STARC_BANDS_NEW; public static MethodHandle WICKRA_STARC_BANDS_UPDATE; + public static MethodHandle WICKRA_STARC_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_STARC_BANDS_IS_READY; public static MethodHandle WICKRA_STARC_BANDS_RESET; public static MethodHandle WICKRA_STARC_BANDS_FREE; public static MethodHandle WICKRA_STOCHASTIC_NEW; public static MethodHandle WICKRA_STOCHASTIC_UPDATE; + public static MethodHandle WICKRA_STOCHASTIC_WARMUP_PERIOD; + public static MethodHandle WICKRA_STOCHASTIC_IS_READY; public static MethodHandle WICKRA_STOCHASTIC_RESET; public static MethodHandle WICKRA_STOCHASTIC_FREE; public static MethodHandle WICKRA_SUPER_TREND_NEW; public static MethodHandle WICKRA_SUPER_TREND_UPDATE; + public static MethodHandle WICKRA_SUPER_TREND_WARMUP_PERIOD; + public static MethodHandle WICKRA_SUPER_TREND_IS_READY; public static MethodHandle WICKRA_SUPER_TREND_RESET; public static MethodHandle WICKRA_SUPER_TREND_FREE; public static MethodHandle WICKRA_TD_LINES_NEW; public static MethodHandle WICKRA_TD_LINES_UPDATE; + public static MethodHandle WICKRA_TD_LINES_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_LINES_IS_READY; public static MethodHandle WICKRA_TD_LINES_RESET; public static MethodHandle WICKRA_TD_LINES_FREE; public static MethodHandle WICKRA_TD_MOVING_AVERAGE_NEW; public static MethodHandle WICKRA_TD_MOVING_AVERAGE_UPDATE; + public static MethodHandle WICKRA_TD_MOVING_AVERAGE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_MOVING_AVERAGE_IS_READY; public static MethodHandle WICKRA_TD_MOVING_AVERAGE_RESET; public static MethodHandle WICKRA_TD_MOVING_AVERAGE_FREE; public static MethodHandle WICKRA_TD_RANGE_PROJECTION_NEW; public static MethodHandle WICKRA_TD_RANGE_PROJECTION_UPDATE; + public static MethodHandle WICKRA_TD_RANGE_PROJECTION_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_RANGE_PROJECTION_IS_READY; public static MethodHandle WICKRA_TD_RANGE_PROJECTION_RESET; public static MethodHandle WICKRA_TD_RANGE_PROJECTION_FREE; public static MethodHandle WICKRA_TD_RISK_LEVEL_NEW; public static MethodHandle WICKRA_TD_RISK_LEVEL_UPDATE; + public static MethodHandle WICKRA_TD_RISK_LEVEL_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_RISK_LEVEL_IS_READY; public static MethodHandle WICKRA_TD_RISK_LEVEL_RESET; public static MethodHandle WICKRA_TD_RISK_LEVEL_FREE; public static MethodHandle WICKRA_TD_SEQUENTIAL_NEW; public static MethodHandle WICKRA_TD_SEQUENTIAL_UPDATE; + public static MethodHandle WICKRA_TD_SEQUENTIAL_WARMUP_PERIOD; + public static MethodHandle WICKRA_TD_SEQUENTIAL_IS_READY; public static MethodHandle WICKRA_TD_SEQUENTIAL_RESET; public static MethodHandle WICKRA_TD_SEQUENTIAL_FREE; public static MethodHandle WICKRA_TTM_SQUEEZE_NEW; public static MethodHandle WICKRA_TTM_SQUEEZE_UPDATE; + public static MethodHandle WICKRA_TTM_SQUEEZE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TTM_SQUEEZE_IS_READY; public static MethodHandle WICKRA_TTM_SQUEEZE_RESET; public static MethodHandle WICKRA_TTM_SQUEEZE_FREE; public static MethodHandle WICKRA_VALUE_AREA_NEW; public static MethodHandle WICKRA_VALUE_AREA_UPDATE; + public static MethodHandle WICKRA_VALUE_AREA_WARMUP_PERIOD; + public static MethodHandle WICKRA_VALUE_AREA_IS_READY; public static MethodHandle WICKRA_VALUE_AREA_RESET; public static MethodHandle WICKRA_VALUE_AREA_FREE; public static MethodHandle WICKRA_VOLATILITY_CONE_NEW; public static MethodHandle WICKRA_VOLATILITY_CONE_UPDATE; + public static MethodHandle WICKRA_VOLATILITY_CONE_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLATILITY_CONE_IS_READY; public static MethodHandle WICKRA_VOLATILITY_CONE_RESET; public static MethodHandle WICKRA_VOLATILITY_CONE_FREE; public static MethodHandle WICKRA_VOLUME_WEIGHTED_MACD_NEW; public static MethodHandle WICKRA_VOLUME_WEIGHTED_MACD_UPDATE; + public static MethodHandle WICKRA_VOLUME_WEIGHTED_MACD_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_WEIGHTED_MACD_IS_READY; public static MethodHandle WICKRA_VOLUME_WEIGHTED_MACD_RESET; public static MethodHandle WICKRA_VOLUME_WEIGHTED_MACD_FREE; public static MethodHandle WICKRA_VOLUME_WEIGHTED_SR_NEW; public static MethodHandle WICKRA_VOLUME_WEIGHTED_SR_UPDATE; + public static MethodHandle WICKRA_VOLUME_WEIGHTED_SR_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_WEIGHTED_SR_IS_READY; public static MethodHandle WICKRA_VOLUME_WEIGHTED_SR_RESET; public static MethodHandle WICKRA_VOLUME_WEIGHTED_SR_FREE; public static MethodHandle WICKRA_VORTEX_NEW; public static MethodHandle WICKRA_VORTEX_UPDATE; + public static MethodHandle WICKRA_VORTEX_WARMUP_PERIOD; + public static MethodHandle WICKRA_VORTEX_IS_READY; public static MethodHandle WICKRA_VORTEX_RESET; public static MethodHandle WICKRA_VORTEX_FREE; public static MethodHandle WICKRA_VWAP_STD_DEV_BANDS_NEW; public static MethodHandle WICKRA_VWAP_STD_DEV_BANDS_UPDATE; + public static MethodHandle WICKRA_VWAP_STD_DEV_BANDS_WARMUP_PERIOD; + public static MethodHandle WICKRA_VWAP_STD_DEV_BANDS_IS_READY; public static MethodHandle WICKRA_VWAP_STD_DEV_BANDS_RESET; public static MethodHandle WICKRA_VWAP_STD_DEV_BANDS_FREE; public static MethodHandle WICKRA_WAVE_TREND_NEW; public static MethodHandle WICKRA_WAVE_TREND_UPDATE; + public static MethodHandle WICKRA_WAVE_TREND_WARMUP_PERIOD; + public static MethodHandle WICKRA_WAVE_TREND_IS_READY; public static MethodHandle WICKRA_WAVE_TREND_RESET; public static MethodHandle WICKRA_WAVE_TREND_FREE; public static MethodHandle WICKRA_WILLIAMS_FRACTALS_NEW; public static MethodHandle WICKRA_WILLIAMS_FRACTALS_UPDATE; + public static MethodHandle WICKRA_WILLIAMS_FRACTALS_WARMUP_PERIOD; + public static MethodHandle WICKRA_WILLIAMS_FRACTALS_IS_READY; public static MethodHandle WICKRA_WILLIAMS_FRACTALS_RESET; public static MethodHandle WICKRA_WILLIAMS_FRACTALS_FREE; public static MethodHandle WICKRA_WOODIE_PIVOTS_NEW; public static MethodHandle WICKRA_WOODIE_PIVOTS_UPDATE; + public static MethodHandle WICKRA_WOODIE_PIVOTS_WARMUP_PERIOD; + public static MethodHandle WICKRA_WOODIE_PIVOTS_IS_READY; public static MethodHandle WICKRA_WOODIE_PIVOTS_RESET; public static MethodHandle WICKRA_WOODIE_PIVOTS_FREE; public static MethodHandle WICKRA_ZERO_LAG_MACD_NEW; public static MethodHandle WICKRA_ZERO_LAG_MACD_UPDATE; + public static MethodHandle WICKRA_ZERO_LAG_MACD_WARMUP_PERIOD; + public static MethodHandle WICKRA_ZERO_LAG_MACD_IS_READY; public static MethodHandle WICKRA_ZERO_LAG_MACD_RESET; public static MethodHandle WICKRA_ZERO_LAG_MACD_FREE; public static MethodHandle WICKRA_ZIG_ZAG_NEW; public static MethodHandle WICKRA_ZIG_ZAG_UPDATE; + public static MethodHandle WICKRA_ZIG_ZAG_WARMUP_PERIOD; + public static MethodHandle WICKRA_ZIG_ZAG_IS_READY; public static MethodHandle WICKRA_ZIG_ZAG_RESET; public static MethodHandle WICKRA_ZIG_ZAG_FREE; public static MethodHandle WICKRA_DAY_OF_WEEK_PROFILE_NEW; public static MethodHandle WICKRA_DAY_OF_WEEK_PROFILE_UPDATE; + public static MethodHandle WICKRA_DAY_OF_WEEK_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_DAY_OF_WEEK_PROFILE_IS_READY; public static MethodHandle WICKRA_DAY_OF_WEEK_PROFILE_RESET; public static MethodHandle WICKRA_DAY_OF_WEEK_PROFILE_FREE; public static MethodHandle WICKRA_INTRADAY_VOLATILITY_PROFILE_NEW; public static MethodHandle WICKRA_INTRADAY_VOLATILITY_PROFILE_UPDATE; + public static MethodHandle WICKRA_INTRADAY_VOLATILITY_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_INTRADAY_VOLATILITY_PROFILE_IS_READY; public static MethodHandle WICKRA_INTRADAY_VOLATILITY_PROFILE_RESET; public static MethodHandle WICKRA_INTRADAY_VOLATILITY_PROFILE_FREE; public static MethodHandle WICKRA_TIME_OF_DAY_RETURN_PROFILE_NEW; public static MethodHandle WICKRA_TIME_OF_DAY_RETURN_PROFILE_UPDATE; + public static MethodHandle WICKRA_TIME_OF_DAY_RETURN_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TIME_OF_DAY_RETURN_PROFILE_IS_READY; public static MethodHandle WICKRA_TIME_OF_DAY_RETURN_PROFILE_RESET; public static MethodHandle WICKRA_TIME_OF_DAY_RETURN_PROFILE_FREE; public static MethodHandle WICKRA_TPO_PROFILE_NEW; public static MethodHandle WICKRA_TPO_PROFILE_UPDATE; + public static MethodHandle WICKRA_TPO_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_TPO_PROFILE_IS_READY; public static MethodHandle WICKRA_TPO_PROFILE_RESET; public static MethodHandle WICKRA_TPO_PROFILE_FREE; public static MethodHandle WICKRA_VOLUME_BY_TIME_PROFILE_NEW; public static MethodHandle WICKRA_VOLUME_BY_TIME_PROFILE_UPDATE; + public static MethodHandle WICKRA_VOLUME_BY_TIME_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_BY_TIME_PROFILE_IS_READY; public static MethodHandle WICKRA_VOLUME_BY_TIME_PROFILE_RESET; public static MethodHandle WICKRA_VOLUME_BY_TIME_PROFILE_FREE; public static MethodHandle WICKRA_VOLUME_PROFILE_NEW; public static MethodHandle WICKRA_VOLUME_PROFILE_UPDATE; + public static MethodHandle WICKRA_VOLUME_PROFILE_WARMUP_PERIOD; + public static MethodHandle WICKRA_VOLUME_PROFILE_IS_READY; public static MethodHandle WICKRA_VOLUME_PROFILE_RESET; public static MethodHandle WICKRA_VOLUME_PROFILE_FREE; public static MethodHandle WICKRA_DOLLAR_BARS_NEW; @@ -2419,10 +3423,14 @@ public final class NativeMethods { public static MethodHandle WICKRA_VOLUME_BARS_FREE; public static MethodHandle WICKRA_MACD_EXT_NEW; public static MethodHandle WICKRA_MACD_EXT_UPDATE; + public static MethodHandle WICKRA_MACD_EXT_WARMUP_PERIOD; + public static MethodHandle WICKRA_MACD_EXT_IS_READY; public static MethodHandle WICKRA_MACD_EXT_RESET; public static MethodHandle WICKRA_MACD_EXT_FREE; public static MethodHandle WICKRA_FOOTPRINT_NEW; public static MethodHandle WICKRA_FOOTPRINT_UPDATE; + public static MethodHandle WICKRA_FOOTPRINT_WARMUP_PERIOD; + public static MethodHandle WICKRA_FOOTPRINT_IS_READY; public static MethodHandle WICKRA_FOOTPRINT_RESET; public static MethodHandle WICKRA_FOOTPRINT_FREE; @@ -2448,2428 +3456,3467 @@ public final class NativeMethods { init18(); init19(); init20(); + init21(); + init22(); + init23(); + init24(); + init25(); + init26(); + init27(); + init28(); } private static void init0() { WICKRA_ADAPTIVE_CYCLE_NEW = h("wickra_adaptive_cycle_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ADAPTIVE_CYCLE_UPDATE = h("wickra_adaptive_cycle_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ADAPTIVE_CYCLE_BATCH = h("wickra_adaptive_cycle_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADAPTIVE_CYCLE_WARMUP_PERIOD = h("wickra_adaptive_cycle_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADAPTIVE_CYCLE_IS_READY = h("wickra_adaptive_cycle_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADAPTIVE_CYCLE_RESET = h("wickra_adaptive_cycle_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_CYCLE_FREE = h("wickra_adaptive_cycle_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_LAGUERRE_FILTER_NEW = h("wickra_adaptive_laguerre_filter_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ADAPTIVE_LAGUERRE_FILTER_UPDATE = h("wickra_adaptive_laguerre_filter_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ADAPTIVE_LAGUERRE_FILTER_BATCH = h("wickra_adaptive_laguerre_filter_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADAPTIVE_LAGUERRE_FILTER_WARMUP_PERIOD = h("wickra_adaptive_laguerre_filter_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADAPTIVE_LAGUERRE_FILTER_IS_READY = h("wickra_adaptive_laguerre_filter_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADAPTIVE_LAGUERRE_FILTER_RESET = h("wickra_adaptive_laguerre_filter_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_LAGUERRE_FILTER_FREE = h("wickra_adaptive_laguerre_filter_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_RSI_NEW = h("wickra_adaptive_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ADAPTIVE_RSI_UPDATE = h("wickra_adaptive_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ADAPTIVE_RSI_BATCH = h("wickra_adaptive_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADAPTIVE_RSI_WARMUP_PERIOD = h("wickra_adaptive_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADAPTIVE_RSI_IS_READY = h("wickra_adaptive_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADAPTIVE_RSI_RESET = h("wickra_adaptive_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_RSI_FREE = h("wickra_adaptive_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ALMA_NEW = h("wickra_alma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_ALMA_UPDATE = h("wickra_alma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ALMA_BATCH = h("wickra_alma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ALMA_WARMUP_PERIOD = h("wickra_alma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ALMA_IS_READY = h("wickra_alma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ALMA_RESET = h("wickra_alma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ALMA_FREE = h("wickra_alma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ANCHORED_RSI_NEW = h("wickra_anchored_rsi_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ANCHORED_RSI_UPDATE = h("wickra_anchored_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ANCHORED_RSI_BATCH = h("wickra_anchored_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ANCHORED_RSI_WARMUP_PERIOD = h("wickra_anchored_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ANCHORED_RSI_IS_READY = h("wickra_anchored_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ANCHORED_RSI_RESET = h("wickra_anchored_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ANCHORED_RSI_FREE = h("wickra_anchored_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_APO_NEW = h("wickra_apo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_APO_UPDATE = h("wickra_apo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_APO_BATCH = h("wickra_apo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_APO_WARMUP_PERIOD = h("wickra_apo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_APO_IS_READY = h("wickra_apo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_APO_RESET = h("wickra_apo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_APO_FREE = h("wickra_apo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AUTOCORRELATION_NEW = h("wickra_autocorrelation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_AUTOCORRELATION_UPDATE = h("wickra_autocorrelation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_AUTOCORRELATION_BATCH = h("wickra_autocorrelation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AUTOCORRELATION_WARMUP_PERIOD = h("wickra_autocorrelation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AUTOCORRELATION_IS_READY = h("wickra_autocorrelation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AUTOCORRELATION_RESET = h("wickra_autocorrelation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AUTOCORRELATION_FREE = h("wickra_autocorrelation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AUTOCORRELATION_PERIODOGRAM_NEW = h("wickra_autocorrelation_periodogram_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_AUTOCORRELATION_PERIODOGRAM_UPDATE = h("wickra_autocorrelation_periodogram_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_AUTOCORRELATION_PERIODOGRAM_BATCH = h("wickra_autocorrelation_periodogram_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AUTOCORRELATION_PERIODOGRAM_WARMUP_PERIOD = h("wickra_autocorrelation_periodogram_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AUTOCORRELATION_PERIODOGRAM_IS_READY = h("wickra_autocorrelation_periodogram_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AUTOCORRELATION_PERIODOGRAM_RESET = h("wickra_autocorrelation_periodogram_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AUTOCORRELATION_PERIODOGRAM_FREE = h("wickra_autocorrelation_periodogram_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AVERAGE_DRAWDOWN_NEW = h("wickra_average_drawdown_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_AVERAGE_DRAWDOWN_UPDATE = h("wickra_average_drawdown_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_AVERAGE_DRAWDOWN_BATCH = h("wickra_average_drawdown_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AVERAGE_DRAWDOWN_WARMUP_PERIOD = h("wickra_average_drawdown_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AVERAGE_DRAWDOWN_IS_READY = h("wickra_average_drawdown_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AVERAGE_DRAWDOWN_RESET = h("wickra_average_drawdown_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AVERAGE_DRAWDOWN_FREE = h("wickra_average_drawdown_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BANDPASS_FILTER_NEW = h("wickra_bandpass_filter_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_BANDPASS_FILTER_UPDATE = h("wickra_bandpass_filter_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_BANDPASS_FILTER_BATCH = h("wickra_bandpass_filter_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BANDPASS_FILTER_WARMUP_PERIOD = h("wickra_bandpass_filter_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BANDPASS_FILTER_IS_READY = h("wickra_bandpass_filter_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BANDPASS_FILTER_RESET = h("wickra_bandpass_filter_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BANDPASS_FILTER_FREE = h("wickra_bandpass_filter_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BIPOWER_VARIATION_NEW = h("wickra_bipower_variation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_BIPOWER_VARIATION_UPDATE = h("wickra_bipower_variation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_BIPOWER_VARIATION_BATCH = h("wickra_bipower_variation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BIPOWER_VARIATION_WARMUP_PERIOD = h("wickra_bipower_variation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BIPOWER_VARIATION_IS_READY = h("wickra_bipower_variation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BIPOWER_VARIATION_RESET = h("wickra_bipower_variation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BIPOWER_VARIATION_FREE = h("wickra_bipower_variation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BOLLINGER_BANDWIDTH_NEW = h("wickra_bollinger_bandwidth_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_BOLLINGER_BANDWIDTH_UPDATE = h("wickra_bollinger_bandwidth_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_BOLLINGER_BANDWIDTH_BATCH = h("wickra_bollinger_bandwidth_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BOLLINGER_BANDWIDTH_WARMUP_PERIOD = h("wickra_bollinger_bandwidth_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BOLLINGER_BANDWIDTH_IS_READY = h("wickra_bollinger_bandwidth_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BOLLINGER_BANDWIDTH_RESET = h("wickra_bollinger_bandwidth_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BOLLINGER_BANDWIDTH_FREE = h("wickra_bollinger_bandwidth_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BURKE_RATIO_NEW = h("wickra_burke_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_BURKE_RATIO_UPDATE = h("wickra_burke_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_BURKE_RATIO_BATCH = h("wickra_burke_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BURKE_RATIO_WARMUP_PERIOD = h("wickra_burke_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BURKE_RATIO_IS_READY = h("wickra_burke_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BURKE_RATIO_RESET = h("wickra_burke_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BURKE_RATIO_FREE = h("wickra_burke_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CALMAR_RATIO_NEW = h("wickra_calmar_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CALMAR_RATIO_UPDATE = h("wickra_calmar_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CALMAR_RATIO_BATCH = h("wickra_calmar_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CALMAR_RATIO_WARMUP_PERIOD = h("wickra_calmar_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CALMAR_RATIO_IS_READY = h("wickra_calmar_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CALMAR_RATIO_RESET = h("wickra_calmar_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CALMAR_RATIO_FREE = h("wickra_calmar_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CENTER_OF_GRAVITY_NEW = h("wickra_center_of_gravity_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CENTER_OF_GRAVITY_UPDATE = h("wickra_center_of_gravity_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CENTER_OF_GRAVITY_BATCH = h("wickra_center_of_gravity_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CENTER_OF_GRAVITY_WARMUP_PERIOD = h("wickra_center_of_gravity_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CENTER_OF_GRAVITY_IS_READY = h("wickra_center_of_gravity_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CENTER_OF_GRAVITY_RESET = h("wickra_center_of_gravity_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CENTER_OF_GRAVITY_FREE = h("wickra_center_of_gravity_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CFO_NEW = h("wickra_cfo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CFO_UPDATE = h("wickra_cfo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CFO_BATCH = h("wickra_cfo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CFO_WARMUP_PERIOD = h("wickra_cfo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CFO_IS_READY = h("wickra_cfo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CFO_RESET = h("wickra_cfo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CFO_FREE = h("wickra_cfo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CMO_NEW = h("wickra_cmo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CMO_UPDATE = h("wickra_cmo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CMO_BATCH = h("wickra_cmo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CMO_WARMUP_PERIOD = h("wickra_cmo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CMO_IS_READY = h("wickra_cmo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CMO_RESET = h("wickra_cmo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CMO_FREE = h("wickra_cmo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COEFFICIENT_OF_VARIATION_NEW = h("wickra_coefficient_of_variation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); + } + + private static void init1() { WICKRA_COEFFICIENT_OF_VARIATION_UPDATE = h("wickra_coefficient_of_variation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_COEFFICIENT_OF_VARIATION_BATCH = h("wickra_coefficient_of_variation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_COEFFICIENT_OF_VARIATION_WARMUP_PERIOD = h("wickra_coefficient_of_variation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_COEFFICIENT_OF_VARIATION_IS_READY = h("wickra_coefficient_of_variation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_COEFFICIENT_OF_VARIATION_RESET = h("wickra_coefficient_of_variation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COEFFICIENT_OF_VARIATION_FREE = h("wickra_coefficient_of_variation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COMMON_SENSE_RATIO_NEW = h("wickra_common_sense_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_COMMON_SENSE_RATIO_UPDATE = h("wickra_common_sense_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_COMMON_SENSE_RATIO_BATCH = h("wickra_common_sense_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_COMMON_SENSE_RATIO_WARMUP_PERIOD = h("wickra_common_sense_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_COMMON_SENSE_RATIO_IS_READY = h("wickra_common_sense_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_COMMON_SENSE_RATIO_RESET = h("wickra_common_sense_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COMMON_SENSE_RATIO_FREE = h("wickra_common_sense_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CONDITIONAL_VALUE_AT_RISK_NEW = h("wickra_conditional_value_at_risk_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_CONDITIONAL_VALUE_AT_RISK_UPDATE = h("wickra_conditional_value_at_risk_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CONDITIONAL_VALUE_AT_RISK_BATCH = h("wickra_conditional_value_at_risk_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CONDITIONAL_VALUE_AT_RISK_WARMUP_PERIOD = h("wickra_conditional_value_at_risk_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CONDITIONAL_VALUE_AT_RISK_IS_READY = h("wickra_conditional_value_at_risk_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CONDITIONAL_VALUE_AT_RISK_RESET = h("wickra_conditional_value_at_risk_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CONDITIONAL_VALUE_AT_RISK_FREE = h("wickra_conditional_value_at_risk_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CONNORS_RSI_NEW = h("wickra_connors_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_CONNORS_RSI_UPDATE = h("wickra_connors_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CONNORS_RSI_BATCH = h("wickra_connors_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CONNORS_RSI_WARMUP_PERIOD = h("wickra_connors_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CONNORS_RSI_IS_READY = h("wickra_connors_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CONNORS_RSI_RESET = h("wickra_connors_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CONNORS_RSI_FREE = h("wickra_connors_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COPPOCK_NEW = h("wickra_coppock_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_COPPOCK_UPDATE = h("wickra_coppock_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_COPPOCK_BATCH = h("wickra_coppock_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_COPPOCK_WARMUP_PERIOD = h("wickra_coppock_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_COPPOCK_IS_READY = h("wickra_coppock_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_COPPOCK_RESET = h("wickra_coppock_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COPPOCK_FREE = h("wickra_coppock_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CORRELATION_TREND_INDICATOR_NEW = h("wickra_correlation_trend_indicator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CORRELATION_TREND_INDICATOR_UPDATE = h("wickra_correlation_trend_indicator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CORRELATION_TREND_INDICATOR_BATCH = h("wickra_correlation_trend_indicator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CORRELATION_TREND_INDICATOR_WARMUP_PERIOD = h("wickra_correlation_trend_indicator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CORRELATION_TREND_INDICATOR_IS_READY = h("wickra_correlation_trend_indicator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CORRELATION_TREND_INDICATOR_RESET = h("wickra_correlation_trend_indicator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CORRELATION_TREND_INDICATOR_FREE = h("wickra_correlation_trend_indicator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CYBERNETIC_CYCLE_NEW = h("wickra_cybernetic_cycle_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CYBERNETIC_CYCLE_UPDATE = h("wickra_cybernetic_cycle_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_CYBERNETIC_CYCLE_BATCH = h("wickra_cybernetic_cycle_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CYBERNETIC_CYCLE_WARMUP_PERIOD = h("wickra_cybernetic_cycle_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CYBERNETIC_CYCLE_IS_READY = h("wickra_cybernetic_cycle_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CYBERNETIC_CYCLE_RESET = h("wickra_cybernetic_cycle_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CYBERNETIC_CYCLE_FREE = h("wickra_cybernetic_cycle_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init1() { WICKRA_DECYCLER_NEW = h("wickra_decycler_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DECYCLER_UPDATE = h("wickra_decycler_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DECYCLER_BATCH = h("wickra_decycler_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DECYCLER_WARMUP_PERIOD = h("wickra_decycler_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DECYCLER_IS_READY = h("wickra_decycler_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DECYCLER_RESET = h("wickra_decycler_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DECYCLER_FREE = h("wickra_decycler_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DECYCLER_OSCILLATOR_NEW = h("wickra_decycler_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_DECYCLER_OSCILLATOR_UPDATE = h("wickra_decycler_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DECYCLER_OSCILLATOR_BATCH = h("wickra_decycler_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DECYCLER_OSCILLATOR_WARMUP_PERIOD = h("wickra_decycler_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DECYCLER_OSCILLATOR_IS_READY = h("wickra_decycler_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DECYCLER_OSCILLATOR_RESET = h("wickra_decycler_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DECYCLER_OSCILLATOR_FREE = h("wickra_decycler_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEMA_NEW = h("wickra_dema_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DEMA_UPDATE = h("wickra_dema_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DEMA_BATCH = h("wickra_dema_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DEMA_WARMUP_PERIOD = h("wickra_dema_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DEMA_IS_READY = h("wickra_dema_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DEMA_RESET = h("wickra_dema_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEMA_FREE = h("wickra_dema_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DERIVATIVE_OSCILLATOR_NEW = h("wickra_derivative_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_DERIVATIVE_OSCILLATOR_UPDATE = h("wickra_derivative_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DERIVATIVE_OSCILLATOR_BATCH = h("wickra_derivative_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DERIVATIVE_OSCILLATOR_WARMUP_PERIOD = h("wickra_derivative_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DERIVATIVE_OSCILLATOR_IS_READY = h("wickra_derivative_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DERIVATIVE_OSCILLATOR_RESET = h("wickra_derivative_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DERIVATIVE_OSCILLATOR_FREE = h("wickra_derivative_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DETRENDED_STD_DEV_NEW = h("wickra_detrended_std_dev_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DETRENDED_STD_DEV_UPDATE = h("wickra_detrended_std_dev_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DETRENDED_STD_DEV_BATCH = h("wickra_detrended_std_dev_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DETRENDED_STD_DEV_WARMUP_PERIOD = h("wickra_detrended_std_dev_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DETRENDED_STD_DEV_IS_READY = h("wickra_detrended_std_dev_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DETRENDED_STD_DEV_RESET = h("wickra_detrended_std_dev_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DETRENDED_STD_DEV_FREE = h("wickra_detrended_std_dev_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DISPARITY_INDEX_NEW = h("wickra_disparity_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DISPARITY_INDEX_UPDATE = h("wickra_disparity_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DISPARITY_INDEX_BATCH = h("wickra_disparity_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DISPARITY_INDEX_WARMUP_PERIOD = h("wickra_disparity_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DISPARITY_INDEX_IS_READY = h("wickra_disparity_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DISPARITY_INDEX_RESET = h("wickra_disparity_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DISPARITY_INDEX_FREE = h("wickra_disparity_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DPO_NEW = h("wickra_dpo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DPO_UPDATE = h("wickra_dpo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DPO_BATCH = h("wickra_dpo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DPO_WARMUP_PERIOD = h("wickra_dpo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DPO_IS_READY = h("wickra_dpo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DPO_RESET = h("wickra_dpo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DPO_FREE = h("wickra_dpo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DRAWDOWN_DURATION_NEW = h("wickra_drawdown_duration_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DRAWDOWN_DURATION_UPDATE = h("wickra_drawdown_duration_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DRAWDOWN_DURATION_BATCH = h("wickra_drawdown_duration_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DRAWDOWN_DURATION_WARMUP_PERIOD = h("wickra_drawdown_duration_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DRAWDOWN_DURATION_IS_READY = h("wickra_drawdown_duration_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DRAWDOWN_DURATION_RESET = h("wickra_drawdown_duration_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DRAWDOWN_DURATION_FREE = h("wickra_drawdown_duration_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DYNAMIC_MOMENTUM_INDEX_NEW = h("wickra_dynamic_momentum_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DYNAMIC_MOMENTUM_INDEX_UPDATE = h("wickra_dynamic_momentum_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_DYNAMIC_MOMENTUM_INDEX_BATCH = h("wickra_dynamic_momentum_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DYNAMIC_MOMENTUM_INDEX_WARMUP_PERIOD = h("wickra_dynamic_momentum_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DYNAMIC_MOMENTUM_INDEX_IS_READY = h("wickra_dynamic_momentum_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DYNAMIC_MOMENTUM_INDEX_RESET = h("wickra_dynamic_momentum_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DYNAMIC_MOMENTUM_INDEX_FREE = h("wickra_dynamic_momentum_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EHLERS_STOCHASTIC_NEW = h("wickra_ehlers_stochastic_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EHLERS_STOCHASTIC_UPDATE = h("wickra_ehlers_stochastic_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_EHLERS_STOCHASTIC_BATCH = h("wickra_ehlers_stochastic_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EHLERS_STOCHASTIC_WARMUP_PERIOD = h("wickra_ehlers_stochastic_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EHLERS_STOCHASTIC_IS_READY = h("wickra_ehlers_stochastic_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EHLERS_STOCHASTIC_RESET = h("wickra_ehlers_stochastic_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EHLERS_STOCHASTIC_FREE = h("wickra_ehlers_stochastic_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EHMA_NEW = h("wickra_ehma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EHMA_UPDATE = h("wickra_ehma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); + } + + private static void init2() { WICKRA_EHMA_BATCH = h("wickra_ehma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EHMA_WARMUP_PERIOD = h("wickra_ehma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EHMA_IS_READY = h("wickra_ehma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EHMA_RESET = h("wickra_ehma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EHMA_FREE = h("wickra_ehma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ELDER_IMPULSE_NEW = h("wickra_elder_impulse_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_ELDER_IMPULSE_UPDATE = h("wickra_elder_impulse_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ELDER_IMPULSE_BATCH = h("wickra_elder_impulse_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ELDER_IMPULSE_WARMUP_PERIOD = h("wickra_elder_impulse_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ELDER_IMPULSE_IS_READY = h("wickra_elder_impulse_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ELDER_IMPULSE_RESET = h("wickra_elder_impulse_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ELDER_IMPULSE_FREE = h("wickra_elder_impulse_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EMA_NEW = h("wickra_ema_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EMA_UPDATE = h("wickra_ema_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_EMA_BATCH = h("wickra_ema_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EMA_WARMUP_PERIOD = h("wickra_ema_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EMA_IS_READY = h("wickra_ema_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EMA_RESET = h("wickra_ema_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EMA_FREE = h("wickra_ema_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EMPIRICAL_MODE_DECOMPOSITION_NEW = h("wickra_empirical_mode_decomposition_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_EMPIRICAL_MODE_DECOMPOSITION_UPDATE = h("wickra_empirical_mode_decomposition_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_EMPIRICAL_MODE_DECOMPOSITION_BATCH = h("wickra_empirical_mode_decomposition_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EMPIRICAL_MODE_DECOMPOSITION_WARMUP_PERIOD = h("wickra_empirical_mode_decomposition_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EMPIRICAL_MODE_DECOMPOSITION_IS_READY = h("wickra_empirical_mode_decomposition_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EMPIRICAL_MODE_DECOMPOSITION_RESET = h("wickra_empirical_mode_decomposition_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EMPIRICAL_MODE_DECOMPOSITION_FREE = h("wickra_empirical_mode_decomposition_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EVEN_BETTER_SINEWAVE_NEW = h("wickra_even_better_sinewave_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_EVEN_BETTER_SINEWAVE_UPDATE = h("wickra_even_better_sinewave_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_EVEN_BETTER_SINEWAVE_BATCH = h("wickra_even_better_sinewave_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EVEN_BETTER_SINEWAVE_WARMUP_PERIOD = h("wickra_even_better_sinewave_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EVEN_BETTER_SINEWAVE_IS_READY = h("wickra_even_better_sinewave_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EVEN_BETTER_SINEWAVE_RESET = h("wickra_even_better_sinewave_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EVEN_BETTER_SINEWAVE_FREE = h("wickra_even_better_sinewave_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EWMA_VOLATILITY_NEW = h("wickra_ewma_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_EWMA_VOLATILITY_UPDATE = h("wickra_ewma_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_EWMA_VOLATILITY_BATCH = h("wickra_ewma_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EWMA_VOLATILITY_WARMUP_PERIOD = h("wickra_ewma_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EWMA_VOLATILITY_IS_READY = h("wickra_ewma_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EWMA_VOLATILITY_RESET = h("wickra_ewma_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EWMA_VOLATILITY_FREE = h("wickra_ewma_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EXPECTANCY_NEW = h("wickra_expectancy_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EXPECTANCY_UPDATE = h("wickra_expectancy_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_EXPECTANCY_BATCH = h("wickra_expectancy_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EXPECTANCY_WARMUP_PERIOD = h("wickra_expectancy_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EXPECTANCY_IS_READY = h("wickra_expectancy_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EXPECTANCY_RESET = h("wickra_expectancy_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EXPECTANCY_FREE = h("wickra_expectancy_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FAMA_NEW = h("wickra_fama_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_FAMA_UPDATE = h("wickra_fama_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_FAMA_BATCH = h("wickra_fama_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FAMA_WARMUP_PERIOD = h("wickra_fama_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FAMA_IS_READY = h("wickra_fama_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FAMA_RESET = h("wickra_fama_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FAMA_FREE = h("wickra_fama_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FISHER_RSI_NEW = h("wickra_fisher_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FISHER_RSI_UPDATE = h("wickra_fisher_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_FISHER_RSI_BATCH = h("wickra_fisher_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FISHER_RSI_WARMUP_PERIOD = h("wickra_fisher_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FISHER_RSI_IS_READY = h("wickra_fisher_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FISHER_RSI_RESET = h("wickra_fisher_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FISHER_RSI_FREE = h("wickra_fisher_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FISHER_TRANSFORM_NEW = h("wickra_fisher_transform_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FISHER_TRANSFORM_UPDATE = h("wickra_fisher_transform_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_FISHER_TRANSFORM_BATCH = h("wickra_fisher_transform_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FISHER_TRANSFORM_WARMUP_PERIOD = h("wickra_fisher_transform_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FISHER_TRANSFORM_IS_READY = h("wickra_fisher_transform_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FISHER_TRANSFORM_RESET = h("wickra_fisher_transform_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FISHER_TRANSFORM_FREE = h("wickra_fisher_transform_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FRAMA_NEW = h("wickra_frama_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FRAMA_UPDATE = h("wickra_frama_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_FRAMA_BATCH = h("wickra_frama_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FRAMA_WARMUP_PERIOD = h("wickra_frama_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FRAMA_IS_READY = h("wickra_frama_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FRAMA_RESET = h("wickra_frama_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FRAMA_FREE = h("wickra_frama_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GAIN_LOSS_RATIO_NEW = h("wickra_gain_loss_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_GAIN_LOSS_RATIO_UPDATE = h("wickra_gain_loss_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_GAIN_LOSS_RATIO_BATCH = h("wickra_gain_loss_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GAIN_LOSS_RATIO_WARMUP_PERIOD = h("wickra_gain_loss_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GAIN_LOSS_RATIO_IS_READY = h("wickra_gain_loss_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GAIN_LOSS_RATIO_RESET = h("wickra_gain_loss_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GAIN_LOSS_RATIO_FREE = h("wickra_gain_loss_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GAIN_TO_PAIN_RATIO_NEW = h("wickra_gain_to_pain_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_GAIN_TO_PAIN_RATIO_UPDATE = h("wickra_gain_to_pain_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_GAIN_TO_PAIN_RATIO_BATCH = h("wickra_gain_to_pain_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GAIN_TO_PAIN_RATIO_WARMUP_PERIOD = h("wickra_gain_to_pain_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GAIN_TO_PAIN_RATIO_IS_READY = h("wickra_gain_to_pain_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GAIN_TO_PAIN_RATIO_RESET = h("wickra_gain_to_pain_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GAIN_TO_PAIN_RATIO_FREE = h("wickra_gain_to_pain_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GARCH11_NEW = h("wickra_garch11_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_GARCH11_UPDATE = h("wickra_garch11_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_GARCH11_BATCH = h("wickra_garch11_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GARCH11_WARMUP_PERIOD = h("wickra_garch11_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GARCH11_IS_READY = h("wickra_garch11_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GARCH11_RESET = h("wickra_garch11_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GARCH11_FREE = h("wickra_garch11_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init2() { WICKRA_GENERALIZED_DEMA_NEW = h("wickra_generalized_dema_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_GENERALIZED_DEMA_UPDATE = h("wickra_generalized_dema_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_GENERALIZED_DEMA_BATCH = h("wickra_generalized_dema_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GENERALIZED_DEMA_WARMUP_PERIOD = h("wickra_generalized_dema_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GENERALIZED_DEMA_IS_READY = h("wickra_generalized_dema_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GENERALIZED_DEMA_RESET = h("wickra_generalized_dema_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GENERALIZED_DEMA_FREE = h("wickra_generalized_dema_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GEOMETRIC_MA_NEW = h("wickra_geometric_ma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_GEOMETRIC_MA_UPDATE = h("wickra_geometric_ma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_GEOMETRIC_MA_BATCH = h("wickra_geometric_ma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GEOMETRIC_MA_WARMUP_PERIOD = h("wickra_geometric_ma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GEOMETRIC_MA_IS_READY = h("wickra_geometric_ma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GEOMETRIC_MA_RESET = h("wickra_geometric_ma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GEOMETRIC_MA_FREE = h("wickra_geometric_ma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGHPASS_FILTER_NEW = h("wickra_highpass_filter_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_HIGHPASS_FILTER_UPDATE = h("wickra_highpass_filter_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HIGHPASS_FILTER_BATCH = h("wickra_highpass_filter_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HIGHPASS_FILTER_WARMUP_PERIOD = h("wickra_highpass_filter_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIGHPASS_FILTER_IS_READY = h("wickra_highpass_filter_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIGHPASS_FILTER_RESET = h("wickra_highpass_filter_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGHPASS_FILTER_FREE = h("wickra_highpass_filter_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HILBERT_DOMINANT_CYCLE_NEW = h("wickra_hilbert_dominant_cycle_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HILBERT_DOMINANT_CYCLE_UPDATE = h("wickra_hilbert_dominant_cycle_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HILBERT_DOMINANT_CYCLE_BATCH = h("wickra_hilbert_dominant_cycle_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + } + + private static void init3() { + WICKRA_HILBERT_DOMINANT_CYCLE_WARMUP_PERIOD = h("wickra_hilbert_dominant_cycle_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HILBERT_DOMINANT_CYCLE_IS_READY = h("wickra_hilbert_dominant_cycle_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HILBERT_DOMINANT_CYCLE_RESET = h("wickra_hilbert_dominant_cycle_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HILBERT_DOMINANT_CYCLE_FREE = h("wickra_hilbert_dominant_cycle_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HISTORICAL_VOLATILITY_NEW = h("wickra_historical_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_HISTORICAL_VOLATILITY_UPDATE = h("wickra_historical_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HISTORICAL_VOLATILITY_BATCH = h("wickra_historical_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HISTORICAL_VOLATILITY_WARMUP_PERIOD = h("wickra_historical_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HISTORICAL_VOLATILITY_IS_READY = h("wickra_historical_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HISTORICAL_VOLATILITY_RESET = h("wickra_historical_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HISTORICAL_VOLATILITY_FREE = h("wickra_historical_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HMA_NEW = h("wickra_hma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_HMA_UPDATE = h("wickra_hma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HMA_BATCH = h("wickra_hma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HMA_WARMUP_PERIOD = h("wickra_hma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HMA_IS_READY = h("wickra_hma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HMA_RESET = h("wickra_hma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HMA_FREE = h("wickra_hma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HOLT_WINTERS_NEW = h("wickra_holt_winters_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_HOLT_WINTERS_UPDATE = h("wickra_holt_winters_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HOLT_WINTERS_BATCH = h("wickra_holt_winters_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HOLT_WINTERS_WARMUP_PERIOD = h("wickra_holt_winters_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HOLT_WINTERS_IS_READY = h("wickra_holt_winters_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HOLT_WINTERS_RESET = h("wickra_holt_winters_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HOLT_WINTERS_FREE = h("wickra_holt_winters_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HT_DC_PHASE_NEW = h("wickra_ht_dc_phase_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HT_DC_PHASE_UPDATE = h("wickra_ht_dc_phase_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HT_DC_PHASE_BATCH = h("wickra_ht_dc_phase_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HT_DC_PHASE_WARMUP_PERIOD = h("wickra_ht_dc_phase_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HT_DC_PHASE_IS_READY = h("wickra_ht_dc_phase_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HT_DC_PHASE_RESET = h("wickra_ht_dc_phase_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HT_DC_PHASE_FREE = h("wickra_ht_dc_phase_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HT_TREND_MODE_NEW = h("wickra_ht_trend_mode_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HT_TREND_MODE_UPDATE = h("wickra_ht_trend_mode_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HT_TREND_MODE_BATCH = h("wickra_ht_trend_mode_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HT_TREND_MODE_WARMUP_PERIOD = h("wickra_ht_trend_mode_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HT_TREND_MODE_IS_READY = h("wickra_ht_trend_mode_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HT_TREND_MODE_RESET = h("wickra_ht_trend_mode_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HT_TREND_MODE_FREE = h("wickra_ht_trend_mode_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HURST_EXPONENT_NEW = h("wickra_hurst_exponent_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_HURST_EXPONENT_UPDATE = h("wickra_hurst_exponent_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_HURST_EXPONENT_BATCH = h("wickra_hurst_exponent_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HURST_EXPONENT_WARMUP_PERIOD = h("wickra_hurst_exponent_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HURST_EXPONENT_IS_READY = h("wickra_hurst_exponent_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HURST_EXPONENT_RESET = h("wickra_hurst_exponent_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HURST_EXPONENT_FREE = h("wickra_hurst_exponent_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INSTANTANEOUS_TRENDLINE_NEW = h("wickra_instantaneous_trendline_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_INSTANTANEOUS_TRENDLINE_UPDATE = h("wickra_instantaneous_trendline_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_INSTANTANEOUS_TRENDLINE_BATCH = h("wickra_instantaneous_trendline_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INSTANTANEOUS_TRENDLINE_WARMUP_PERIOD = h("wickra_instantaneous_trendline_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INSTANTANEOUS_TRENDLINE_IS_READY = h("wickra_instantaneous_trendline_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INSTANTANEOUS_TRENDLINE_RESET = h("wickra_instantaneous_trendline_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INSTANTANEOUS_TRENDLINE_FREE = h("wickra_instantaneous_trendline_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INVERSE_FISHER_TRANSFORM_NEW = h("wickra_inverse_fisher_transform_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_INVERSE_FISHER_TRANSFORM_UPDATE = h("wickra_inverse_fisher_transform_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_INVERSE_FISHER_TRANSFORM_BATCH = h("wickra_inverse_fisher_transform_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INVERSE_FISHER_TRANSFORM_WARMUP_PERIOD = h("wickra_inverse_fisher_transform_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INVERSE_FISHER_TRANSFORM_IS_READY = h("wickra_inverse_fisher_transform_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INVERSE_FISHER_TRANSFORM_RESET = h("wickra_inverse_fisher_transform_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INVERSE_FISHER_TRANSFORM_FREE = h("wickra_inverse_fisher_transform_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_JARQUE_BERA_NEW = h("wickra_jarque_bera_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_JARQUE_BERA_UPDATE = h("wickra_jarque_bera_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_JARQUE_BERA_BATCH = h("wickra_jarque_bera_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_JARQUE_BERA_WARMUP_PERIOD = h("wickra_jarque_bera_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_JARQUE_BERA_IS_READY = h("wickra_jarque_bera_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_JARQUE_BERA_RESET = h("wickra_jarque_bera_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_JARQUE_BERA_FREE = h("wickra_jarque_bera_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_JMA_NEW = h("wickra_jma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_INT)); WICKRA_JMA_UPDATE = h("wickra_jma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_JMA_BATCH = h("wickra_jma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_JMA_WARMUP_PERIOD = h("wickra_jma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_JMA_IS_READY = h("wickra_jma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_JMA_RESET = h("wickra_jma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_JMA_FREE = h("wickra_jma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_JUMP_INDICATOR_NEW = h("wickra_jump_indicator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_JUMP_INDICATOR_UPDATE = h("wickra_jump_indicator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_JUMP_INDICATOR_BATCH = h("wickra_jump_indicator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_JUMP_INDICATOR_WARMUP_PERIOD = h("wickra_jump_indicator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_JUMP_INDICATOR_IS_READY = h("wickra_jump_indicator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_JUMP_INDICATOR_RESET = h("wickra_jump_indicator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_JUMP_INDICATOR_FREE = h("wickra_jump_indicator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_K_RATIO_NEW = h("wickra_k_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_K_RATIO_UPDATE = h("wickra_k_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_K_RATIO_BATCH = h("wickra_k_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_K_RATIO_WARMUP_PERIOD = h("wickra_k_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_K_RATIO_IS_READY = h("wickra_k_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_K_RATIO_RESET = h("wickra_k_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_K_RATIO_FREE = h("wickra_k_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KAMA_NEW = h("wickra_kama_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_KAMA_UPDATE = h("wickra_kama_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_KAMA_BATCH = h("wickra_kama_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KAMA_WARMUP_PERIOD = h("wickra_kama_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KAMA_IS_READY = h("wickra_kama_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KAMA_RESET = h("wickra_kama_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KAMA_FREE = h("wickra_kama_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KELLY_CRITERION_NEW = h("wickra_kelly_criterion_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_KELLY_CRITERION_UPDATE = h("wickra_kelly_criterion_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_KELLY_CRITERION_BATCH = h("wickra_kelly_criterion_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KELLY_CRITERION_WARMUP_PERIOD = h("wickra_kelly_criterion_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KELLY_CRITERION_IS_READY = h("wickra_kelly_criterion_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KELLY_CRITERION_RESET = h("wickra_kelly_criterion_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KELLY_CRITERION_FREE = h("wickra_kelly_criterion_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KURTOSIS_NEW = h("wickra_kurtosis_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_KURTOSIS_UPDATE = h("wickra_kurtosis_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_KURTOSIS_BATCH = h("wickra_kurtosis_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KURTOSIS_WARMUP_PERIOD = h("wickra_kurtosis_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KURTOSIS_IS_READY = h("wickra_kurtosis_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KURTOSIS_RESET = h("wickra_kurtosis_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KURTOSIS_FREE = h("wickra_kurtosis_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LAGUERRE_RSI_NEW = h("wickra_laguerre_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_LAGUERRE_RSI_UPDATE = h("wickra_laguerre_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_LAGUERRE_RSI_BATCH = h("wickra_laguerre_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LAGUERRE_RSI_WARMUP_PERIOD = h("wickra_laguerre_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LAGUERRE_RSI_IS_READY = h("wickra_laguerre_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LAGUERRE_RSI_RESET = h("wickra_laguerre_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LAGUERRE_RSI_FREE = h("wickra_laguerre_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LINEAR_REGRESSION_NEW = h("wickra_linear_regression_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_LINEAR_REGRESSION_UPDATE = h("wickra_linear_regression_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_LINEAR_REGRESSION_BATCH = h("wickra_linear_regression_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LINEAR_REGRESSION_WARMUP_PERIOD = h("wickra_linear_regression_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + } + + private static void init4() { + WICKRA_LINEAR_REGRESSION_IS_READY = h("wickra_linear_regression_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LINEAR_REGRESSION_RESET = h("wickra_linear_regression_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LINEAR_REGRESSION_FREE = h("wickra_linear_regression_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_ANGLE_NEW = h("wickra_lin_reg_angle_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_LIN_REG_ANGLE_UPDATE = h("wickra_lin_reg_angle_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_LIN_REG_ANGLE_BATCH = h("wickra_lin_reg_angle_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LIN_REG_ANGLE_WARMUP_PERIOD = h("wickra_lin_reg_angle_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LIN_REG_ANGLE_IS_READY = h("wickra_lin_reg_angle_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LIN_REG_ANGLE_RESET = h("wickra_lin_reg_angle_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_ANGLE_FREE = h("wickra_lin_reg_angle_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_INTERCEPT_NEW = h("wickra_lin_reg_intercept_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_LIN_REG_INTERCEPT_UPDATE = h("wickra_lin_reg_intercept_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_LIN_REG_INTERCEPT_BATCH = h("wickra_lin_reg_intercept_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LIN_REG_INTERCEPT_WARMUP_PERIOD = h("wickra_lin_reg_intercept_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LIN_REG_INTERCEPT_IS_READY = h("wickra_lin_reg_intercept_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LIN_REG_INTERCEPT_RESET = h("wickra_lin_reg_intercept_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_INTERCEPT_FREE = h("wickra_lin_reg_intercept_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_SLOPE_NEW = h("wickra_lin_reg_slope_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_LIN_REG_SLOPE_UPDATE = h("wickra_lin_reg_slope_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_LIN_REG_SLOPE_BATCH = h("wickra_lin_reg_slope_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LIN_REG_SLOPE_WARMUP_PERIOD = h("wickra_lin_reg_slope_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LIN_REG_SLOPE_IS_READY = h("wickra_lin_reg_slope_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LIN_REG_SLOPE_RESET = h("wickra_lin_reg_slope_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_SLOPE_FREE = h("wickra_lin_reg_slope_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init3() { WICKRA_LOG_RETURN_NEW = h("wickra_log_return_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_LOG_RETURN_UPDATE = h("wickra_log_return_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_LOG_RETURN_BATCH = h("wickra_log_return_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LOG_RETURN_WARMUP_PERIOD = h("wickra_log_return_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LOG_RETURN_IS_READY = h("wickra_log_return_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LOG_RETURN_RESET = h("wickra_log_return_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LOG_RETURN_FREE = h("wickra_log_return_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_M2_MEASURE_NEW = h("wickra_m2_measure_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_M2_MEASURE_UPDATE = h("wickra_m2_measure_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_M2_MEASURE_BATCH = h("wickra_m2_measure_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_M2_MEASURE_WARMUP_PERIOD = h("wickra_m2_measure_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_M2_MEASURE_IS_READY = h("wickra_m2_measure_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_M2_MEASURE_RESET = h("wickra_m2_measure_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_M2_MEASURE_FREE = h("wickra_m2_measure_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_HISTOGRAM_NEW = h("wickra_macd_histogram_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_MACD_HISTOGRAM_UPDATE = h("wickra_macd_histogram_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MACD_HISTOGRAM_BATCH = h("wickra_macd_histogram_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MACD_HISTOGRAM_WARMUP_PERIOD = h("wickra_macd_histogram_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MACD_HISTOGRAM_IS_READY = h("wickra_macd_histogram_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MACD_HISTOGRAM_RESET = h("wickra_macd_histogram_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_HISTOGRAM_FREE = h("wickra_macd_histogram_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MARTIN_RATIO_NEW = h("wickra_martin_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MARTIN_RATIO_UPDATE = h("wickra_martin_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MARTIN_RATIO_BATCH = h("wickra_martin_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MARTIN_RATIO_WARMUP_PERIOD = h("wickra_martin_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MARTIN_RATIO_IS_READY = h("wickra_martin_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MARTIN_RATIO_RESET = h("wickra_martin_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MARTIN_RATIO_FREE = h("wickra_martin_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MAX_DRAWDOWN_NEW = h("wickra_max_drawdown_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MAX_DRAWDOWN_UPDATE = h("wickra_max_drawdown_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MAX_DRAWDOWN_BATCH = h("wickra_max_drawdown_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MAX_DRAWDOWN_WARMUP_PERIOD = h("wickra_max_drawdown_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MAX_DRAWDOWN_IS_READY = h("wickra_max_drawdown_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MAX_DRAWDOWN_RESET = h("wickra_max_drawdown_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MAX_DRAWDOWN_FREE = h("wickra_max_drawdown_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MC_GINLEY_DYNAMIC_NEW = h("wickra_mc_ginley_dynamic_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MC_GINLEY_DYNAMIC_UPDATE = h("wickra_mc_ginley_dynamic_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MC_GINLEY_DYNAMIC_BATCH = h("wickra_mc_ginley_dynamic_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MC_GINLEY_DYNAMIC_WARMUP_PERIOD = h("wickra_mc_ginley_dynamic_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MC_GINLEY_DYNAMIC_IS_READY = h("wickra_mc_ginley_dynamic_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MC_GINLEY_DYNAMIC_RESET = h("wickra_mc_ginley_dynamic_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MC_GINLEY_DYNAMIC_FREE = h("wickra_mc_ginley_dynamic_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_ABSOLUTE_DEVIATION_NEW = h("wickra_median_absolute_deviation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MEDIAN_ABSOLUTE_DEVIATION_UPDATE = h("wickra_median_absolute_deviation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MEDIAN_ABSOLUTE_DEVIATION_BATCH = h("wickra_median_absolute_deviation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MEDIAN_ABSOLUTE_DEVIATION_WARMUP_PERIOD = h("wickra_median_absolute_deviation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MEDIAN_ABSOLUTE_DEVIATION_IS_READY = h("wickra_median_absolute_deviation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MEDIAN_ABSOLUTE_DEVIATION_RESET = h("wickra_median_absolute_deviation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_ABSOLUTE_DEVIATION_FREE = h("wickra_median_absolute_deviation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_MA_NEW = h("wickra_median_ma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MEDIAN_MA_UPDATE = h("wickra_median_ma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MEDIAN_MA_BATCH = h("wickra_median_ma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MEDIAN_MA_WARMUP_PERIOD = h("wickra_median_ma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MEDIAN_MA_IS_READY = h("wickra_median_ma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MEDIAN_MA_RESET = h("wickra_median_ma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_MA_FREE = h("wickra_median_ma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MID_POINT_NEW = h("wickra_mid_point_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MID_POINT_UPDATE = h("wickra_mid_point_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MID_POINT_BATCH = h("wickra_mid_point_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MID_POINT_WARMUP_PERIOD = h("wickra_mid_point_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MID_POINT_IS_READY = h("wickra_mid_point_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MID_POINT_RESET = h("wickra_mid_point_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MID_POINT_FREE = h("wickra_mid_point_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MOM_NEW = h("wickra_mom_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MOM_UPDATE = h("wickra_mom_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_MOM_BATCH = h("wickra_mom_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MOM_WARMUP_PERIOD = h("wickra_mom_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MOM_IS_READY = h("wickra_mom_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MOM_RESET = h("wickra_mom_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MOM_FREE = h("wickra_mom_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OMEGA_RATIO_NEW = h("wickra_omega_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_OMEGA_RATIO_UPDATE = h("wickra_omega_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_OMEGA_RATIO_BATCH = h("wickra_omega_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_OMEGA_RATIO_WARMUP_PERIOD = h("wickra_omega_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OMEGA_RATIO_IS_READY = h("wickra_omega_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OMEGA_RATIO_RESET = h("wickra_omega_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OMEGA_RATIO_FREE = h("wickra_omega_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PAIN_INDEX_NEW = h("wickra_pain_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PAIN_INDEX_UPDATE = h("wickra_pain_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PAIN_INDEX_BATCH = h("wickra_pain_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PAIN_INDEX_WARMUP_PERIOD = h("wickra_pain_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PAIN_INDEX_IS_READY = h("wickra_pain_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PAIN_INDEX_RESET = h("wickra_pain_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PAIN_INDEX_FREE = h("wickra_pain_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERCENT_B_NEW = h("wickra_percent_b_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_PERCENT_B_UPDATE = h("wickra_percent_b_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PERCENT_B_BATCH = h("wickra_percent_b_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PERCENT_B_WARMUP_PERIOD = h("wickra_percent_b_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PERCENT_B_IS_READY = h("wickra_percent_b_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PERCENT_B_RESET = h("wickra_percent_b_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERCENT_B_FREE = h("wickra_percent_b_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERCENTAGE_TRAILING_STOP_NEW = h("wickra_percentage_trailing_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_PERCENTAGE_TRAILING_STOP_UPDATE = h("wickra_percentage_trailing_stop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PERCENTAGE_TRAILING_STOP_BATCH = h("wickra_percentage_trailing_stop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PERCENTAGE_TRAILING_STOP_WARMUP_PERIOD = h("wickra_percentage_trailing_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PERCENTAGE_TRAILING_STOP_IS_READY = h("wickra_percentage_trailing_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init5() { WICKRA_PERCENTAGE_TRAILING_STOP_RESET = h("wickra_percentage_trailing_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERCENTAGE_TRAILING_STOP_FREE = h("wickra_percentage_trailing_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PMO_NEW = h("wickra_pmo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_PMO_UPDATE = h("wickra_pmo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PMO_BATCH = h("wickra_pmo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PMO_WARMUP_PERIOD = h("wickra_pmo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PMO_IS_READY = h("wickra_pmo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PMO_RESET = h("wickra_pmo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PMO_FREE = h("wickra_pmo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_POLARIZED_FRACTAL_EFFICIENCY_NEW = h("wickra_polarized_fractal_efficiency_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_POLARIZED_FRACTAL_EFFICIENCY_UPDATE = h("wickra_polarized_fractal_efficiency_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_POLARIZED_FRACTAL_EFFICIENCY_BATCH = h("wickra_polarized_fractal_efficiency_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_POLARIZED_FRACTAL_EFFICIENCY_WARMUP_PERIOD = h("wickra_polarized_fractal_efficiency_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_POLARIZED_FRACTAL_EFFICIENCY_IS_READY = h("wickra_polarized_fractal_efficiency_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_POLARIZED_FRACTAL_EFFICIENCY_RESET = h("wickra_polarized_fractal_efficiency_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_POLARIZED_FRACTAL_EFFICIENCY_FREE = h("wickra_polarized_fractal_efficiency_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PPO_NEW = h("wickra_ppo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_PPO_UPDATE = h("wickra_ppo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PPO_BATCH = h("wickra_ppo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PPO_WARMUP_PERIOD = h("wickra_ppo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PPO_IS_READY = h("wickra_ppo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PPO_RESET = h("wickra_ppo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PPO_FREE = h("wickra_ppo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PPO_HISTOGRAM_NEW = h("wickra_ppo_histogram_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_PPO_HISTOGRAM_UPDATE = h("wickra_ppo_histogram_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PPO_HISTOGRAM_BATCH = h("wickra_ppo_histogram_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PPO_HISTOGRAM_WARMUP_PERIOD = h("wickra_ppo_histogram_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PPO_HISTOGRAM_IS_READY = h("wickra_ppo_histogram_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PPO_HISTOGRAM_RESET = h("wickra_ppo_histogram_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PPO_HISTOGRAM_FREE = h("wickra_ppo_histogram_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROFIT_FACTOR_NEW = h("wickra_profit_factor_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PROFIT_FACTOR_UPDATE = h("wickra_profit_factor_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_PROFIT_FACTOR_BATCH = h("wickra_profit_factor_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PROFIT_FACTOR_WARMUP_PERIOD = h("wickra_profit_factor_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PROFIT_FACTOR_IS_READY = h("wickra_profit_factor_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PROFIT_FACTOR_RESET = h("wickra_profit_factor_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROFIT_FACTOR_FREE = h("wickra_profit_factor_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_R_SQUARED_NEW = h("wickra_r_squared_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_R_SQUARED_UPDATE = h("wickra_r_squared_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_R_SQUARED_BATCH = h("wickra_r_squared_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_R_SQUARED_WARMUP_PERIOD = h("wickra_r_squared_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_R_SQUARED_IS_READY = h("wickra_r_squared_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_R_SQUARED_RESET = h("wickra_r_squared_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_R_SQUARED_FREE = h("wickra_r_squared_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REALIZED_VOLATILITY_NEW = h("wickra_realized_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_REALIZED_VOLATILITY_UPDATE = h("wickra_realized_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_REALIZED_VOLATILITY_BATCH = h("wickra_realized_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_REALIZED_VOLATILITY_WARMUP_PERIOD = h("wickra_realized_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_REALIZED_VOLATILITY_IS_READY = h("wickra_realized_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_REALIZED_VOLATILITY_RESET = h("wickra_realized_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REALIZED_VOLATILITY_FREE = h("wickra_realized_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RECOVERY_FACTOR_NEW = h("wickra_recovery_factor_new", FunctionDescriptor.of(ADDRESS)); WICKRA_RECOVERY_FACTOR_UPDATE = h("wickra_recovery_factor_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_RECOVERY_FACTOR_BATCH = h("wickra_recovery_factor_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RECOVERY_FACTOR_WARMUP_PERIOD = h("wickra_recovery_factor_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RECOVERY_FACTOR_IS_READY = h("wickra_recovery_factor_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RECOVERY_FACTOR_RESET = h("wickra_recovery_factor_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RECOVERY_FACTOR_FREE = h("wickra_recovery_factor_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REFLEX_NEW = h("wickra_reflex_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_REFLEX_UPDATE = h("wickra_reflex_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_REFLEX_BATCH = h("wickra_reflex_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_REFLEX_WARMUP_PERIOD = h("wickra_reflex_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_REFLEX_IS_READY = h("wickra_reflex_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_REFLEX_RESET = h("wickra_reflex_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REFLEX_FREE = h("wickra_reflex_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REGIME_LABEL_NEW = h("wickra_regime_label_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_REGIME_LABEL_UPDATE = h("wickra_regime_label_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_REGIME_LABEL_BATCH = h("wickra_regime_label_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_REGIME_LABEL_WARMUP_PERIOD = h("wickra_regime_label_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_REGIME_LABEL_IS_READY = h("wickra_regime_label_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_REGIME_LABEL_RESET = h("wickra_regime_label_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REGIME_LABEL_FREE = h("wickra_regime_label_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init4() { WICKRA_RENKO_TRAILING_STOP_NEW = h("wickra_renko_trailing_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_RENKO_TRAILING_STOP_UPDATE = h("wickra_renko_trailing_stop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_RENKO_TRAILING_STOP_BATCH = h("wickra_renko_trailing_stop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RENKO_TRAILING_STOP_WARMUP_PERIOD = h("wickra_renko_trailing_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RENKO_TRAILING_STOP_IS_READY = h("wickra_renko_trailing_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RENKO_TRAILING_STOP_RESET = h("wickra_renko_trailing_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RENKO_TRAILING_STOP_FREE = h("wickra_renko_trailing_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RMI_NEW = h("wickra_rmi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_RMI_UPDATE = h("wickra_rmi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_RMI_BATCH = h("wickra_rmi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RMI_WARMUP_PERIOD = h("wickra_rmi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RMI_IS_READY = h("wickra_rmi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RMI_RESET = h("wickra_rmi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RMI_FREE = h("wickra_rmi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROC_NEW = h("wickra_roc_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROC_UPDATE = h("wickra_roc_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROC_BATCH = h("wickra_roc_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROC_WARMUP_PERIOD = h("wickra_roc_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROC_IS_READY = h("wickra_roc_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROC_RESET = h("wickra_roc_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROC_FREE = h("wickra_roc_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROCP_NEW = h("wickra_rocp_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROCP_UPDATE = h("wickra_rocp_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROCP_BATCH = h("wickra_rocp_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROCP_WARMUP_PERIOD = h("wickra_rocp_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROCP_IS_READY = h("wickra_rocp_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROCP_RESET = h("wickra_rocp_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROCP_FREE = h("wickra_rocp_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROCR_NEW = h("wickra_rocr_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROCR_UPDATE = h("wickra_rocr_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROCR_BATCH = h("wickra_rocr_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROCR_WARMUP_PERIOD = h("wickra_rocr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROCR_IS_READY = h("wickra_rocr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROCR_RESET = h("wickra_rocr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROCR_FREE = h("wickra_rocr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROCR100_NEW = h("wickra_rocr100_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROCR100_UPDATE = h("wickra_rocr100_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROCR100_BATCH = h("wickra_rocr100_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROCR100_WARMUP_PERIOD = h("wickra_rocr100_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROCR100_IS_READY = h("wickra_rocr100_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROCR100_RESET = h("wickra_rocr100_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROCR100_FREE = h("wickra_rocr100_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_IQR_NEW = h("wickra_rolling_iqr_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLLING_IQR_UPDATE = h("wickra_rolling_iqr_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROLLING_IQR_BATCH = h("wickra_rolling_iqr_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_IQR_WARMUP_PERIOD = h("wickra_rolling_iqr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_IQR_IS_READY = h("wickra_rolling_iqr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_IQR_RESET = h("wickra_rolling_iqr_reset", FunctionDescriptor.ofVoid(ADDRESS)); + } + + private static void init6() { WICKRA_ROLLING_IQR_FREE = h("wickra_rolling_iqr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_MIN_MAX_SCALER_NEW = h("wickra_rolling_min_max_scaler_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLLING_MIN_MAX_SCALER_UPDATE = h("wickra_rolling_min_max_scaler_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROLLING_MIN_MAX_SCALER_BATCH = h("wickra_rolling_min_max_scaler_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_MIN_MAX_SCALER_WARMUP_PERIOD = h("wickra_rolling_min_max_scaler_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_MIN_MAX_SCALER_IS_READY = h("wickra_rolling_min_max_scaler_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_MIN_MAX_SCALER_RESET = h("wickra_rolling_min_max_scaler_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_MIN_MAX_SCALER_FREE = h("wickra_rolling_min_max_scaler_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_PERCENTILE_RANK_NEW = h("wickra_rolling_percentile_rank_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLLING_PERCENTILE_RANK_UPDATE = h("wickra_rolling_percentile_rank_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROLLING_PERCENTILE_RANK_BATCH = h("wickra_rolling_percentile_rank_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_PERCENTILE_RANK_WARMUP_PERIOD = h("wickra_rolling_percentile_rank_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_PERCENTILE_RANK_IS_READY = h("wickra_rolling_percentile_rank_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_PERCENTILE_RANK_RESET = h("wickra_rolling_percentile_rank_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_PERCENTILE_RANK_FREE = h("wickra_rolling_percentile_rank_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_QUANTILE_NEW = h("wickra_rolling_quantile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_ROLLING_QUANTILE_UPDATE = h("wickra_rolling_quantile_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROLLING_QUANTILE_BATCH = h("wickra_rolling_quantile_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_QUANTILE_WARMUP_PERIOD = h("wickra_rolling_quantile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_QUANTILE_IS_READY = h("wickra_rolling_quantile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_QUANTILE_RESET = h("wickra_rolling_quantile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_QUANTILE_FREE = h("wickra_rolling_quantile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROOFING_FILTER_NEW = h("wickra_roofing_filter_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_ROOFING_FILTER_UPDATE = h("wickra_roofing_filter_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ROOFING_FILTER_BATCH = h("wickra_roofing_filter_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROOFING_FILTER_WARMUP_PERIOD = h("wickra_roofing_filter_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROOFING_FILTER_IS_READY = h("wickra_roofing_filter_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROOFING_FILTER_RESET = h("wickra_roofing_filter_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROOFING_FILTER_FREE = h("wickra_roofing_filter_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RSI_NEW = h("wickra_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_RSI_UPDATE = h("wickra_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_RSI_BATCH = h("wickra_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RSI_WARMUP_PERIOD = h("wickra_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RSI_IS_READY = h("wickra_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RSI_RESET = h("wickra_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RSI_FREE = h("wickra_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RSX_NEW = h("wickra_rsx_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_RSX_UPDATE = h("wickra_rsx_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_RSX_BATCH = h("wickra_rsx_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RSX_WARMUP_PERIOD = h("wickra_rsx_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RSX_IS_READY = h("wickra_rsx_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RSX_RESET = h("wickra_rsx_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RSX_FREE = h("wickra_rsx_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RVI_VOLATILITY_NEW = h("wickra_rvi_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_RVI_VOLATILITY_UPDATE = h("wickra_rvi_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_RVI_VOLATILITY_BATCH = h("wickra_rvi_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RVI_VOLATILITY_WARMUP_PERIOD = h("wickra_rvi_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RVI_VOLATILITY_IS_READY = h("wickra_rvi_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RVI_VOLATILITY_RESET = h("wickra_rvi_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RVI_VOLATILITY_FREE = h("wickra_rvi_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SAMPLE_ENTROPY_NEW = h("wickra_sample_entropy_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_SAMPLE_ENTROPY_UPDATE = h("wickra_sample_entropy_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SAMPLE_ENTROPY_BATCH = h("wickra_sample_entropy_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SAMPLE_ENTROPY_WARMUP_PERIOD = h("wickra_sample_entropy_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SAMPLE_ENTROPY_IS_READY = h("wickra_sample_entropy_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SAMPLE_ENTROPY_RESET = h("wickra_sample_entropy_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SAMPLE_ENTROPY_FREE = h("wickra_sample_entropy_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHANNON_ENTROPY_NEW = h("wickra_shannon_entropy_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_SHANNON_ENTROPY_UPDATE = h("wickra_shannon_entropy_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SHANNON_ENTROPY_BATCH = h("wickra_shannon_entropy_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SHANNON_ENTROPY_WARMUP_PERIOD = h("wickra_shannon_entropy_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SHANNON_ENTROPY_IS_READY = h("wickra_shannon_entropy_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SHANNON_ENTROPY_RESET = h("wickra_shannon_entropy_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHANNON_ENTROPY_FREE = h("wickra_shannon_entropy_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHARPE_RATIO_NEW = h("wickra_sharpe_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_SHARPE_RATIO_UPDATE = h("wickra_sharpe_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SHARPE_RATIO_BATCH = h("wickra_sharpe_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SHARPE_RATIO_WARMUP_PERIOD = h("wickra_sharpe_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SHARPE_RATIO_IS_READY = h("wickra_sharpe_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SHARPE_RATIO_RESET = h("wickra_sharpe_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHARPE_RATIO_FREE = h("wickra_sharpe_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SINE_WAVE_NEW = h("wickra_sine_wave_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SINE_WAVE_UPDATE = h("wickra_sine_wave_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SINE_WAVE_BATCH = h("wickra_sine_wave_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SINE_WAVE_WARMUP_PERIOD = h("wickra_sine_wave_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SINE_WAVE_IS_READY = h("wickra_sine_wave_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SINE_WAVE_RESET = h("wickra_sine_wave_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SINE_WAVE_FREE = h("wickra_sine_wave_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SINE_WEIGHTED_MA_NEW = h("wickra_sine_weighted_ma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SINE_WEIGHTED_MA_UPDATE = h("wickra_sine_weighted_ma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SINE_WEIGHTED_MA_BATCH = h("wickra_sine_weighted_ma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SINE_WEIGHTED_MA_WARMUP_PERIOD = h("wickra_sine_weighted_ma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SINE_WEIGHTED_MA_IS_READY = h("wickra_sine_weighted_ma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SINE_WEIGHTED_MA_RESET = h("wickra_sine_weighted_ma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SINE_WEIGHTED_MA_FREE = h("wickra_sine_weighted_ma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SKEWNESS_NEW = h("wickra_skewness_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SKEWNESS_UPDATE = h("wickra_skewness_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SKEWNESS_BATCH = h("wickra_skewness_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SKEWNESS_WARMUP_PERIOD = h("wickra_skewness_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SKEWNESS_IS_READY = h("wickra_skewness_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SKEWNESS_RESET = h("wickra_skewness_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SKEWNESS_FREE = h("wickra_skewness_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMA_NEW = h("wickra_sma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SMA_UPDATE = h("wickra_sma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SMA_BATCH = h("wickra_sma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SMA_WARMUP_PERIOD = h("wickra_sma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SMA_IS_READY = h("wickra_sma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SMA_RESET = h("wickra_sma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMA_FREE = h("wickra_sma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMMA_NEW = h("wickra_smma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SMMA_UPDATE = h("wickra_smma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SMMA_BATCH = h("wickra_smma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SMMA_WARMUP_PERIOD = h("wickra_smma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SMMA_IS_READY = h("wickra_smma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SMMA_RESET = h("wickra_smma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMMA_FREE = h("wickra_smma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SORTINO_RATIO_NEW = h("wickra_sortino_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_SORTINO_RATIO_UPDATE = h("wickra_sortino_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SORTINO_RATIO_BATCH = h("wickra_sortino_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SORTINO_RATIO_WARMUP_PERIOD = h("wickra_sortino_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SORTINO_RATIO_IS_READY = h("wickra_sortino_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SORTINO_RATIO_RESET = h("wickra_sortino_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SORTINO_RATIO_FREE = h("wickra_sortino_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STANDARD_ERROR_NEW = h("wickra_standard_error_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_STANDARD_ERROR_UPDATE = h("wickra_standard_error_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_STANDARD_ERROR_BATCH = h("wickra_standard_error_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STANDARD_ERROR_WARMUP_PERIOD = h("wickra_standard_error_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STANDARD_ERROR_IS_READY = h("wickra_standard_error_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STANDARD_ERROR_RESET = h("wickra_standard_error_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STANDARD_ERROR_FREE = h("wickra_standard_error_free", FunctionDescriptor.ofVoid(ADDRESS)); } - private static void init5() { + private static void init7() { WICKRA_STC_NEW = h("wickra_stc_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_STC_UPDATE = h("wickra_stc_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_STC_BATCH = h("wickra_stc_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STC_WARMUP_PERIOD = h("wickra_stc_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STC_IS_READY = h("wickra_stc_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STC_RESET = h("wickra_stc_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STC_FREE = h("wickra_stc_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STD_DEV_NEW = h("wickra_std_dev_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_STD_DEV_UPDATE = h("wickra_std_dev_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_STD_DEV_BATCH = h("wickra_std_dev_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STD_DEV_WARMUP_PERIOD = h("wickra_std_dev_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STD_DEV_IS_READY = h("wickra_std_dev_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STD_DEV_RESET = h("wickra_std_dev_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STD_DEV_FREE = h("wickra_std_dev_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STEP_TRAILING_STOP_NEW = h("wickra_step_trailing_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_STEP_TRAILING_STOP_UPDATE = h("wickra_step_trailing_stop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_STEP_TRAILING_STOP_BATCH = h("wickra_step_trailing_stop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STEP_TRAILING_STOP_WARMUP_PERIOD = h("wickra_step_trailing_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STEP_TRAILING_STOP_IS_READY = h("wickra_step_trailing_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STEP_TRAILING_STOP_RESET = h("wickra_step_trailing_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STEP_TRAILING_STOP_FREE = h("wickra_step_trailing_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STERLING_RATIO_NEW = h("wickra_sterling_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_STERLING_RATIO_UPDATE = h("wickra_sterling_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_STERLING_RATIO_BATCH = h("wickra_sterling_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STERLING_RATIO_WARMUP_PERIOD = h("wickra_sterling_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STERLING_RATIO_IS_READY = h("wickra_sterling_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STERLING_RATIO_RESET = h("wickra_sterling_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STERLING_RATIO_FREE = h("wickra_sterling_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STOCH_RSI_NEW = h("wickra_stoch_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_STOCH_RSI_UPDATE = h("wickra_stoch_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_STOCH_RSI_BATCH = h("wickra_stoch_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STOCH_RSI_WARMUP_PERIOD = h("wickra_stoch_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STOCH_RSI_IS_READY = h("wickra_stoch_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STOCH_RSI_RESET = h("wickra_stoch_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STOCH_RSI_FREE = h("wickra_stoch_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SUPER_SMOOTHER_NEW = h("wickra_super_smoother_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SUPER_SMOOTHER_UPDATE = h("wickra_super_smoother_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_SUPER_SMOOTHER_BATCH = h("wickra_super_smoother_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SUPER_SMOOTHER_WARMUP_PERIOD = h("wickra_super_smoother_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SUPER_SMOOTHER_IS_READY = h("wickra_super_smoother_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SUPER_SMOOTHER_RESET = h("wickra_super_smoother_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SUPER_SMOOTHER_FREE = h("wickra_super_smoother_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_T3_NEW = h("wickra_t3_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_T3_UPDATE = h("wickra_t3_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_T3_BATCH = h("wickra_t3_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_T3_WARMUP_PERIOD = h("wickra_t3_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_T3_IS_READY = h("wickra_t3_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_T3_RESET = h("wickra_t3_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_T3_FREE = h("wickra_t3_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TAIL_RATIO_NEW = h("wickra_tail_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TAIL_RATIO_UPDATE = h("wickra_tail_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TAIL_RATIO_BATCH = h("wickra_tail_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TAIL_RATIO_WARMUP_PERIOD = h("wickra_tail_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TAIL_RATIO_IS_READY = h("wickra_tail_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TAIL_RATIO_RESET = h("wickra_tail_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TAIL_RATIO_FREE = h("wickra_tail_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TEMA_NEW = h("wickra_tema_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TEMA_UPDATE = h("wickra_tema_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TEMA_BATCH = h("wickra_tema_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TEMA_WARMUP_PERIOD = h("wickra_tema_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TEMA_IS_READY = h("wickra_tema_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TEMA_RESET = h("wickra_tema_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TEMA_FREE = h("wickra_tema_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TII_NEW = h("wickra_tii_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_TII_UPDATE = h("wickra_tii_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TII_BATCH = h("wickra_tii_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TII_WARMUP_PERIOD = h("wickra_tii_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TII_IS_READY = h("wickra_tii_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TII_RESET = h("wickra_tii_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TII_FREE = h("wickra_tii_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TREND_LABEL_NEW = h("wickra_trend_label_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TREND_LABEL_UPDATE = h("wickra_trend_label_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TREND_LABEL_BATCH = h("wickra_trend_label_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TREND_LABEL_WARMUP_PERIOD = h("wickra_trend_label_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TREND_LABEL_IS_READY = h("wickra_trend_label_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TREND_LABEL_RESET = h("wickra_trend_label_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TREND_LABEL_FREE = h("wickra_trend_label_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TREND_STRENGTH_INDEX_NEW = h("wickra_trend_strength_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TREND_STRENGTH_INDEX_UPDATE = h("wickra_trend_strength_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TREND_STRENGTH_INDEX_BATCH = h("wickra_trend_strength_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TREND_STRENGTH_INDEX_WARMUP_PERIOD = h("wickra_trend_strength_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TREND_STRENGTH_INDEX_IS_READY = h("wickra_trend_strength_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TREND_STRENGTH_INDEX_RESET = h("wickra_trend_strength_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TREND_STRENGTH_INDEX_FREE = h("wickra_trend_strength_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRENDFLEX_NEW = h("wickra_trendflex_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TRENDFLEX_UPDATE = h("wickra_trendflex_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TRENDFLEX_BATCH = h("wickra_trendflex_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRENDFLEX_WARMUP_PERIOD = h("wickra_trendflex_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRENDFLEX_IS_READY = h("wickra_trendflex_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRENDFLEX_RESET = h("wickra_trendflex_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRENDFLEX_FREE = h("wickra_trendflex_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIMA_NEW = h("wickra_trima_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TRIMA_UPDATE = h("wickra_trima_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TRIMA_BATCH = h("wickra_trima_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRIMA_WARMUP_PERIOD = h("wickra_trima_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRIMA_IS_READY = h("wickra_trima_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRIMA_RESET = h("wickra_trima_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIMA_FREE = h("wickra_trima_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIX_NEW = h("wickra_trix_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TRIX_UPDATE = h("wickra_trix_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TRIX_BATCH = h("wickra_trix_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRIX_WARMUP_PERIOD = h("wickra_trix_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRIX_IS_READY = h("wickra_trix_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRIX_RESET = h("wickra_trix_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIX_FREE = h("wickra_trix_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSF_NEW = h("wickra_tsf_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TSF_UPDATE = h("wickra_tsf_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TSF_BATCH = h("wickra_tsf_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TSF_WARMUP_PERIOD = h("wickra_tsf_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TSF_IS_READY = h("wickra_tsf_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TSF_RESET = h("wickra_tsf_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSF_FREE = h("wickra_tsf_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSF_OSCILLATOR_NEW = h("wickra_tsf_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TSF_OSCILLATOR_UPDATE = h("wickra_tsf_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TSF_OSCILLATOR_BATCH = h("wickra_tsf_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TSF_OSCILLATOR_WARMUP_PERIOD = h("wickra_tsf_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TSF_OSCILLATOR_IS_READY = h("wickra_tsf_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TSF_OSCILLATOR_RESET = h("wickra_tsf_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSF_OSCILLATOR_FREE = h("wickra_tsf_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSI_NEW = h("wickra_tsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); + } + + private static void init8() { WICKRA_TSI_UPDATE = h("wickra_tsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_TSI_BATCH = h("wickra_tsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TSI_WARMUP_PERIOD = h("wickra_tsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TSI_IS_READY = h("wickra_tsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TSI_RESET = h("wickra_tsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSI_FREE = h("wickra_tsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ULCER_INDEX_NEW = h("wickra_ulcer_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ULCER_INDEX_UPDATE = h("wickra_ulcer_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ULCER_INDEX_BATCH = h("wickra_ulcer_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ULCER_INDEX_WARMUP_PERIOD = h("wickra_ulcer_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ULCER_INDEX_IS_READY = h("wickra_ulcer_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ULCER_INDEX_RESET = h("wickra_ulcer_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ULCER_INDEX_FREE = h("wickra_ulcer_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UNIVERSAL_OSCILLATOR_NEW = h("wickra_universal_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_UNIVERSAL_OSCILLATOR_UPDATE = h("wickra_universal_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_UNIVERSAL_OSCILLATOR_BATCH = h("wickra_universal_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_UNIVERSAL_OSCILLATOR_WARMUP_PERIOD = h("wickra_universal_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_UNIVERSAL_OSCILLATOR_IS_READY = h("wickra_universal_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_UNIVERSAL_OSCILLATOR_RESET = h("wickra_universal_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UNIVERSAL_OSCILLATOR_FREE = h("wickra_universal_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UPSIDE_POTENTIAL_RATIO_NEW = h("wickra_upside_potential_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_UPSIDE_POTENTIAL_RATIO_UPDATE = h("wickra_upside_potential_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_UPSIDE_POTENTIAL_RATIO_BATCH = h("wickra_upside_potential_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_UPSIDE_POTENTIAL_RATIO_WARMUP_PERIOD = h("wickra_upside_potential_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_UPSIDE_POTENTIAL_RATIO_IS_READY = h("wickra_upside_potential_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_UPSIDE_POTENTIAL_RATIO_RESET = h("wickra_upside_potential_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UPSIDE_POTENTIAL_RATIO_FREE = h("wickra_upside_potential_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VALUE_AT_RISK_NEW = h("wickra_value_at_risk_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_VALUE_AT_RISK_UPDATE = h("wickra_value_at_risk_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_VALUE_AT_RISK_BATCH = h("wickra_value_at_risk_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VALUE_AT_RISK_WARMUP_PERIOD = h("wickra_value_at_risk_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VALUE_AT_RISK_IS_READY = h("wickra_value_at_risk_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VALUE_AT_RISK_RESET = h("wickra_value_at_risk_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VALUE_AT_RISK_FREE = h("wickra_value_at_risk_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VARIANCE_NEW = h("wickra_variance_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VARIANCE_UPDATE = h("wickra_variance_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_VARIANCE_BATCH = h("wickra_variance_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VARIANCE_WARMUP_PERIOD = h("wickra_variance_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VARIANCE_IS_READY = h("wickra_variance_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VARIANCE_RESET = h("wickra_variance_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VARIANCE_FREE = h("wickra_variance_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VERTICAL_HORIZONTAL_FILTER_NEW = h("wickra_vertical_horizontal_filter_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VERTICAL_HORIZONTAL_FILTER_UPDATE = h("wickra_vertical_horizontal_filter_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_VERTICAL_HORIZONTAL_FILTER_BATCH = h("wickra_vertical_horizontal_filter_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VERTICAL_HORIZONTAL_FILTER_WARMUP_PERIOD = h("wickra_vertical_horizontal_filter_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VERTICAL_HORIZONTAL_FILTER_IS_READY = h("wickra_vertical_horizontal_filter_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VERTICAL_HORIZONTAL_FILTER_RESET = h("wickra_vertical_horizontal_filter_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VERTICAL_HORIZONTAL_FILTER_FREE = h("wickra_vertical_horizontal_filter_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init6() { WICKRA_VIDYA_NEW = h("wickra_vidya_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_VIDYA_UPDATE = h("wickra_vidya_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_VIDYA_BATCH = h("wickra_vidya_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VIDYA_WARMUP_PERIOD = h("wickra_vidya_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VIDYA_IS_READY = h("wickra_vidya_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VIDYA_RESET = h("wickra_vidya_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VIDYA_FREE = h("wickra_vidya_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLATILITY_OF_VOLATILITY_NEW = h("wickra_volatility_of_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_VOLATILITY_OF_VOLATILITY_UPDATE = h("wickra_volatility_of_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_VOLATILITY_OF_VOLATILITY_BATCH = h("wickra_volatility_of_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLATILITY_OF_VOLATILITY_WARMUP_PERIOD = h("wickra_volatility_of_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLATILITY_OF_VOLATILITY_IS_READY = h("wickra_volatility_of_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLATILITY_OF_VOLATILITY_RESET = h("wickra_volatility_of_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLATILITY_OF_VOLATILITY_FREE = h("wickra_volatility_of_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WAVE_PM_NEW = h("wickra_wave_pm_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_WAVE_PM_UPDATE = h("wickra_wave_pm_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_WAVE_PM_BATCH = h("wickra_wave_pm_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WAVE_PM_WARMUP_PERIOD = h("wickra_wave_pm_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WAVE_PM_IS_READY = h("wickra_wave_pm_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WAVE_PM_RESET = h("wickra_wave_pm_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WAVE_PM_FREE = h("wickra_wave_pm_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WIN_RATE_NEW = h("wickra_win_rate_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_WIN_RATE_UPDATE = h("wickra_win_rate_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_WIN_RATE_BATCH = h("wickra_win_rate_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WIN_RATE_WARMUP_PERIOD = h("wickra_win_rate_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WIN_RATE_IS_READY = h("wickra_win_rate_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WIN_RATE_RESET = h("wickra_win_rate_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WIN_RATE_FREE = h("wickra_win_rate_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WMA_NEW = h("wickra_wma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_WMA_UPDATE = h("wickra_wma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_WMA_BATCH = h("wickra_wma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WMA_WARMUP_PERIOD = h("wickra_wma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WMA_IS_READY = h("wickra_wma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WMA_RESET = h("wickra_wma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WMA_FREE = h("wickra_wma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_Z_SCORE_NEW = h("wickra_z_score_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_Z_SCORE_UPDATE = h("wickra_z_score_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_Z_SCORE_BATCH = h("wickra_z_score_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_Z_SCORE_WARMUP_PERIOD = h("wickra_z_score_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_Z_SCORE_IS_READY = h("wickra_z_score_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_Z_SCORE_RESET = h("wickra_z_score_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_Z_SCORE_FREE = h("wickra_z_score_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ZLEMA_NEW = h("wickra_zlema_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ZLEMA_UPDATE = h("wickra_zlema_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE)); WICKRA_ZLEMA_BATCH = h("wickra_zlema_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ZLEMA_WARMUP_PERIOD = h("wickra_zlema_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ZLEMA_IS_READY = h("wickra_zlema_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ZLEMA_RESET = h("wickra_zlema_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ZLEMA_FREE = h("wickra_zlema_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ALPHA_NEW = h("wickra_alpha_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_ALPHA_UPDATE = h("wickra_alpha_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_ALPHA_BATCH = h("wickra_alpha_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ALPHA_WARMUP_PERIOD = h("wickra_alpha_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ALPHA_IS_READY = h("wickra_alpha_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ALPHA_RESET = h("wickra_alpha_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ALPHA_FREE = h("wickra_alpha_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BETA_NEW = h("wickra_beta_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_BETA_UPDATE = h("wickra_beta_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_BETA_BATCH = h("wickra_beta_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BETA_WARMUP_PERIOD = h("wickra_beta_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BETA_IS_READY = h("wickra_beta_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BETA_RESET = h("wickra_beta_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BETA_FREE = h("wickra_beta_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BETA_NEUTRAL_SPREAD_NEW = h("wickra_beta_neutral_spread_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_BETA_NEUTRAL_SPREAD_UPDATE = h("wickra_beta_neutral_spread_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_BETA_NEUTRAL_SPREAD_BATCH = h("wickra_beta_neutral_spread_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BETA_NEUTRAL_SPREAD_WARMUP_PERIOD = h("wickra_beta_neutral_spread_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BETA_NEUTRAL_SPREAD_IS_READY = h("wickra_beta_neutral_spread_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BETA_NEUTRAL_SPREAD_RESET = h("wickra_beta_neutral_spread_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BETA_NEUTRAL_SPREAD_FREE = h("wickra_beta_neutral_spread_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DISTANCE_SSD_NEW = h("wickra_distance_ssd_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DISTANCE_SSD_UPDATE = h("wickra_distance_ssd_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); + } + + private static void init9() { WICKRA_DISTANCE_SSD_BATCH = h("wickra_distance_ssd_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DISTANCE_SSD_WARMUP_PERIOD = h("wickra_distance_ssd_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DISTANCE_SSD_IS_READY = h("wickra_distance_ssd_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DISTANCE_SSD_RESET = h("wickra_distance_ssd_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DISTANCE_SSD_FREE = h("wickra_distance_ssd_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GRANGER_CAUSALITY_NEW = h("wickra_granger_causality_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_GRANGER_CAUSALITY_UPDATE = h("wickra_granger_causality_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_GRANGER_CAUSALITY_BATCH = h("wickra_granger_causality_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GRANGER_CAUSALITY_WARMUP_PERIOD = h("wickra_granger_causality_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GRANGER_CAUSALITY_IS_READY = h("wickra_granger_causality_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GRANGER_CAUSALITY_RESET = h("wickra_granger_causality_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GRANGER_CAUSALITY_FREE = h("wickra_granger_causality_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HASBROUCK_INFORMATION_SHARE_NEW = h("wickra_hasbrouck_information_share_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_HASBROUCK_INFORMATION_SHARE_UPDATE = h("wickra_hasbrouck_information_share_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_HASBROUCK_INFORMATION_SHARE_BATCH = h("wickra_hasbrouck_information_share_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HASBROUCK_INFORMATION_SHARE_WARMUP_PERIOD = h("wickra_hasbrouck_information_share_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HASBROUCK_INFORMATION_SHARE_IS_READY = h("wickra_hasbrouck_information_share_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HASBROUCK_INFORMATION_SHARE_RESET = h("wickra_hasbrouck_information_share_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HASBROUCK_INFORMATION_SHARE_FREE = h("wickra_hasbrouck_information_share_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INFORMATION_RATIO_NEW = h("wickra_information_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_INFORMATION_RATIO_UPDATE = h("wickra_information_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_INFORMATION_RATIO_BATCH = h("wickra_information_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INFORMATION_RATIO_WARMUP_PERIOD = h("wickra_information_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INFORMATION_RATIO_IS_READY = h("wickra_information_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INFORMATION_RATIO_RESET = h("wickra_information_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INFORMATION_RATIO_FREE = h("wickra_information_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KENDALL_TAU_NEW = h("wickra_kendall_tau_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_KENDALL_TAU_UPDATE = h("wickra_kendall_tau_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_KENDALL_TAU_BATCH = h("wickra_kendall_tau_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KENDALL_TAU_WARMUP_PERIOD = h("wickra_kendall_tau_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KENDALL_TAU_IS_READY = h("wickra_kendall_tau_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KENDALL_TAU_RESET = h("wickra_kendall_tau_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KENDALL_TAU_FREE = h("wickra_kendall_tau_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OU_HALF_LIFE_NEW = h("wickra_ou_half_life_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_OU_HALF_LIFE_UPDATE = h("wickra_ou_half_life_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_OU_HALF_LIFE_BATCH = h("wickra_ou_half_life_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_OU_HALF_LIFE_WARMUP_PERIOD = h("wickra_ou_half_life_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OU_HALF_LIFE_IS_READY = h("wickra_ou_half_life_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OU_HALF_LIFE_RESET = h("wickra_ou_half_life_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OU_HALF_LIFE_FREE = h("wickra_ou_half_life_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PAIR_SPREAD_Z_SCORE_NEW = h("wickra_pair_spread_z_score_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_PAIR_SPREAD_Z_SCORE_UPDATE = h("wickra_pair_spread_z_score_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_PAIR_SPREAD_Z_SCORE_BATCH = h("wickra_pair_spread_z_score_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PAIR_SPREAD_Z_SCORE_WARMUP_PERIOD = h("wickra_pair_spread_z_score_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PAIR_SPREAD_Z_SCORE_IS_READY = h("wickra_pair_spread_z_score_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PAIR_SPREAD_Z_SCORE_RESET = h("wickra_pair_spread_z_score_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PAIR_SPREAD_Z_SCORE_FREE = h("wickra_pair_spread_z_score_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PAIRWISE_BETA_NEW = h("wickra_pairwise_beta_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PAIRWISE_BETA_UPDATE = h("wickra_pairwise_beta_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_PAIRWISE_BETA_BATCH = h("wickra_pairwise_beta_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PAIRWISE_BETA_WARMUP_PERIOD = h("wickra_pairwise_beta_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PAIRWISE_BETA_IS_READY = h("wickra_pairwise_beta_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PAIRWISE_BETA_RESET = h("wickra_pairwise_beta_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PAIRWISE_BETA_FREE = h("wickra_pairwise_beta_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PEARSON_CORRELATION_NEW = h("wickra_pearson_correlation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PEARSON_CORRELATION_UPDATE = h("wickra_pearson_correlation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_PEARSON_CORRELATION_BATCH = h("wickra_pearson_correlation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PEARSON_CORRELATION_WARMUP_PERIOD = h("wickra_pearson_correlation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PEARSON_CORRELATION_IS_READY = h("wickra_pearson_correlation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PEARSON_CORRELATION_RESET = h("wickra_pearson_correlation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PEARSON_CORRELATION_FREE = h("wickra_pearson_correlation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_CORRELATION_NEW = h("wickra_rolling_correlation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLLING_CORRELATION_UPDATE = h("wickra_rolling_correlation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_ROLLING_CORRELATION_BATCH = h("wickra_rolling_correlation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_CORRELATION_WARMUP_PERIOD = h("wickra_rolling_correlation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_CORRELATION_IS_READY = h("wickra_rolling_correlation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_CORRELATION_RESET = h("wickra_rolling_correlation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_CORRELATION_FREE = h("wickra_rolling_correlation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_COVARIANCE_NEW = h("wickra_rolling_covariance_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLLING_COVARIANCE_UPDATE = h("wickra_rolling_covariance_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_ROLLING_COVARIANCE_BATCH = h("wickra_rolling_covariance_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_COVARIANCE_WARMUP_PERIOD = h("wickra_rolling_covariance_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_COVARIANCE_IS_READY = h("wickra_rolling_covariance_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_COVARIANCE_RESET = h("wickra_rolling_covariance_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_COVARIANCE_FREE = h("wickra_rolling_covariance_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPEARMAN_CORRELATION_NEW = h("wickra_spearman_correlation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SPEARMAN_CORRELATION_UPDATE = h("wickra_spearman_correlation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_SPEARMAN_CORRELATION_BATCH = h("wickra_spearman_correlation_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SPEARMAN_CORRELATION_WARMUP_PERIOD = h("wickra_spearman_correlation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SPEARMAN_CORRELATION_IS_READY = h("wickra_spearman_correlation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SPEARMAN_CORRELATION_RESET = h("wickra_spearman_correlation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPEARMAN_CORRELATION_FREE = h("wickra_spearman_correlation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPREAD_AR1_COEFFICIENT_NEW = h("wickra_spread_ar1_coefficient_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SPREAD_AR1_COEFFICIENT_UPDATE = h("wickra_spread_ar1_coefficient_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_SPREAD_AR1_COEFFICIENT_BATCH = h("wickra_spread_ar1_coefficient_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SPREAD_AR1_COEFFICIENT_WARMUP_PERIOD = h("wickra_spread_ar1_coefficient_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SPREAD_AR1_COEFFICIENT_IS_READY = h("wickra_spread_ar1_coefficient_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SPREAD_AR1_COEFFICIENT_RESET = h("wickra_spread_ar1_coefficient_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPREAD_AR1_COEFFICIENT_FREE = h("wickra_spread_ar1_coefficient_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPREAD_HURST_NEW = h("wickra_spread_hurst_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SPREAD_HURST_UPDATE = h("wickra_spread_hurst_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_SPREAD_HURST_BATCH = h("wickra_spread_hurst_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SPREAD_HURST_WARMUP_PERIOD = h("wickra_spread_hurst_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SPREAD_HURST_IS_READY = h("wickra_spread_hurst_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SPREAD_HURST_RESET = h("wickra_spread_hurst_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPREAD_HURST_FREE = h("wickra_spread_hurst_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init7() { WICKRA_TREYNOR_RATIO_NEW = h("wickra_treynor_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_TREYNOR_RATIO_UPDATE = h("wickra_treynor_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_TREYNOR_RATIO_BATCH = h("wickra_treynor_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TREYNOR_RATIO_WARMUP_PERIOD = h("wickra_treynor_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TREYNOR_RATIO_IS_READY = h("wickra_treynor_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TREYNOR_RATIO_RESET = h("wickra_treynor_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TREYNOR_RATIO_FREE = h("wickra_treynor_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VARIANCE_RATIO_NEW = h("wickra_variance_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_VARIANCE_RATIO_UPDATE = h("wickra_variance_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_VARIANCE_RATIO_BATCH = h("wickra_variance_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VARIANCE_RATIO_WARMUP_PERIOD = h("wickra_variance_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VARIANCE_RATIO_IS_READY = h("wickra_variance_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VARIANCE_RATIO_RESET = h("wickra_variance_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VARIANCE_RATIO_FREE = h("wickra_variance_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ABANDONED_BABY_NEW = h("wickra_abandoned_baby_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ABANDONED_BABY_UPDATE = h("wickra_abandoned_baby_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ABANDONED_BABY_BATCH = h("wickra_abandoned_baby_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ABANDONED_BABY_WARMUP_PERIOD = h("wickra_abandoned_baby_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ABANDONED_BABY_IS_READY = h("wickra_abandoned_baby_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ABANDONED_BABY_RESET = h("wickra_abandoned_baby_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ABANDONED_BABY_FREE = h("wickra_abandoned_baby_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ABCD_NEW = h("wickra_abcd_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ABCD_UPDATE = h("wickra_abcd_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ABCD_BATCH = h("wickra_abcd_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + } + + private static void init10() { + WICKRA_ABCD_WARMUP_PERIOD = h("wickra_abcd_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ABCD_IS_READY = h("wickra_abcd_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ABCD_RESET = h("wickra_abcd_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ABCD_FREE = h("wickra_abcd_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ACCELERATOR_OSCILLATOR_NEW = h("wickra_accelerator_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_ACCELERATOR_OSCILLATOR_UPDATE = h("wickra_accelerator_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ACCELERATOR_OSCILLATOR_BATCH = h("wickra_accelerator_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ACCELERATOR_OSCILLATOR_WARMUP_PERIOD = h("wickra_accelerator_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ACCELERATOR_OSCILLATOR_IS_READY = h("wickra_accelerator_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ACCELERATOR_OSCILLATOR_RESET = h("wickra_accelerator_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ACCELERATOR_OSCILLATOR_FREE = h("wickra_accelerator_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AD_OSCILLATOR_NEW = h("wickra_ad_oscillator_new", FunctionDescriptor.of(ADDRESS)); WICKRA_AD_OSCILLATOR_UPDATE = h("wickra_ad_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_AD_OSCILLATOR_BATCH = h("wickra_ad_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AD_OSCILLATOR_WARMUP_PERIOD = h("wickra_ad_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AD_OSCILLATOR_IS_READY = h("wickra_ad_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AD_OSCILLATOR_RESET = h("wickra_ad_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AD_OSCILLATOR_FREE = h("wickra_ad_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_CCI_NEW = h("wickra_adaptive_cci_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ADAPTIVE_CCI_UPDATE = h("wickra_adaptive_cci_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ADAPTIVE_CCI_BATCH = h("wickra_adaptive_cci_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADAPTIVE_CCI_WARMUP_PERIOD = h("wickra_adaptive_cci_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADAPTIVE_CCI_IS_READY = h("wickra_adaptive_cci_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADAPTIVE_CCI_RESET = h("wickra_adaptive_cci_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADAPTIVE_CCI_FREE = h("wickra_adaptive_cci_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADL_NEW = h("wickra_adl_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ADL_UPDATE = h("wickra_adl_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ADL_BATCH = h("wickra_adl_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADL_WARMUP_PERIOD = h("wickra_adl_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADL_IS_READY = h("wickra_adl_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADL_RESET = h("wickra_adl_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADL_FREE = h("wickra_adl_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADVANCE_BLOCK_NEW = h("wickra_advance_block_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ADVANCE_BLOCK_UPDATE = h("wickra_advance_block_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ADVANCE_BLOCK_BATCH = h("wickra_advance_block_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADVANCE_BLOCK_WARMUP_PERIOD = h("wickra_advance_block_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADVANCE_BLOCK_IS_READY = h("wickra_advance_block_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADVANCE_BLOCK_RESET = h("wickra_advance_block_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADVANCE_BLOCK_FREE = h("wickra_advance_block_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADXR_NEW = h("wickra_adxr_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ADXR_UPDATE = h("wickra_adxr_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ADXR_BATCH = h("wickra_adxr_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ADXR_WARMUP_PERIOD = h("wickra_adxr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADXR_IS_READY = h("wickra_adxr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADXR_RESET = h("wickra_adxr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADXR_FREE = h("wickra_adxr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ANCHORED_VWAP_NEW = h("wickra_anchored_vwap_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ANCHORED_VWAP_UPDATE = h("wickra_anchored_vwap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ANCHORED_VWAP_BATCH = h("wickra_anchored_vwap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ANCHORED_VWAP_WARMUP_PERIOD = h("wickra_anchored_vwap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ANCHORED_VWAP_IS_READY = h("wickra_anchored_vwap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ANCHORED_VWAP_RESET = h("wickra_anchored_vwap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ANCHORED_VWAP_FREE = h("wickra_anchored_vwap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AROON_OSCILLATOR_NEW = h("wickra_aroon_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_AROON_OSCILLATOR_UPDATE = h("wickra_aroon_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_AROON_OSCILLATOR_BATCH = h("wickra_aroon_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AROON_OSCILLATOR_WARMUP_PERIOD = h("wickra_aroon_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AROON_OSCILLATOR_IS_READY = h("wickra_aroon_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AROON_OSCILLATOR_RESET = h("wickra_aroon_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AROON_OSCILLATOR_FREE = h("wickra_aroon_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_NEW = h("wickra_atr_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ATR_UPDATE = h("wickra_atr_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ATR_BATCH = h("wickra_atr_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ATR_WARMUP_PERIOD = h("wickra_atr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ATR_IS_READY = h("wickra_atr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ATR_RESET = h("wickra_atr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_FREE = h("wickra_atr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_TRAILING_STOP_NEW = h("wickra_atr_trailing_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_ATR_TRAILING_STOP_UPDATE = h("wickra_atr_trailing_stop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ATR_TRAILING_STOP_BATCH = h("wickra_atr_trailing_stop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ATR_TRAILING_STOP_WARMUP_PERIOD = h("wickra_atr_trailing_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ATR_TRAILING_STOP_IS_READY = h("wickra_atr_trailing_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ATR_TRAILING_STOP_RESET = h("wickra_atr_trailing_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_TRAILING_STOP_FREE = h("wickra_atr_trailing_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AVERAGE_DAILY_RANGE_NEW = h("wickra_average_daily_range_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_INT)); WICKRA_AVERAGE_DAILY_RANGE_UPDATE = h("wickra_average_daily_range_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_AVERAGE_DAILY_RANGE_BATCH = h("wickra_average_daily_range_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AVERAGE_DAILY_RANGE_WARMUP_PERIOD = h("wickra_average_daily_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AVERAGE_DAILY_RANGE_IS_READY = h("wickra_average_daily_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AVERAGE_DAILY_RANGE_RESET = h("wickra_average_daily_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AVERAGE_DAILY_RANGE_FREE = h("wickra_average_daily_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AVG_PRICE_NEW = h("wickra_avg_price_new", FunctionDescriptor.of(ADDRESS)); WICKRA_AVG_PRICE_UPDATE = h("wickra_avg_price_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_AVG_PRICE_BATCH = h("wickra_avg_price_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AVG_PRICE_WARMUP_PERIOD = h("wickra_avg_price_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AVG_PRICE_IS_READY = h("wickra_avg_price_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AVG_PRICE_RESET = h("wickra_avg_price_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AVG_PRICE_FREE = h("wickra_avg_price_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AWESOME_OSCILLATOR_NEW = h("wickra_awesome_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_AWESOME_OSCILLATOR_UPDATE = h("wickra_awesome_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_AWESOME_OSCILLATOR_BATCH = h("wickra_awesome_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AWESOME_OSCILLATOR_WARMUP_PERIOD = h("wickra_awesome_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AWESOME_OSCILLATOR_IS_READY = h("wickra_awesome_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AWESOME_OSCILLATOR_RESET = h("wickra_awesome_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AWESOME_OSCILLATOR_FREE = h("wickra_awesome_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_NEW = h("wickra_awesome_oscillator_histogram_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_UPDATE = h("wickra_awesome_oscillator_histogram_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_BATCH = h("wickra_awesome_oscillator_histogram_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_WARMUP_PERIOD = h("wickra_awesome_oscillator_histogram_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_IS_READY = h("wickra_awesome_oscillator_histogram_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_RESET = h("wickra_awesome_oscillator_histogram_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AWESOME_OSCILLATOR_HISTOGRAM_FREE = h("wickra_awesome_oscillator_histogram_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BALANCE_OF_POWER_NEW = h("wickra_balance_of_power_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BALANCE_OF_POWER_UPDATE = h("wickra_balance_of_power_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BALANCE_OF_POWER_BATCH = h("wickra_balance_of_power_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BALANCE_OF_POWER_WARMUP_PERIOD = h("wickra_balance_of_power_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BALANCE_OF_POWER_IS_READY = h("wickra_balance_of_power_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BALANCE_OF_POWER_RESET = h("wickra_balance_of_power_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BALANCE_OF_POWER_FREE = h("wickra_balance_of_power_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BAT_NEW = h("wickra_bat_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BAT_UPDATE = h("wickra_bat_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BAT_BATCH = h("wickra_bat_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BAT_WARMUP_PERIOD = h("wickra_bat_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BAT_IS_READY = h("wickra_bat_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BAT_RESET = h("wickra_bat_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BAT_FREE = h("wickra_bat_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BELT_HOLD_NEW = h("wickra_belt_hold_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BELT_HOLD_UPDATE = h("wickra_belt_hold_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BELT_HOLD_BATCH = h("wickra_belt_hold_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BELT_HOLD_WARMUP_PERIOD = h("wickra_belt_hold_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + } + + private static void init11() { + WICKRA_BELT_HOLD_IS_READY = h("wickra_belt_hold_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BELT_HOLD_RESET = h("wickra_belt_hold_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BELT_HOLD_FREE = h("wickra_belt_hold_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BETTER_VOLUME_NEW = h("wickra_better_volume_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_BETTER_VOLUME_UPDATE = h("wickra_better_volume_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BETTER_VOLUME_BATCH = h("wickra_better_volume_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BETTER_VOLUME_WARMUP_PERIOD = h("wickra_better_volume_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BETTER_VOLUME_IS_READY = h("wickra_better_volume_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BETTER_VOLUME_RESET = h("wickra_better_volume_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BETTER_VOLUME_FREE = h("wickra_better_volume_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BODY_SIZE_PCT_NEW = h("wickra_body_size_pct_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BODY_SIZE_PCT_UPDATE = h("wickra_body_size_pct_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BODY_SIZE_PCT_BATCH = h("wickra_body_size_pct_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BODY_SIZE_PCT_WARMUP_PERIOD = h("wickra_body_size_pct_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BODY_SIZE_PCT_IS_READY = h("wickra_body_size_pct_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BODY_SIZE_PCT_RESET = h("wickra_body_size_pct_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BODY_SIZE_PCT_FREE = h("wickra_body_size_pct_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BREAKAWAY_NEW = h("wickra_breakaway_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BREAKAWAY_UPDATE = h("wickra_breakaway_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BREAKAWAY_BATCH = h("wickra_breakaway_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BREAKAWAY_WARMUP_PERIOD = h("wickra_breakaway_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BREAKAWAY_IS_READY = h("wickra_breakaway_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BREAKAWAY_RESET = h("wickra_breakaway_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BREAKAWAY_FREE = h("wickra_breakaway_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init8() { WICKRA_BUTTERFLY_NEW = h("wickra_butterfly_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BUTTERFLY_UPDATE = h("wickra_butterfly_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_BUTTERFLY_BATCH = h("wickra_butterfly_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_BUTTERFLY_WARMUP_PERIOD = h("wickra_butterfly_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BUTTERFLY_IS_READY = h("wickra_butterfly_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BUTTERFLY_RESET = h("wickra_butterfly_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BUTTERFLY_FREE = h("wickra_butterfly_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CCI_NEW = h("wickra_cci_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CCI_UPDATE = h("wickra_cci_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CCI_BATCH = h("wickra_cci_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CCI_WARMUP_PERIOD = h("wickra_cci_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CCI_IS_READY = h("wickra_cci_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CCI_RESET = h("wickra_cci_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CCI_FREE = h("wickra_cci_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHAIKIN_OSCILLATOR_NEW = h("wickra_chaikin_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_CHAIKIN_OSCILLATOR_UPDATE = h("wickra_chaikin_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CHAIKIN_OSCILLATOR_BATCH = h("wickra_chaikin_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CHAIKIN_OSCILLATOR_WARMUP_PERIOD = h("wickra_chaikin_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CHAIKIN_OSCILLATOR_IS_READY = h("wickra_chaikin_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CHAIKIN_OSCILLATOR_RESET = h("wickra_chaikin_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHAIKIN_OSCILLATOR_FREE = h("wickra_chaikin_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHAIKIN_VOLATILITY_NEW = h("wickra_chaikin_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_CHAIKIN_VOLATILITY_UPDATE = h("wickra_chaikin_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CHAIKIN_VOLATILITY_BATCH = h("wickra_chaikin_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CHAIKIN_VOLATILITY_WARMUP_PERIOD = h("wickra_chaikin_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CHAIKIN_VOLATILITY_IS_READY = h("wickra_chaikin_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CHAIKIN_VOLATILITY_RESET = h("wickra_chaikin_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHAIKIN_VOLATILITY_FREE = h("wickra_chaikin_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHOPPINESS_INDEX_NEW = h("wickra_choppiness_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CHOPPINESS_INDEX_UPDATE = h("wickra_choppiness_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CHOPPINESS_INDEX_BATCH = h("wickra_choppiness_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CHOPPINESS_INDEX_WARMUP_PERIOD = h("wickra_choppiness_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CHOPPINESS_INDEX_IS_READY = h("wickra_choppiness_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CHOPPINESS_INDEX_RESET = h("wickra_choppiness_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHOPPINESS_INDEX_FREE = h("wickra_choppiness_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CLOSE_VS_OPEN_NEW = h("wickra_close_vs_open_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CLOSE_VS_OPEN_UPDATE = h("wickra_close_vs_open_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CLOSE_VS_OPEN_BATCH = h("wickra_close_vs_open_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CLOSE_VS_OPEN_WARMUP_PERIOD = h("wickra_close_vs_open_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CLOSE_VS_OPEN_IS_READY = h("wickra_close_vs_open_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CLOSE_VS_OPEN_RESET = h("wickra_close_vs_open_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CLOSE_VS_OPEN_FREE = h("wickra_close_vs_open_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CLOSING_MARUBOZU_NEW = h("wickra_closing_marubozu_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CLOSING_MARUBOZU_UPDATE = h("wickra_closing_marubozu_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CLOSING_MARUBOZU_BATCH = h("wickra_closing_marubozu_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CLOSING_MARUBOZU_WARMUP_PERIOD = h("wickra_closing_marubozu_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CLOSING_MARUBOZU_IS_READY = h("wickra_closing_marubozu_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CLOSING_MARUBOZU_RESET = h("wickra_closing_marubozu_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CLOSING_MARUBOZU_FREE = h("wickra_closing_marubozu_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHAIKIN_MONEY_FLOW_NEW = h("wickra_chaikin_money_flow_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CHAIKIN_MONEY_FLOW_UPDATE = h("wickra_chaikin_money_flow_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CHAIKIN_MONEY_FLOW_BATCH = h("wickra_chaikin_money_flow_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CHAIKIN_MONEY_FLOW_WARMUP_PERIOD = h("wickra_chaikin_money_flow_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CHAIKIN_MONEY_FLOW_IS_READY = h("wickra_chaikin_money_flow_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CHAIKIN_MONEY_FLOW_RESET = h("wickra_chaikin_money_flow_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHAIKIN_MONEY_FLOW_FREE = h("wickra_chaikin_money_flow_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CONCEALING_BABY_SWALLOW_NEW = h("wickra_concealing_baby_swallow_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CONCEALING_BABY_SWALLOW_UPDATE = h("wickra_concealing_baby_swallow_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CONCEALING_BABY_SWALLOW_BATCH = h("wickra_concealing_baby_swallow_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CONCEALING_BABY_SWALLOW_WARMUP_PERIOD = h("wickra_concealing_baby_swallow_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CONCEALING_BABY_SWALLOW_IS_READY = h("wickra_concealing_baby_swallow_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CONCEALING_BABY_SWALLOW_RESET = h("wickra_concealing_baby_swallow_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CONCEALING_BABY_SWALLOW_FREE = h("wickra_concealing_baby_swallow_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COUNTERATTACK_NEW = h("wickra_counterattack_new", FunctionDescriptor.of(ADDRESS)); WICKRA_COUNTERATTACK_UPDATE = h("wickra_counterattack_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_COUNTERATTACK_BATCH = h("wickra_counterattack_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_COUNTERATTACK_WARMUP_PERIOD = h("wickra_counterattack_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_COUNTERATTACK_IS_READY = h("wickra_counterattack_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_COUNTERATTACK_RESET = h("wickra_counterattack_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COUNTERATTACK_FREE = h("wickra_counterattack_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CRAB_NEW = h("wickra_crab_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CRAB_UPDATE = h("wickra_crab_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CRAB_BATCH = h("wickra_crab_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CRAB_WARMUP_PERIOD = h("wickra_crab_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CRAB_IS_READY = h("wickra_crab_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CRAB_RESET = h("wickra_crab_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CRAB_FREE = h("wickra_crab_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CUP_AND_HANDLE_NEW = h("wickra_cup_and_handle_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CUP_AND_HANDLE_UPDATE = h("wickra_cup_and_handle_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CUP_AND_HANDLE_BATCH = h("wickra_cup_and_handle_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CUP_AND_HANDLE_WARMUP_PERIOD = h("wickra_cup_and_handle_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CUP_AND_HANDLE_IS_READY = h("wickra_cup_and_handle_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CUP_AND_HANDLE_RESET = h("wickra_cup_and_handle_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CUP_AND_HANDLE_FREE = h("wickra_cup_and_handle_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CYPHER_NEW = h("wickra_cypher_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CYPHER_UPDATE = h("wickra_cypher_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CYPHER_BATCH = h("wickra_cypher_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_CYPHER_WARMUP_PERIOD = h("wickra_cypher_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CYPHER_IS_READY = h("wickra_cypher_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CYPHER_RESET = h("wickra_cypher_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CYPHER_FREE = h("wickra_cypher_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEMAND_INDEX_NEW = h("wickra_demand_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DEMAND_INDEX_UPDATE = h("wickra_demand_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DEMAND_INDEX_BATCH = h("wickra_demand_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DEMAND_INDEX_WARMUP_PERIOD = h("wickra_demand_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DEMAND_INDEX_IS_READY = h("wickra_demand_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init12() { WICKRA_DEMAND_INDEX_RESET = h("wickra_demand_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEMAND_INDEX_FREE = h("wickra_demand_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOJI_NEW = h("wickra_doji_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DOJI_UPDATE = h("wickra_doji_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DOJI_BATCH = h("wickra_doji_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DOJI_WARMUP_PERIOD = h("wickra_doji_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DOJI_IS_READY = h("wickra_doji_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DOJI_RESET = h("wickra_doji_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOJI_FREE = h("wickra_doji_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOJI_STAR_NEW = h("wickra_doji_star_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DOJI_STAR_UPDATE = h("wickra_doji_star_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DOJI_STAR_BATCH = h("wickra_doji_star_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DOJI_STAR_WARMUP_PERIOD = h("wickra_doji_star_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DOJI_STAR_IS_READY = h("wickra_doji_star_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DOJI_STAR_RESET = h("wickra_doji_star_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOJI_STAR_FREE = h("wickra_doji_star_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOUBLE_TOP_BOTTOM_NEW = h("wickra_double_top_bottom_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DOUBLE_TOP_BOTTOM_UPDATE = h("wickra_double_top_bottom_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DOUBLE_TOP_BOTTOM_BATCH = h("wickra_double_top_bottom_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DOUBLE_TOP_BOTTOM_WARMUP_PERIOD = h("wickra_double_top_bottom_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DOUBLE_TOP_BOTTOM_IS_READY = h("wickra_double_top_bottom_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DOUBLE_TOP_BOTTOM_RESET = h("wickra_double_top_bottom_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOUBLE_TOP_BOTTOM_FREE = h("wickra_double_top_bottom_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOWNSIDE_GAP_THREE_METHODS_NEW = h("wickra_downside_gap_three_methods_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DOWNSIDE_GAP_THREE_METHODS_UPDATE = h("wickra_downside_gap_three_methods_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DOWNSIDE_GAP_THREE_METHODS_BATCH = h("wickra_downside_gap_three_methods_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DOWNSIDE_GAP_THREE_METHODS_WARMUP_PERIOD = h("wickra_downside_gap_three_methods_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DOWNSIDE_GAP_THREE_METHODS_IS_READY = h("wickra_downside_gap_three_methods_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DOWNSIDE_GAP_THREE_METHODS_RESET = h("wickra_downside_gap_three_methods_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOWNSIDE_GAP_THREE_METHODS_FREE = h("wickra_downside_gap_three_methods_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DRAGONFLY_DOJI_NEW = h("wickra_dragonfly_doji_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DRAGONFLY_DOJI_UPDATE = h("wickra_dragonfly_doji_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DRAGONFLY_DOJI_BATCH = h("wickra_dragonfly_doji_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DRAGONFLY_DOJI_WARMUP_PERIOD = h("wickra_dragonfly_doji_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DRAGONFLY_DOJI_IS_READY = h("wickra_dragonfly_doji_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DRAGONFLY_DOJI_RESET = h("wickra_dragonfly_doji_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DRAGONFLY_DOJI_FREE = h("wickra_dragonfly_doji_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DUMPLING_TOP_NEW = h("wickra_dumpling_top_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DUMPLING_TOP_UPDATE = h("wickra_dumpling_top_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DUMPLING_TOP_BATCH = h("wickra_dumpling_top_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DUMPLING_TOP_WARMUP_PERIOD = h("wickra_dumpling_top_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DUMPLING_TOP_IS_READY = h("wickra_dumpling_top_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DUMPLING_TOP_RESET = h("wickra_dumpling_top_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DUMPLING_TOP_FREE = h("wickra_dumpling_top_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DX_NEW = h("wickra_dx_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DX_UPDATE = h("wickra_dx_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_DX_BATCH = h("wickra_dx_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DX_WARMUP_PERIOD = h("wickra_dx_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DX_IS_READY = h("wickra_dx_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DX_RESET = h("wickra_dx_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DX_FREE = h("wickra_dx_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EASE_OF_MOVEMENT_NEW = h("wickra_ease_of_movement_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EASE_OF_MOVEMENT_UPDATE = h("wickra_ease_of_movement_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_EASE_OF_MOVEMENT_BATCH = h("wickra_ease_of_movement_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EASE_OF_MOVEMENT_WARMUP_PERIOD = h("wickra_ease_of_movement_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EASE_OF_MOVEMENT_IS_READY = h("wickra_ease_of_movement_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EASE_OF_MOVEMENT_RESET = h("wickra_ease_of_movement_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EASE_OF_MOVEMENT_FREE = h("wickra_ease_of_movement_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ENGULFING_NEW = h("wickra_engulfing_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ENGULFING_UPDATE = h("wickra_engulfing_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ENGULFING_BATCH = h("wickra_engulfing_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ENGULFING_WARMUP_PERIOD = h("wickra_engulfing_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ENGULFING_IS_READY = h("wickra_engulfing_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ENGULFING_RESET = h("wickra_engulfing_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ENGULFING_FREE = h("wickra_engulfing_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EVENING_DOJI_STAR_NEW = h("wickra_evening_doji_star_new", FunctionDescriptor.of(ADDRESS)); WICKRA_EVENING_DOJI_STAR_UPDATE = h("wickra_evening_doji_star_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_EVENING_DOJI_STAR_BATCH = h("wickra_evening_doji_star_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EVENING_DOJI_STAR_WARMUP_PERIOD = h("wickra_evening_doji_star_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EVENING_DOJI_STAR_IS_READY = h("wickra_evening_doji_star_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EVENING_DOJI_STAR_RESET = h("wickra_evening_doji_star_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EVENING_DOJI_STAR_FREE = h("wickra_evening_doji_star_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init9() { WICKRA_EVWMA_NEW = h("wickra_evwma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EVWMA_UPDATE = h("wickra_evwma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_EVWMA_BATCH = h("wickra_evwma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_EVWMA_WARMUP_PERIOD = h("wickra_evwma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EVWMA_IS_READY = h("wickra_evwma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EVWMA_RESET = h("wickra_evwma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EVWMA_FREE = h("wickra_evwma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FALLING_THREE_METHODS_NEW = h("wickra_falling_three_methods_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FALLING_THREE_METHODS_UPDATE = h("wickra_falling_three_methods_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_FALLING_THREE_METHODS_BATCH = h("wickra_falling_three_methods_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FALLING_THREE_METHODS_WARMUP_PERIOD = h("wickra_falling_three_methods_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FALLING_THREE_METHODS_IS_READY = h("wickra_falling_three_methods_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FALLING_THREE_METHODS_RESET = h("wickra_falling_three_methods_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FALLING_THREE_METHODS_FREE = h("wickra_falling_three_methods_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FLAG_PENNANT_NEW = h("wickra_flag_pennant_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FLAG_PENNANT_UPDATE = h("wickra_flag_pennant_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_FLAG_PENNANT_BATCH = h("wickra_flag_pennant_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FLAG_PENNANT_WARMUP_PERIOD = h("wickra_flag_pennant_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FLAG_PENNANT_IS_READY = h("wickra_flag_pennant_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FLAG_PENNANT_RESET = h("wickra_flag_pennant_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FLAG_PENNANT_FREE = h("wickra_flag_pennant_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FORCE_INDEX_NEW = h("wickra_force_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FORCE_INDEX_UPDATE = h("wickra_force_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_FORCE_INDEX_BATCH = h("wickra_force_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FORCE_INDEX_WARMUP_PERIOD = h("wickra_force_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FORCE_INDEX_IS_READY = h("wickra_force_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FORCE_INDEX_RESET = h("wickra_force_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FORCE_INDEX_FREE = h("wickra_force_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FRY_PAN_BOTTOM_NEW = h("wickra_fry_pan_bottom_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FRY_PAN_BOTTOM_UPDATE = h("wickra_fry_pan_bottom_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_FRY_PAN_BOTTOM_BATCH = h("wickra_fry_pan_bottom_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_FRY_PAN_BOTTOM_WARMUP_PERIOD = h("wickra_fry_pan_bottom_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FRY_PAN_BOTTOM_IS_READY = h("wickra_fry_pan_bottom_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FRY_PAN_BOTTOM_RESET = h("wickra_fry_pan_bottom_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FRY_PAN_BOTTOM_FREE = h("wickra_fry_pan_bottom_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GAP_SIDE_BY_SIDE_WHITE_NEW = h("wickra_gap_side_by_side_white_new", FunctionDescriptor.of(ADDRESS)); WICKRA_GAP_SIDE_BY_SIDE_WHITE_UPDATE = h("wickra_gap_side_by_side_white_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_GAP_SIDE_BY_SIDE_WHITE_BATCH = h("wickra_gap_side_by_side_white_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GAP_SIDE_BY_SIDE_WHITE_WARMUP_PERIOD = h("wickra_gap_side_by_side_white_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GAP_SIDE_BY_SIDE_WHITE_IS_READY = h("wickra_gap_side_by_side_white_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GAP_SIDE_BY_SIDE_WHITE_RESET = h("wickra_gap_side_by_side_white_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GAP_SIDE_BY_SIDE_WHITE_FREE = h("wickra_gap_side_by_side_white_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GARMAN_KLASS_VOLATILITY_NEW = h("wickra_garman_klass_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_GARMAN_KLASS_VOLATILITY_UPDATE = h("wickra_garman_klass_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_GARMAN_KLASS_VOLATILITY_BATCH = h("wickra_garman_klass_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GARMAN_KLASS_VOLATILITY_WARMUP_PERIOD = h("wickra_garman_klass_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GARMAN_KLASS_VOLATILITY_IS_READY = h("wickra_garman_klass_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GARMAN_KLASS_VOLATILITY_RESET = h("wickra_garman_klass_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); + } + + private static void init13() { WICKRA_GARMAN_KLASS_VOLATILITY_FREE = h("wickra_garman_klass_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GARTLEY_NEW = h("wickra_gartley_new", FunctionDescriptor.of(ADDRESS)); WICKRA_GARTLEY_UPDATE = h("wickra_gartley_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_GARTLEY_BATCH = h("wickra_gartley_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GARTLEY_WARMUP_PERIOD = h("wickra_gartley_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GARTLEY_IS_READY = h("wickra_gartley_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GARTLEY_RESET = h("wickra_gartley_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GARTLEY_FREE = h("wickra_gartley_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GRAVESTONE_DOJI_NEW = h("wickra_gravestone_doji_new", FunctionDescriptor.of(ADDRESS)); WICKRA_GRAVESTONE_DOJI_UPDATE = h("wickra_gravestone_doji_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_GRAVESTONE_DOJI_BATCH = h("wickra_gravestone_doji_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_GRAVESTONE_DOJI_WARMUP_PERIOD = h("wickra_gravestone_doji_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GRAVESTONE_DOJI_IS_READY = h("wickra_gravestone_doji_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GRAVESTONE_DOJI_RESET = h("wickra_gravestone_doji_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GRAVESTONE_DOJI_FREE = h("wickra_gravestone_doji_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HAMMER_NEW = h("wickra_hammer_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HAMMER_UPDATE = h("wickra_hammer_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HAMMER_BATCH = h("wickra_hammer_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HAMMER_WARMUP_PERIOD = h("wickra_hammer_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HAMMER_IS_READY = h("wickra_hammer_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HAMMER_RESET = h("wickra_hammer_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HAMMER_FREE = h("wickra_hammer_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HANGING_MAN_NEW = h("wickra_hanging_man_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HANGING_MAN_UPDATE = h("wickra_hanging_man_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HANGING_MAN_BATCH = h("wickra_hanging_man_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HANGING_MAN_WARMUP_PERIOD = h("wickra_hanging_man_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HANGING_MAN_IS_READY = h("wickra_hanging_man_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HANGING_MAN_RESET = h("wickra_hanging_man_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HANGING_MAN_FREE = h("wickra_hanging_man_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HARAMI_NEW = h("wickra_harami_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HARAMI_UPDATE = h("wickra_harami_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HARAMI_BATCH = h("wickra_harami_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HARAMI_WARMUP_PERIOD = h("wickra_harami_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HARAMI_IS_READY = h("wickra_harami_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HARAMI_RESET = h("wickra_harami_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HARAMI_FREE = h("wickra_harami_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HARAMI_CROSS_NEW = h("wickra_harami_cross_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HARAMI_CROSS_UPDATE = h("wickra_harami_cross_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HARAMI_CROSS_BATCH = h("wickra_harami_cross_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HARAMI_CROSS_WARMUP_PERIOD = h("wickra_harami_cross_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HARAMI_CROSS_IS_READY = h("wickra_harami_cross_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HARAMI_CROSS_RESET = h("wickra_harami_cross_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HARAMI_CROSS_FREE = h("wickra_harami_cross_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HEAD_AND_SHOULDERS_NEW = h("wickra_head_and_shoulders_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HEAD_AND_SHOULDERS_UPDATE = h("wickra_head_and_shoulders_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HEAD_AND_SHOULDERS_BATCH = h("wickra_head_and_shoulders_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HEAD_AND_SHOULDERS_WARMUP_PERIOD = h("wickra_head_and_shoulders_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HEAD_AND_SHOULDERS_IS_READY = h("wickra_head_and_shoulders_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HEAD_AND_SHOULDERS_RESET = h("wickra_head_and_shoulders_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HEAD_AND_SHOULDERS_FREE = h("wickra_head_and_shoulders_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HEIKIN_ASHI_OSCILLATOR_NEW = h("wickra_heikin_ashi_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_HEIKIN_ASHI_OSCILLATOR_UPDATE = h("wickra_heikin_ashi_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HEIKIN_ASHI_OSCILLATOR_BATCH = h("wickra_heikin_ashi_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HEIKIN_ASHI_OSCILLATOR_WARMUP_PERIOD = h("wickra_heikin_ashi_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HEIKIN_ASHI_OSCILLATOR_IS_READY = h("wickra_heikin_ashi_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HEIKIN_ASHI_OSCILLATOR_RESET = h("wickra_heikin_ashi_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HEIKIN_ASHI_OSCILLATOR_FREE = h("wickra_heikin_ashi_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_LOW_RANGE_NEW = h("wickra_high_low_range_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HIGH_LOW_RANGE_UPDATE = h("wickra_high_low_range_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HIGH_LOW_RANGE_BATCH = h("wickra_high_low_range_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HIGH_LOW_RANGE_WARMUP_PERIOD = h("wickra_high_low_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIGH_LOW_RANGE_IS_READY = h("wickra_high_low_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIGH_LOW_RANGE_RESET = h("wickra_high_low_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_LOW_RANGE_FREE = h("wickra_high_low_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_WAVE_NEW = h("wickra_high_wave_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HIGH_WAVE_UPDATE = h("wickra_high_wave_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HIGH_WAVE_BATCH = h("wickra_high_wave_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HIGH_WAVE_WARMUP_PERIOD = h("wickra_high_wave_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIGH_WAVE_IS_READY = h("wickra_high_wave_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIGH_WAVE_RESET = h("wickra_high_wave_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_WAVE_FREE = h("wickra_high_wave_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIKKAKE_NEW = h("wickra_hikkake_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HIKKAKE_UPDATE = h("wickra_hikkake_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HIKKAKE_BATCH = h("wickra_hikkake_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HIKKAKE_WARMUP_PERIOD = h("wickra_hikkake_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIKKAKE_IS_READY = h("wickra_hikkake_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIKKAKE_RESET = h("wickra_hikkake_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIKKAKE_FREE = h("wickra_hikkake_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIKKAKE_MODIFIED_NEW = h("wickra_hikkake_modified_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HIKKAKE_MODIFIED_UPDATE = h("wickra_hikkake_modified_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HIKKAKE_MODIFIED_BATCH = h("wickra_hikkake_modified_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HIKKAKE_MODIFIED_WARMUP_PERIOD = h("wickra_hikkake_modified_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIKKAKE_MODIFIED_IS_READY = h("wickra_hikkake_modified_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIKKAKE_MODIFIED_RESET = h("wickra_hikkake_modified_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIKKAKE_MODIFIED_FREE = h("wickra_hikkake_modified_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HI_LO_ACTIVATOR_NEW = h("wickra_hi_lo_activator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_HI_LO_ACTIVATOR_UPDATE = h("wickra_hi_lo_activator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HI_LO_ACTIVATOR_BATCH = h("wickra_hi_lo_activator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HI_LO_ACTIVATOR_WARMUP_PERIOD = h("wickra_hi_lo_activator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HI_LO_ACTIVATOR_IS_READY = h("wickra_hi_lo_activator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HI_LO_ACTIVATOR_RESET = h("wickra_hi_lo_activator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HI_LO_ACTIVATOR_FREE = h("wickra_hi_lo_activator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HOMING_PIGEON_NEW = h("wickra_homing_pigeon_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HOMING_PIGEON_UPDATE = h("wickra_homing_pigeon_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_HOMING_PIGEON_BATCH = h("wickra_homing_pigeon_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_HOMING_PIGEON_WARMUP_PERIOD = h("wickra_homing_pigeon_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HOMING_PIGEON_IS_READY = h("wickra_homing_pigeon_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HOMING_PIGEON_RESET = h("wickra_homing_pigeon_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HOMING_PIGEON_FREE = h("wickra_homing_pigeon_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_IDENTICAL_THREE_CROWS_NEW = h("wickra_identical_three_crows_new", FunctionDescriptor.of(ADDRESS)); WICKRA_IDENTICAL_THREE_CROWS_UPDATE = h("wickra_identical_three_crows_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_IDENTICAL_THREE_CROWS_BATCH = h("wickra_identical_three_crows_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_IDENTICAL_THREE_CROWS_WARMUP_PERIOD = h("wickra_identical_three_crows_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_IDENTICAL_THREE_CROWS_IS_READY = h("wickra_identical_three_crows_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_IDENTICAL_THREE_CROWS_RESET = h("wickra_identical_three_crows_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_IDENTICAL_THREE_CROWS_FREE = h("wickra_identical_three_crows_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_IN_NECK_NEW = h("wickra_in_neck_new", FunctionDescriptor.of(ADDRESS)); WICKRA_IN_NECK_UPDATE = h("wickra_in_neck_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_IN_NECK_BATCH = h("wickra_in_neck_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_IN_NECK_WARMUP_PERIOD = h("wickra_in_neck_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_IN_NECK_IS_READY = h("wickra_in_neck_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_IN_NECK_RESET = h("wickra_in_neck_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_IN_NECK_FREE = h("wickra_in_neck_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INERTIA_NEW = h("wickra_inertia_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_INERTIA_UPDATE = h("wickra_inertia_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_INERTIA_BATCH = h("wickra_inertia_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INERTIA_WARMUP_PERIOD = h("wickra_inertia_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INERTIA_IS_READY = h("wickra_inertia_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INERTIA_RESET = h("wickra_inertia_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INERTIA_FREE = h("wickra_inertia_free", FunctionDescriptor.ofVoid(ADDRESS)); } - private static void init10() { + private static void init14() { WICKRA_INTRADAY_INTENSITY_NEW = h("wickra_intraday_intensity_new", FunctionDescriptor.of(ADDRESS)); WICKRA_INTRADAY_INTENSITY_UPDATE = h("wickra_intraday_intensity_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_INTRADAY_INTENSITY_BATCH = h("wickra_intraday_intensity_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INTRADAY_INTENSITY_WARMUP_PERIOD = h("wickra_intraday_intensity_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INTRADAY_INTENSITY_IS_READY = h("wickra_intraday_intensity_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INTRADAY_INTENSITY_RESET = h("wickra_intraday_intensity_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INTRADAY_INTENSITY_FREE = h("wickra_intraday_intensity_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INTRADAY_MOMENTUM_INDEX_NEW = h("wickra_intraday_momentum_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_INTRADAY_MOMENTUM_INDEX_UPDATE = h("wickra_intraday_momentum_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_INTRADAY_MOMENTUM_INDEX_BATCH = h("wickra_intraday_momentum_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INTRADAY_MOMENTUM_INDEX_WARMUP_PERIOD = h("wickra_intraday_momentum_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INTRADAY_MOMENTUM_INDEX_IS_READY = h("wickra_intraday_momentum_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INTRADAY_MOMENTUM_INDEX_RESET = h("wickra_intraday_momentum_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INTRADAY_MOMENTUM_INDEX_FREE = h("wickra_intraday_momentum_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INVERTED_HAMMER_NEW = h("wickra_inverted_hammer_new", FunctionDescriptor.of(ADDRESS)); WICKRA_INVERTED_HAMMER_UPDATE = h("wickra_inverted_hammer_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_INVERTED_HAMMER_BATCH = h("wickra_inverted_hammer_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_INVERTED_HAMMER_WARMUP_PERIOD = h("wickra_inverted_hammer_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INVERTED_HAMMER_IS_READY = h("wickra_inverted_hammer_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INVERTED_HAMMER_RESET = h("wickra_inverted_hammer_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INVERTED_HAMMER_FREE = h("wickra_inverted_hammer_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KICKING_NEW = h("wickra_kicking_new", FunctionDescriptor.of(ADDRESS)); WICKRA_KICKING_UPDATE = h("wickra_kicking_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_KICKING_BATCH = h("wickra_kicking_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KICKING_WARMUP_PERIOD = h("wickra_kicking_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KICKING_IS_READY = h("wickra_kicking_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KICKING_RESET = h("wickra_kicking_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KICKING_FREE = h("wickra_kicking_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KICKING_BY_LENGTH_NEW = h("wickra_kicking_by_length_new", FunctionDescriptor.of(ADDRESS)); WICKRA_KICKING_BY_LENGTH_UPDATE = h("wickra_kicking_by_length_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_KICKING_BY_LENGTH_BATCH = h("wickra_kicking_by_length_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KICKING_BY_LENGTH_WARMUP_PERIOD = h("wickra_kicking_by_length_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KICKING_BY_LENGTH_IS_READY = h("wickra_kicking_by_length_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KICKING_BY_LENGTH_RESET = h("wickra_kicking_by_length_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KICKING_BY_LENGTH_FREE = h("wickra_kicking_by_length_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KVO_NEW = h("wickra_kvo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_KVO_UPDATE = h("wickra_kvo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_KVO_BATCH = h("wickra_kvo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_KVO_WARMUP_PERIOD = h("wickra_kvo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KVO_IS_READY = h("wickra_kvo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KVO_RESET = h("wickra_kvo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KVO_FREE = h("wickra_kvo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LADDER_BOTTOM_NEW = h("wickra_ladder_bottom_new", FunctionDescriptor.of(ADDRESS)); WICKRA_LADDER_BOTTOM_UPDATE = h("wickra_ladder_bottom_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_LADDER_BOTTOM_BATCH = h("wickra_ladder_bottom_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LADDER_BOTTOM_WARMUP_PERIOD = h("wickra_ladder_bottom_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LADDER_BOTTOM_IS_READY = h("wickra_ladder_bottom_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LADDER_BOTTOM_RESET = h("wickra_ladder_bottom_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LADDER_BOTTOM_FREE = h("wickra_ladder_bottom_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LONG_LEGGED_DOJI_NEW = h("wickra_long_legged_doji_new", FunctionDescriptor.of(ADDRESS)); WICKRA_LONG_LEGGED_DOJI_UPDATE = h("wickra_long_legged_doji_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_LONG_LEGGED_DOJI_BATCH = h("wickra_long_legged_doji_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LONG_LEGGED_DOJI_WARMUP_PERIOD = h("wickra_long_legged_doji_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LONG_LEGGED_DOJI_IS_READY = h("wickra_long_legged_doji_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LONG_LEGGED_DOJI_RESET = h("wickra_long_legged_doji_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LONG_LEGGED_DOJI_FREE = h("wickra_long_legged_doji_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LONG_LINE_NEW = h("wickra_long_line_new", FunctionDescriptor.of(ADDRESS)); WICKRA_LONG_LINE_UPDATE = h("wickra_long_line_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_LONG_LINE_BATCH = h("wickra_long_line_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_LONG_LINE_WARMUP_PERIOD = h("wickra_long_line_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LONG_LINE_IS_READY = h("wickra_long_line_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LONG_LINE_RESET = h("wickra_long_line_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LONG_LINE_FREE = h("wickra_long_line_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MARKET_FACILITATION_INDEX_NEW = h("wickra_market_facilitation_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MARKET_FACILITATION_INDEX_UPDATE = h("wickra_market_facilitation_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MARKET_FACILITATION_INDEX_BATCH = h("wickra_market_facilitation_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MARKET_FACILITATION_INDEX_WARMUP_PERIOD = h("wickra_market_facilitation_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MARKET_FACILITATION_INDEX_IS_READY = h("wickra_market_facilitation_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MARKET_FACILITATION_INDEX_RESET = h("wickra_market_facilitation_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MARKET_FACILITATION_INDEX_FREE = h("wickra_market_facilitation_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MARUBOZU_NEW = h("wickra_marubozu_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MARUBOZU_UPDATE = h("wickra_marubozu_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MARUBOZU_BATCH = h("wickra_marubozu_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MARUBOZU_WARMUP_PERIOD = h("wickra_marubozu_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MARUBOZU_IS_READY = h("wickra_marubozu_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MARUBOZU_RESET = h("wickra_marubozu_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MARUBOZU_FREE = h("wickra_marubozu_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MASS_INDEX_NEW = h("wickra_mass_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_MASS_INDEX_UPDATE = h("wickra_mass_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MASS_INDEX_BATCH = h("wickra_mass_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MASS_INDEX_WARMUP_PERIOD = h("wickra_mass_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MASS_INDEX_IS_READY = h("wickra_mass_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MASS_INDEX_RESET = h("wickra_mass_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MASS_INDEX_FREE = h("wickra_mass_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MAT_HOLD_NEW = h("wickra_mat_hold_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MAT_HOLD_UPDATE = h("wickra_mat_hold_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MAT_HOLD_BATCH = h("wickra_mat_hold_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MAT_HOLD_WARMUP_PERIOD = h("wickra_mat_hold_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MAT_HOLD_IS_READY = h("wickra_mat_hold_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MAT_HOLD_RESET = h("wickra_mat_hold_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MAT_HOLD_FREE = h("wickra_mat_hold_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MATCHING_LOW_NEW = h("wickra_matching_low_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MATCHING_LOW_UPDATE = h("wickra_matching_low_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MATCHING_LOW_BATCH = h("wickra_matching_low_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MATCHING_LOW_WARMUP_PERIOD = h("wickra_matching_low_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MATCHING_LOW_IS_READY = h("wickra_matching_low_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MATCHING_LOW_RESET = h("wickra_matching_low_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MATCHING_LOW_FREE = h("wickra_matching_low_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_PRICE_NEW = h("wickra_median_price_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MEDIAN_PRICE_UPDATE = h("wickra_median_price_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MEDIAN_PRICE_BATCH = h("wickra_median_price_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MEDIAN_PRICE_WARMUP_PERIOD = h("wickra_median_price_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MEDIAN_PRICE_IS_READY = h("wickra_median_price_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MEDIAN_PRICE_RESET = h("wickra_median_price_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_PRICE_FREE = h("wickra_median_price_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MFI_NEW = h("wickra_mfi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MFI_UPDATE = h("wickra_mfi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MFI_BATCH = h("wickra_mfi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MFI_WARMUP_PERIOD = h("wickra_mfi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MFI_IS_READY = h("wickra_mfi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MFI_RESET = h("wickra_mfi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MFI_FREE = h("wickra_mfi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MID_PRICE_NEW = h("wickra_mid_price_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MID_PRICE_UPDATE = h("wickra_mid_price_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MID_PRICE_BATCH = h("wickra_mid_price_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MID_PRICE_WARMUP_PERIOD = h("wickra_mid_price_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MID_PRICE_IS_READY = h("wickra_mid_price_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MID_PRICE_RESET = h("wickra_mid_price_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MID_PRICE_FREE = h("wickra_mid_price_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MINUS_DI_NEW = h("wickra_minus_di_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); + } + + private static void init15() { WICKRA_MINUS_DI_UPDATE = h("wickra_minus_di_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MINUS_DI_BATCH = h("wickra_minus_di_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MINUS_DI_WARMUP_PERIOD = h("wickra_minus_di_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MINUS_DI_IS_READY = h("wickra_minus_di_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MINUS_DI_RESET = h("wickra_minus_di_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MINUS_DI_FREE = h("wickra_minus_di_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MINUS_DM_NEW = h("wickra_minus_dm_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MINUS_DM_UPDATE = h("wickra_minus_dm_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MINUS_DM_BATCH = h("wickra_minus_dm_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MINUS_DM_WARMUP_PERIOD = h("wickra_minus_dm_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MINUS_DM_IS_READY = h("wickra_minus_dm_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MINUS_DM_RESET = h("wickra_minus_dm_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MINUS_DM_FREE = h("wickra_minus_dm_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MORNING_DOJI_STAR_NEW = h("wickra_morning_doji_star_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MORNING_DOJI_STAR_UPDATE = h("wickra_morning_doji_star_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MORNING_DOJI_STAR_BATCH = h("wickra_morning_doji_star_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MORNING_DOJI_STAR_WARMUP_PERIOD = h("wickra_morning_doji_star_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MORNING_DOJI_STAR_IS_READY = h("wickra_morning_doji_star_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MORNING_DOJI_STAR_RESET = h("wickra_morning_doji_star_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MORNING_DOJI_STAR_FREE = h("wickra_morning_doji_star_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MORNING_EVENING_STAR_NEW = h("wickra_morning_evening_star_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MORNING_EVENING_STAR_UPDATE = h("wickra_morning_evening_star_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_MORNING_EVENING_STAR_BATCH = h("wickra_morning_evening_star_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MORNING_EVENING_STAR_WARMUP_PERIOD = h("wickra_morning_evening_star_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MORNING_EVENING_STAR_IS_READY = h("wickra_morning_evening_star_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MORNING_EVENING_STAR_RESET = h("wickra_morning_evening_star_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MORNING_EVENING_STAR_FREE = h("wickra_morning_evening_star_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NAKED_POC_NEW = h("wickra_naked_poc_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_NAKED_POC_UPDATE = h("wickra_naked_poc_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_NAKED_POC_BATCH = h("wickra_naked_poc_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_NAKED_POC_WARMUP_PERIOD = h("wickra_naked_poc_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_NAKED_POC_IS_READY = h("wickra_naked_poc_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_NAKED_POC_RESET = h("wickra_naked_poc_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NAKED_POC_FREE = h("wickra_naked_poc_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NATR_NEW = h("wickra_natr_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_NATR_UPDATE = h("wickra_natr_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_NATR_BATCH = h("wickra_natr_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_NATR_WARMUP_PERIOD = h("wickra_natr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_NATR_IS_READY = h("wickra_natr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_NATR_RESET = h("wickra_natr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NATR_FREE = h("wickra_natr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NEW_PRICE_LINES_NEW = h("wickra_new_price_lines_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_NEW_PRICE_LINES_UPDATE = h("wickra_new_price_lines_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_NEW_PRICE_LINES_BATCH = h("wickra_new_price_lines_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_NEW_PRICE_LINES_WARMUP_PERIOD = h("wickra_new_price_lines_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_NEW_PRICE_LINES_IS_READY = h("wickra_new_price_lines_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_NEW_PRICE_LINES_RESET = h("wickra_new_price_lines_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NEW_PRICE_LINES_FREE = h("wickra_new_price_lines_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init11() { WICKRA_NVI_NEW = h("wickra_nvi_new", FunctionDescriptor.of(ADDRESS)); WICKRA_NVI_UPDATE = h("wickra_nvi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_NVI_BATCH = h("wickra_nvi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_NVI_WARMUP_PERIOD = h("wickra_nvi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_NVI_IS_READY = h("wickra_nvi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_NVI_RESET = h("wickra_nvi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NVI_FREE = h("wickra_nvi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OBV_NEW = h("wickra_obv_new", FunctionDescriptor.of(ADDRESS)); WICKRA_OBV_UPDATE = h("wickra_obv_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_OBV_BATCH = h("wickra_obv_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_OBV_WARMUP_PERIOD = h("wickra_obv_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OBV_IS_READY = h("wickra_obv_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OBV_RESET = h("wickra_obv_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OBV_FREE = h("wickra_obv_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ON_NECK_NEW = h("wickra_on_neck_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ON_NECK_UPDATE = h("wickra_on_neck_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ON_NECK_BATCH = h("wickra_on_neck_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ON_NECK_WARMUP_PERIOD = h("wickra_on_neck_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ON_NECK_IS_READY = h("wickra_on_neck_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ON_NECK_RESET = h("wickra_on_neck_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ON_NECK_FREE = h("wickra_on_neck_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPENING_MARUBOZU_NEW = h("wickra_opening_marubozu_new", FunctionDescriptor.of(ADDRESS)); WICKRA_OPENING_MARUBOZU_UPDATE = h("wickra_opening_marubozu_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_OPENING_MARUBOZU_BATCH = h("wickra_opening_marubozu_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_OPENING_MARUBOZU_WARMUP_PERIOD = h("wickra_opening_marubozu_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OPENING_MARUBOZU_IS_READY = h("wickra_opening_marubozu_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OPENING_MARUBOZU_RESET = h("wickra_opening_marubozu_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPENING_MARUBOZU_FREE = h("wickra_opening_marubozu_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OVERNIGHT_GAP_NEW = h("wickra_overnight_gap_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_OVERNIGHT_GAP_UPDATE = h("wickra_overnight_gap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_OVERNIGHT_GAP_BATCH = h("wickra_overnight_gap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_OVERNIGHT_GAP_WARMUP_PERIOD = h("wickra_overnight_gap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OVERNIGHT_GAP_IS_READY = h("wickra_overnight_gap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OVERNIGHT_GAP_RESET = h("wickra_overnight_gap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OVERNIGHT_GAP_FREE = h("wickra_overnight_gap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PARKINSON_VOLATILITY_NEW = h("wickra_parkinson_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_PARKINSON_VOLATILITY_UPDATE = h("wickra_parkinson_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PARKINSON_VOLATILITY_BATCH = h("wickra_parkinson_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PARKINSON_VOLATILITY_WARMUP_PERIOD = h("wickra_parkinson_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PARKINSON_VOLATILITY_IS_READY = h("wickra_parkinson_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PARKINSON_VOLATILITY_RESET = h("wickra_parkinson_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PARKINSON_VOLATILITY_FREE = h("wickra_parkinson_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PGO_NEW = h("wickra_pgo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PGO_UPDATE = h("wickra_pgo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PGO_BATCH = h("wickra_pgo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PGO_WARMUP_PERIOD = h("wickra_pgo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PGO_IS_READY = h("wickra_pgo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PGO_RESET = h("wickra_pgo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PGO_FREE = h("wickra_pgo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PIERCING_DARK_CLOUD_NEW = h("wickra_piercing_dark_cloud_new", FunctionDescriptor.of(ADDRESS)); WICKRA_PIERCING_DARK_CLOUD_UPDATE = h("wickra_piercing_dark_cloud_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PIERCING_DARK_CLOUD_BATCH = h("wickra_piercing_dark_cloud_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PIERCING_DARK_CLOUD_WARMUP_PERIOD = h("wickra_piercing_dark_cloud_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PIERCING_DARK_CLOUD_IS_READY = h("wickra_piercing_dark_cloud_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PIERCING_DARK_CLOUD_RESET = h("wickra_piercing_dark_cloud_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PIERCING_DARK_CLOUD_FREE = h("wickra_piercing_dark_cloud_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PIVOT_REVERSAL_NEW = h("wickra_pivot_reversal_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_PIVOT_REVERSAL_UPDATE = h("wickra_pivot_reversal_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PIVOT_REVERSAL_BATCH = h("wickra_pivot_reversal_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PIVOT_REVERSAL_WARMUP_PERIOD = h("wickra_pivot_reversal_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PIVOT_REVERSAL_IS_READY = h("wickra_pivot_reversal_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PIVOT_REVERSAL_RESET = h("wickra_pivot_reversal_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PIVOT_REVERSAL_FREE = h("wickra_pivot_reversal_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PLUS_DI_NEW = h("wickra_plus_di_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PLUS_DI_UPDATE = h("wickra_plus_di_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PLUS_DI_BATCH = h("wickra_plus_di_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PLUS_DI_WARMUP_PERIOD = h("wickra_plus_di_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PLUS_DI_IS_READY = h("wickra_plus_di_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PLUS_DI_RESET = h("wickra_plus_di_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PLUS_DI_FREE = h("wickra_plus_di_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PLUS_DM_NEW = h("wickra_plus_dm_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PLUS_DM_UPDATE = h("wickra_plus_dm_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + } + + private static void init16() { WICKRA_PLUS_DM_BATCH = h("wickra_plus_dm_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PLUS_DM_WARMUP_PERIOD = h("wickra_plus_dm_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PLUS_DM_IS_READY = h("wickra_plus_dm_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PLUS_DM_RESET = h("wickra_plus_dm_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PLUS_DM_FREE = h("wickra_plus_dm_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROFILE_SHAPE_NEW = h("wickra_profile_shape_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_PROFILE_SHAPE_UPDATE = h("wickra_profile_shape_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PROFILE_SHAPE_BATCH = h("wickra_profile_shape_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PROFILE_SHAPE_WARMUP_PERIOD = h("wickra_profile_shape_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PROFILE_SHAPE_IS_READY = h("wickra_profile_shape_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PROFILE_SHAPE_RESET = h("wickra_profile_shape_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROFILE_SHAPE_FREE = h("wickra_profile_shape_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROJECTION_OSCILLATOR_NEW = h("wickra_projection_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PROJECTION_OSCILLATOR_UPDATE = h("wickra_projection_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PROJECTION_OSCILLATOR_BATCH = h("wickra_projection_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PROJECTION_OSCILLATOR_WARMUP_PERIOD = h("wickra_projection_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PROJECTION_OSCILLATOR_IS_READY = h("wickra_projection_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PROJECTION_OSCILLATOR_RESET = h("wickra_projection_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROJECTION_OSCILLATOR_FREE = h("wickra_projection_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PSAR_NEW = h("wickra_psar_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_PSAR_UPDATE = h("wickra_psar_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PSAR_BATCH = h("wickra_psar_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PSAR_WARMUP_PERIOD = h("wickra_psar_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PSAR_IS_READY = h("wickra_psar_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PSAR_RESET = h("wickra_psar_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PSAR_FREE = h("wickra_psar_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PVI_NEW = h("wickra_pvi_new", FunctionDescriptor.of(ADDRESS)); WICKRA_PVI_UPDATE = h("wickra_pvi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_PVI_BATCH = h("wickra_pvi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_PVI_WARMUP_PERIOD = h("wickra_pvi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PVI_IS_READY = h("wickra_pvi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PVI_RESET = h("wickra_pvi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PVI_FREE = h("wickra_pvi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QSTICK_NEW = h("wickra_qstick_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_QSTICK_UPDATE = h("wickra_qstick_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_QSTICK_BATCH = h("wickra_qstick_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_QSTICK_WARMUP_PERIOD = h("wickra_qstick_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_QSTICK_IS_READY = h("wickra_qstick_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_QSTICK_RESET = h("wickra_qstick_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QSTICK_FREE = h("wickra_qstick_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RECTANGLE_RANGE_NEW = h("wickra_rectangle_range_new", FunctionDescriptor.of(ADDRESS)); WICKRA_RECTANGLE_RANGE_UPDATE = h("wickra_rectangle_range_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_RECTANGLE_RANGE_BATCH = h("wickra_rectangle_range_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RECTANGLE_RANGE_WARMUP_PERIOD = h("wickra_rectangle_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RECTANGLE_RANGE_IS_READY = h("wickra_rectangle_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RECTANGLE_RANGE_RESET = h("wickra_rectangle_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RECTANGLE_RANGE_FREE = h("wickra_rectangle_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RICKSHAW_MAN_NEW = h("wickra_rickshaw_man_new", FunctionDescriptor.of(ADDRESS)); WICKRA_RICKSHAW_MAN_UPDATE = h("wickra_rickshaw_man_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_RICKSHAW_MAN_BATCH = h("wickra_rickshaw_man_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RICKSHAW_MAN_WARMUP_PERIOD = h("wickra_rickshaw_man_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RICKSHAW_MAN_IS_READY = h("wickra_rickshaw_man_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RICKSHAW_MAN_RESET = h("wickra_rickshaw_man_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RICKSHAW_MAN_FREE = h("wickra_rickshaw_man_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RISING_THREE_METHODS_NEW = h("wickra_rising_three_methods_new", FunctionDescriptor.of(ADDRESS)); WICKRA_RISING_THREE_METHODS_UPDATE = h("wickra_rising_three_methods_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_RISING_THREE_METHODS_BATCH = h("wickra_rising_three_methods_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RISING_THREE_METHODS_WARMUP_PERIOD = h("wickra_rising_three_methods_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RISING_THREE_METHODS_IS_READY = h("wickra_rising_three_methods_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RISING_THREE_METHODS_RESET = h("wickra_rising_three_methods_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RISING_THREE_METHODS_FREE = h("wickra_rising_three_methods_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROGERS_SATCHELL_VOLATILITY_NEW = h("wickra_rogers_satchell_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_ROGERS_SATCHELL_VOLATILITY_UPDATE = h("wickra_rogers_satchell_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ROGERS_SATCHELL_VOLATILITY_BATCH = h("wickra_rogers_satchell_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROGERS_SATCHELL_VOLATILITY_WARMUP_PERIOD = h("wickra_rogers_satchell_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROGERS_SATCHELL_VOLATILITY_IS_READY = h("wickra_rogers_satchell_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROGERS_SATCHELL_VOLATILITY_RESET = h("wickra_rogers_satchell_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROGERS_SATCHELL_VOLATILITY_FREE = h("wickra_rogers_satchell_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RVI_NEW = h("wickra_rvi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_RVI_UPDATE = h("wickra_rvi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_RVI_BATCH = h("wickra_rvi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_RVI_WARMUP_PERIOD = h("wickra_rvi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RVI_IS_READY = h("wickra_rvi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RVI_RESET = h("wickra_rvi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RVI_FREE = h("wickra_rvi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SAR_EXT_NEW = h("wickra_sar_ext_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_SAR_EXT_UPDATE = h("wickra_sar_ext_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SAR_EXT_BATCH = h("wickra_sar_ext_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SAR_EXT_WARMUP_PERIOD = h("wickra_sar_ext_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SAR_EXT_IS_READY = h("wickra_sar_ext_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SAR_EXT_RESET = h("wickra_sar_ext_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SAR_EXT_FREE = h("wickra_sar_ext_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SEASONAL_Z_SCORE_NEW = h("wickra_seasonal_z_score_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_SEASONAL_Z_SCORE_UPDATE = h("wickra_seasonal_z_score_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SEASONAL_Z_SCORE_BATCH = h("wickra_seasonal_z_score_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SEASONAL_Z_SCORE_WARMUP_PERIOD = h("wickra_seasonal_z_score_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SEASONAL_Z_SCORE_IS_READY = h("wickra_seasonal_z_score_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SEASONAL_Z_SCORE_RESET = h("wickra_seasonal_z_score_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SEASONAL_Z_SCORE_FREE = h("wickra_seasonal_z_score_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SEPARATING_LINES_NEW = h("wickra_separating_lines_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SEPARATING_LINES_UPDATE = h("wickra_separating_lines_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SEPARATING_LINES_BATCH = h("wickra_separating_lines_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SEPARATING_LINES_WARMUP_PERIOD = h("wickra_separating_lines_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SEPARATING_LINES_IS_READY = h("wickra_separating_lines_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SEPARATING_LINES_RESET = h("wickra_separating_lines_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SEPARATING_LINES_FREE = h("wickra_separating_lines_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init12() { WICKRA_SESSION_VWAP_NEW = h("wickra_session_vwap_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_SESSION_VWAP_UPDATE = h("wickra_session_vwap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SESSION_VWAP_BATCH = h("wickra_session_vwap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SESSION_VWAP_WARMUP_PERIOD = h("wickra_session_vwap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SESSION_VWAP_IS_READY = h("wickra_session_vwap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SESSION_VWAP_RESET = h("wickra_session_vwap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SESSION_VWAP_FREE = h("wickra_session_vwap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHARK_NEW = h("wickra_shark_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SHARK_UPDATE = h("wickra_shark_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SHARK_BATCH = h("wickra_shark_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SHARK_WARMUP_PERIOD = h("wickra_shark_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SHARK_IS_READY = h("wickra_shark_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SHARK_RESET = h("wickra_shark_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHARK_FREE = h("wickra_shark_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHOOTING_STAR_NEW = h("wickra_shooting_star_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SHOOTING_STAR_UPDATE = h("wickra_shooting_star_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SHOOTING_STAR_BATCH = h("wickra_shooting_star_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SHOOTING_STAR_WARMUP_PERIOD = h("wickra_shooting_star_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SHOOTING_STAR_IS_READY = h("wickra_shooting_star_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SHOOTING_STAR_RESET = h("wickra_shooting_star_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHOOTING_STAR_FREE = h("wickra_shooting_star_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHORT_LINE_NEW = h("wickra_short_line_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SHORT_LINE_UPDATE = h("wickra_short_line_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SHORT_LINE_BATCH = h("wickra_short_line_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + } + + private static void init17() { + WICKRA_SHORT_LINE_WARMUP_PERIOD = h("wickra_short_line_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SHORT_LINE_IS_READY = h("wickra_short_line_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SHORT_LINE_RESET = h("wickra_short_line_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SHORT_LINE_FREE = h("wickra_short_line_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SINGLE_PRINTS_NEW = h("wickra_single_prints_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_SINGLE_PRINTS_UPDATE = h("wickra_single_prints_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SINGLE_PRINTS_BATCH = h("wickra_single_prints_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SINGLE_PRINTS_WARMUP_PERIOD = h("wickra_single_prints_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SINGLE_PRINTS_IS_READY = h("wickra_single_prints_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SINGLE_PRINTS_RESET = h("wickra_single_prints_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SINGLE_PRINTS_FREE = h("wickra_single_prints_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMI_NEW = h("wickra_smi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_SMI_UPDATE = h("wickra_smi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SMI_BATCH = h("wickra_smi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SMI_WARMUP_PERIOD = h("wickra_smi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SMI_IS_READY = h("wickra_smi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SMI_RESET = h("wickra_smi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMI_FREE = h("wickra_smi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPINNING_TOP_NEW = h("wickra_spinning_top_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SPINNING_TOP_UPDATE = h("wickra_spinning_top_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_SPINNING_TOP_BATCH = h("wickra_spinning_top_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_SPINNING_TOP_WARMUP_PERIOD = h("wickra_spinning_top_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SPINNING_TOP_IS_READY = h("wickra_spinning_top_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SPINNING_TOP_RESET = h("wickra_spinning_top_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPINNING_TOP_FREE = h("wickra_spinning_top_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STALLED_PATTERN_NEW = h("wickra_stalled_pattern_new", FunctionDescriptor.of(ADDRESS)); WICKRA_STALLED_PATTERN_UPDATE = h("wickra_stalled_pattern_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_STALLED_PATTERN_BATCH = h("wickra_stalled_pattern_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STALLED_PATTERN_WARMUP_PERIOD = h("wickra_stalled_pattern_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STALLED_PATTERN_IS_READY = h("wickra_stalled_pattern_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STALLED_PATTERN_RESET = h("wickra_stalled_pattern_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STALLED_PATTERN_FREE = h("wickra_stalled_pattern_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STICK_SANDWICH_NEW = h("wickra_stick_sandwich_new", FunctionDescriptor.of(ADDRESS)); WICKRA_STICK_SANDWICH_UPDATE = h("wickra_stick_sandwich_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_STICK_SANDWICH_BATCH = h("wickra_stick_sandwich_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STICK_SANDWICH_WARMUP_PERIOD = h("wickra_stick_sandwich_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STICK_SANDWICH_IS_READY = h("wickra_stick_sandwich_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STICK_SANDWICH_RESET = h("wickra_stick_sandwich_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STICK_SANDWICH_FREE = h("wickra_stick_sandwich_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STOCHASTIC_CCI_NEW = h("wickra_stochastic_cci_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_STOCHASTIC_CCI_UPDATE = h("wickra_stochastic_cci_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_STOCHASTIC_CCI_BATCH = h("wickra_stochastic_cci_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_STOCHASTIC_CCI_WARMUP_PERIOD = h("wickra_stochastic_cci_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STOCHASTIC_CCI_IS_READY = h("wickra_stochastic_cci_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STOCHASTIC_CCI_RESET = h("wickra_stochastic_cci_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STOCHASTIC_CCI_FREE = h("wickra_stochastic_cci_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TAKURI_NEW = h("wickra_takuri_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TAKURI_UPDATE = h("wickra_takuri_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TAKURI_BATCH = h("wickra_takuri_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TAKURI_WARMUP_PERIOD = h("wickra_takuri_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TAKURI_IS_READY = h("wickra_takuri_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TAKURI_RESET = h("wickra_takuri_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TAKURI_FREE = h("wickra_takuri_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TASUKI_GAP_NEW = h("wickra_tasuki_gap_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TASUKI_GAP_UPDATE = h("wickra_tasuki_gap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TASUKI_GAP_BATCH = h("wickra_tasuki_gap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TASUKI_GAP_WARMUP_PERIOD = h("wickra_tasuki_gap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TASUKI_GAP_IS_READY = h("wickra_tasuki_gap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TASUKI_GAP_RESET = h("wickra_tasuki_gap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TASUKI_GAP_FREE = h("wickra_tasuki_gap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_CAMOUFLAGE_NEW = h("wickra_td_camouflage_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_CAMOUFLAGE_UPDATE = h("wickra_td_camouflage_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_CAMOUFLAGE_BATCH = h("wickra_td_camouflage_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_CAMOUFLAGE_WARMUP_PERIOD = h("wickra_td_camouflage_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_CAMOUFLAGE_IS_READY = h("wickra_td_camouflage_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_CAMOUFLAGE_RESET = h("wickra_td_camouflage_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_CAMOUFLAGE_FREE = h("wickra_td_camouflage_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_CLOP_NEW = h("wickra_td_clop_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_CLOP_UPDATE = h("wickra_td_clop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_CLOP_BATCH = h("wickra_td_clop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_CLOP_WARMUP_PERIOD = h("wickra_td_clop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_CLOP_IS_READY = h("wickra_td_clop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_CLOP_RESET = h("wickra_td_clop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_CLOP_FREE = h("wickra_td_clop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_CLOPWIN_NEW = h("wickra_td_clopwin_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_CLOPWIN_UPDATE = h("wickra_td_clopwin_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_CLOPWIN_BATCH = h("wickra_td_clopwin_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_CLOPWIN_WARMUP_PERIOD = h("wickra_td_clopwin_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_CLOPWIN_IS_READY = h("wickra_td_clopwin_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_CLOPWIN_RESET = h("wickra_td_clopwin_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_CLOPWIN_FREE = h("wickra_td_clopwin_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_COMBO_NEW = h("wickra_td_combo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_TD_COMBO_UPDATE = h("wickra_td_combo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_COMBO_BATCH = h("wickra_td_combo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_COMBO_WARMUP_PERIOD = h("wickra_td_combo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_COMBO_IS_READY = h("wickra_td_combo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_COMBO_RESET = h("wickra_td_combo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_COMBO_FREE = h("wickra_td_combo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_COUNTDOWN_NEW = h("wickra_td_countdown_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_TD_COUNTDOWN_UPDATE = h("wickra_td_countdown_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_COUNTDOWN_BATCH = h("wickra_td_countdown_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_COUNTDOWN_WARMUP_PERIOD = h("wickra_td_countdown_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_COUNTDOWN_IS_READY = h("wickra_td_countdown_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_COUNTDOWN_RESET = h("wickra_td_countdown_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_COUNTDOWN_FREE = h("wickra_td_countdown_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_DE_MARKER_NEW = h("wickra_td_de_marker_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TD_DE_MARKER_UPDATE = h("wickra_td_de_marker_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_DE_MARKER_BATCH = h("wickra_td_de_marker_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_DE_MARKER_WARMUP_PERIOD = h("wickra_td_de_marker_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_DE_MARKER_IS_READY = h("wickra_td_de_marker_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_DE_MARKER_RESET = h("wickra_td_de_marker_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_DE_MARKER_FREE = h("wickra_td_de_marker_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_DIFFERENTIAL_NEW = h("wickra_td_differential_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_DIFFERENTIAL_UPDATE = h("wickra_td_differential_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_DIFFERENTIAL_BATCH = h("wickra_td_differential_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_DIFFERENTIAL_WARMUP_PERIOD = h("wickra_td_differential_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_DIFFERENTIAL_IS_READY = h("wickra_td_differential_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_DIFFERENTIAL_RESET = h("wickra_td_differential_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_DIFFERENTIAL_FREE = h("wickra_td_differential_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_D_WAVE_NEW = h("wickra_td_d_wave_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TD_D_WAVE_UPDATE = h("wickra_td_d_wave_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_D_WAVE_BATCH = h("wickra_td_d_wave_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_D_WAVE_WARMUP_PERIOD = h("wickra_td_d_wave_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_D_WAVE_IS_READY = h("wickra_td_d_wave_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_D_WAVE_RESET = h("wickra_td_d_wave_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_D_WAVE_FREE = h("wickra_td_d_wave_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_OPEN_NEW = h("wickra_td_open_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_OPEN_UPDATE = h("wickra_td_open_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_OPEN_BATCH = h("wickra_td_open_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_OPEN_WARMUP_PERIOD = h("wickra_td_open_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + } + + private static void init18() { + WICKRA_TD_OPEN_IS_READY = h("wickra_td_open_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_OPEN_RESET = h("wickra_td_open_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_OPEN_FREE = h("wickra_td_open_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_PRESSURE_NEW = h("wickra_td_pressure_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TD_PRESSURE_UPDATE = h("wickra_td_pressure_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_PRESSURE_BATCH = h("wickra_td_pressure_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_PRESSURE_WARMUP_PERIOD = h("wickra_td_pressure_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_PRESSURE_IS_READY = h("wickra_td_pressure_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_PRESSURE_RESET = h("wickra_td_pressure_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_PRESSURE_FREE = h("wickra_td_pressure_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_PROPULSION_NEW = h("wickra_td_propulsion_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_PROPULSION_UPDATE = h("wickra_td_propulsion_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_PROPULSION_BATCH = h("wickra_td_propulsion_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_PROPULSION_WARMUP_PERIOD = h("wickra_td_propulsion_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_PROPULSION_IS_READY = h("wickra_td_propulsion_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_PROPULSION_RESET = h("wickra_td_propulsion_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_PROPULSION_FREE = h("wickra_td_propulsion_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_REI_NEW = h("wickra_td_rei_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TD_REI_UPDATE = h("wickra_td_rei_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_REI_BATCH = h("wickra_td_rei_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_REI_WARMUP_PERIOD = h("wickra_td_rei_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_REI_IS_READY = h("wickra_td_rei_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_REI_RESET = h("wickra_td_rei_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_REI_FREE = h("wickra_td_rei_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init13() { WICKRA_TD_SETUP_NEW = h("wickra_td_setup_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_TD_SETUP_UPDATE = h("wickra_td_setup_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_SETUP_BATCH = h("wickra_td_setup_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_SETUP_WARMUP_PERIOD = h("wickra_td_setup_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_SETUP_IS_READY = h("wickra_td_setup_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_SETUP_RESET = h("wickra_td_setup_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_SETUP_FREE = h("wickra_td_setup_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_TRAP_NEW = h("wickra_td_trap_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_TRAP_UPDATE = h("wickra_td_trap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TD_TRAP_BATCH = h("wickra_td_trap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TD_TRAP_WARMUP_PERIOD = h("wickra_td_trap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_TRAP_IS_READY = h("wickra_td_trap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_TRAP_RESET = h("wickra_td_trap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_TRAP_FREE = h("wickra_td_trap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_DRIVES_NEW = h("wickra_three_drives_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THREE_DRIVES_UPDATE = h("wickra_three_drives_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_DRIVES_BATCH = h("wickra_three_drives_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_DRIVES_WARMUP_PERIOD = h("wickra_three_drives_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_DRIVES_IS_READY = h("wickra_three_drives_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_DRIVES_RESET = h("wickra_three_drives_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_DRIVES_FREE = h("wickra_three_drives_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_INSIDE_NEW = h("wickra_three_inside_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THREE_INSIDE_UPDATE = h("wickra_three_inside_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_INSIDE_BATCH = h("wickra_three_inside_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_INSIDE_WARMUP_PERIOD = h("wickra_three_inside_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_INSIDE_IS_READY = h("wickra_three_inside_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_INSIDE_RESET = h("wickra_three_inside_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_INSIDE_FREE = h("wickra_three_inside_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_LINE_BREAK_NEW = h("wickra_three_line_break_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_THREE_LINE_BREAK_UPDATE = h("wickra_three_line_break_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_LINE_BREAK_BATCH = h("wickra_three_line_break_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_LINE_BREAK_WARMUP_PERIOD = h("wickra_three_line_break_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_LINE_BREAK_IS_READY = h("wickra_three_line_break_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_LINE_BREAK_RESET = h("wickra_three_line_break_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_LINE_BREAK_FREE = h("wickra_three_line_break_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_LINE_STRIKE_NEW = h("wickra_three_line_strike_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THREE_LINE_STRIKE_UPDATE = h("wickra_three_line_strike_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_LINE_STRIKE_BATCH = h("wickra_three_line_strike_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_LINE_STRIKE_WARMUP_PERIOD = h("wickra_three_line_strike_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_LINE_STRIKE_IS_READY = h("wickra_three_line_strike_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_LINE_STRIKE_RESET = h("wickra_three_line_strike_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_LINE_STRIKE_FREE = h("wickra_three_line_strike_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_OUTSIDE_NEW = h("wickra_three_outside_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THREE_OUTSIDE_UPDATE = h("wickra_three_outside_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_OUTSIDE_BATCH = h("wickra_three_outside_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_OUTSIDE_WARMUP_PERIOD = h("wickra_three_outside_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_OUTSIDE_IS_READY = h("wickra_three_outside_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_OUTSIDE_RESET = h("wickra_three_outside_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_OUTSIDE_FREE = h("wickra_three_outside_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_SOLDIERS_OR_CROWS_NEW = h("wickra_three_soldiers_or_crows_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THREE_SOLDIERS_OR_CROWS_UPDATE = h("wickra_three_soldiers_or_crows_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_SOLDIERS_OR_CROWS_BATCH = h("wickra_three_soldiers_or_crows_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_SOLDIERS_OR_CROWS_WARMUP_PERIOD = h("wickra_three_soldiers_or_crows_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_SOLDIERS_OR_CROWS_IS_READY = h("wickra_three_soldiers_or_crows_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_SOLDIERS_OR_CROWS_RESET = h("wickra_three_soldiers_or_crows_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_SOLDIERS_OR_CROWS_FREE = h("wickra_three_soldiers_or_crows_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_STARS_IN_SOUTH_NEW = h("wickra_three_stars_in_south_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THREE_STARS_IN_SOUTH_UPDATE = h("wickra_three_stars_in_south_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THREE_STARS_IN_SOUTH_BATCH = h("wickra_three_stars_in_south_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THREE_STARS_IN_SOUTH_WARMUP_PERIOD = h("wickra_three_stars_in_south_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THREE_STARS_IN_SOUTH_IS_READY = h("wickra_three_stars_in_south_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THREE_STARS_IN_SOUTH_RESET = h("wickra_three_stars_in_south_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THREE_STARS_IN_SOUTH_FREE = h("wickra_three_stars_in_south_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THRUSTING_NEW = h("wickra_thrusting_new", FunctionDescriptor.of(ADDRESS)); WICKRA_THRUSTING_UPDATE = h("wickra_thrusting_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_THRUSTING_BATCH = h("wickra_thrusting_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_THRUSTING_WARMUP_PERIOD = h("wickra_thrusting_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_THRUSTING_IS_READY = h("wickra_thrusting_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_THRUSTING_RESET = h("wickra_thrusting_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_THRUSTING_FREE = h("wickra_thrusting_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TIME_BASED_STOP_NEW = h("wickra_time_based_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TIME_BASED_STOP_UPDATE = h("wickra_time_based_stop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TIME_BASED_STOP_BATCH = h("wickra_time_based_stop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TIME_BASED_STOP_WARMUP_PERIOD = h("wickra_time_based_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TIME_BASED_STOP_IS_READY = h("wickra_time_based_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TIME_BASED_STOP_RESET = h("wickra_time_based_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TIME_BASED_STOP_FREE = h("wickra_time_based_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TOWER_TOP_BOTTOM_NEW = h("wickra_tower_top_bottom_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TOWER_TOP_BOTTOM_UPDATE = h("wickra_tower_top_bottom_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TOWER_TOP_BOTTOM_BATCH = h("wickra_tower_top_bottom_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TOWER_TOP_BOTTOM_WARMUP_PERIOD = h("wickra_tower_top_bottom_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TOWER_TOP_BOTTOM_IS_READY = h("wickra_tower_top_bottom_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TOWER_TOP_BOTTOM_RESET = h("wickra_tower_top_bottom_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TOWER_TOP_BOTTOM_FREE = h("wickra_tower_top_bottom_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRADE_VOLUME_INDEX_NEW = h("wickra_trade_volume_index_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_TRADE_VOLUME_INDEX_UPDATE = h("wickra_trade_volume_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TRADE_VOLUME_INDEX_BATCH = h("wickra_trade_volume_index_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRADE_VOLUME_INDEX_WARMUP_PERIOD = h("wickra_trade_volume_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRADE_VOLUME_INDEX_IS_READY = h("wickra_trade_volume_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRADE_VOLUME_INDEX_RESET = h("wickra_trade_volume_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRADE_VOLUME_INDEX_FREE = h("wickra_trade_volume_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIANGLE_NEW = h("wickra_triangle_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TRIANGLE_UPDATE = h("wickra_triangle_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TRIANGLE_BATCH = h("wickra_triangle_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRIANGLE_WARMUP_PERIOD = h("wickra_triangle_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRIANGLE_IS_READY = h("wickra_triangle_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init19() { WICKRA_TRIANGLE_RESET = h("wickra_triangle_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIANGLE_FREE = h("wickra_triangle_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIPLE_TOP_BOTTOM_NEW = h("wickra_triple_top_bottom_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TRIPLE_TOP_BOTTOM_UPDATE = h("wickra_triple_top_bottom_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TRIPLE_TOP_BOTTOM_BATCH = h("wickra_triple_top_bottom_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRIPLE_TOP_BOTTOM_WARMUP_PERIOD = h("wickra_triple_top_bottom_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRIPLE_TOP_BOTTOM_IS_READY = h("wickra_triple_top_bottom_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRIPLE_TOP_BOTTOM_RESET = h("wickra_triple_top_bottom_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIPLE_TOP_BOTTOM_FREE = h("wickra_triple_top_bottom_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRISTAR_NEW = h("wickra_tristar_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TRISTAR_UPDATE = h("wickra_tristar_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TRISTAR_BATCH = h("wickra_tristar_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRISTAR_WARMUP_PERIOD = h("wickra_tristar_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRISTAR_IS_READY = h("wickra_tristar_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRISTAR_RESET = h("wickra_tristar_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRISTAR_FREE = h("wickra_tristar_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRUE_RANGE_NEW = h("wickra_true_range_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TRUE_RANGE_UPDATE = h("wickra_true_range_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TRUE_RANGE_BATCH = h("wickra_true_range_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TRUE_RANGE_WARMUP_PERIOD = h("wickra_true_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRUE_RANGE_IS_READY = h("wickra_true_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRUE_RANGE_RESET = h("wickra_true_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRUE_RANGE_FREE = h("wickra_true_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSV_NEW = h("wickra_tsv_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TSV_UPDATE = h("wickra_tsv_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TSV_BATCH = h("wickra_tsv_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TSV_WARMUP_PERIOD = h("wickra_tsv_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TSV_IS_READY = h("wickra_tsv_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TSV_RESET = h("wickra_tsv_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TSV_FREE = h("wickra_tsv_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TTM_TREND_NEW = h("wickra_ttm_trend_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TTM_TREND_UPDATE = h("wickra_ttm_trend_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TTM_TREND_BATCH = h("wickra_ttm_trend_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TTM_TREND_WARMUP_PERIOD = h("wickra_ttm_trend_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TTM_TREND_IS_READY = h("wickra_ttm_trend_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TTM_TREND_RESET = h("wickra_ttm_trend_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TTM_TREND_FREE = h("wickra_ttm_trend_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TURN_OF_MONTH_NEW = h("wickra_turn_of_month_new", FunctionDescriptor.of(ADDRESS, JAVA_INT, JAVA_INT, JAVA_INT)); WICKRA_TURN_OF_MONTH_UPDATE = h("wickra_turn_of_month_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TURN_OF_MONTH_BATCH = h("wickra_turn_of_month_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TURN_OF_MONTH_WARMUP_PERIOD = h("wickra_turn_of_month_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TURN_OF_MONTH_IS_READY = h("wickra_turn_of_month_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TURN_OF_MONTH_RESET = h("wickra_turn_of_month_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TURN_OF_MONTH_FREE = h("wickra_turn_of_month_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TWEEZER_NEW = h("wickra_tweezer_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TWEEZER_UPDATE = h("wickra_tweezer_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TWEEZER_BATCH = h("wickra_tweezer_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TWEEZER_WARMUP_PERIOD = h("wickra_tweezer_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TWEEZER_IS_READY = h("wickra_tweezer_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TWEEZER_RESET = h("wickra_tweezer_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TWEEZER_FREE = h("wickra_tweezer_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TWIGGS_MONEY_FLOW_NEW = h("wickra_twiggs_money_flow_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TWIGGS_MONEY_FLOW_UPDATE = h("wickra_twiggs_money_flow_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TWIGGS_MONEY_FLOW_BATCH = h("wickra_twiggs_money_flow_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TWIGGS_MONEY_FLOW_WARMUP_PERIOD = h("wickra_twiggs_money_flow_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TWIGGS_MONEY_FLOW_IS_READY = h("wickra_twiggs_money_flow_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TWIGGS_MONEY_FLOW_RESET = h("wickra_twiggs_money_flow_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TWIGGS_MONEY_FLOW_FREE = h("wickra_twiggs_money_flow_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TWO_CROWS_NEW = h("wickra_two_crows_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TWO_CROWS_UPDATE = h("wickra_two_crows_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TWO_CROWS_BATCH = h("wickra_two_crows_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TWO_CROWS_WARMUP_PERIOD = h("wickra_two_crows_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TWO_CROWS_IS_READY = h("wickra_two_crows_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TWO_CROWS_RESET = h("wickra_two_crows_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TWO_CROWS_FREE = h("wickra_two_crows_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TYPICAL_PRICE_NEW = h("wickra_typical_price_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TYPICAL_PRICE_UPDATE = h("wickra_typical_price_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_TYPICAL_PRICE_BATCH = h("wickra_typical_price_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TYPICAL_PRICE_WARMUP_PERIOD = h("wickra_typical_price_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TYPICAL_PRICE_IS_READY = h("wickra_typical_price_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TYPICAL_PRICE_RESET = h("wickra_typical_price_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TYPICAL_PRICE_FREE = h("wickra_typical_price_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init14() { WICKRA_ULTIMATE_OSCILLATOR_NEW = h("wickra_ultimate_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_ULTIMATE_OSCILLATOR_UPDATE = h("wickra_ultimate_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ULTIMATE_OSCILLATOR_BATCH = h("wickra_ultimate_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ULTIMATE_OSCILLATOR_WARMUP_PERIOD = h("wickra_ultimate_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ULTIMATE_OSCILLATOR_IS_READY = h("wickra_ultimate_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ULTIMATE_OSCILLATOR_RESET = h("wickra_ultimate_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ULTIMATE_OSCILLATOR_FREE = h("wickra_ultimate_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UNIQUE_THREE_RIVER_NEW = h("wickra_unique_three_river_new", FunctionDescriptor.of(ADDRESS)); WICKRA_UNIQUE_THREE_RIVER_UPDATE = h("wickra_unique_three_river_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_UNIQUE_THREE_RIVER_BATCH = h("wickra_unique_three_river_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_UNIQUE_THREE_RIVER_WARMUP_PERIOD = h("wickra_unique_three_river_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_UNIQUE_THREE_RIVER_IS_READY = h("wickra_unique_three_river_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_UNIQUE_THREE_RIVER_RESET = h("wickra_unique_three_river_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UNIQUE_THREE_RIVER_FREE = h("wickra_unique_three_river_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UPSIDE_GAP_THREE_METHODS_NEW = h("wickra_upside_gap_three_methods_new", FunctionDescriptor.of(ADDRESS)); WICKRA_UPSIDE_GAP_THREE_METHODS_UPDATE = h("wickra_upside_gap_three_methods_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_UPSIDE_GAP_THREE_METHODS_BATCH = h("wickra_upside_gap_three_methods_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_UPSIDE_GAP_THREE_METHODS_WARMUP_PERIOD = h("wickra_upside_gap_three_methods_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_UPSIDE_GAP_THREE_METHODS_IS_READY = h("wickra_upside_gap_three_methods_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_UPSIDE_GAP_THREE_METHODS_RESET = h("wickra_upside_gap_three_methods_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UPSIDE_GAP_THREE_METHODS_FREE = h("wickra_upside_gap_three_methods_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UPSIDE_GAP_TWO_CROWS_NEW = h("wickra_upside_gap_two_crows_new", FunctionDescriptor.of(ADDRESS)); WICKRA_UPSIDE_GAP_TWO_CROWS_UPDATE = h("wickra_upside_gap_two_crows_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_UPSIDE_GAP_TWO_CROWS_BATCH = h("wickra_upside_gap_two_crows_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_UPSIDE_GAP_TWO_CROWS_WARMUP_PERIOD = h("wickra_upside_gap_two_crows_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_UPSIDE_GAP_TWO_CROWS_IS_READY = h("wickra_upside_gap_two_crows_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_UPSIDE_GAP_TWO_CROWS_RESET = h("wickra_upside_gap_two_crows_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UPSIDE_GAP_TWO_CROWS_FREE = h("wickra_upside_gap_two_crows_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLATILITY_RATIO_NEW = h("wickra_volatility_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VOLATILITY_RATIO_UPDATE = h("wickra_volatility_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VOLATILITY_RATIO_BATCH = h("wickra_volatility_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLATILITY_RATIO_WARMUP_PERIOD = h("wickra_volatility_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLATILITY_RATIO_IS_READY = h("wickra_volatility_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLATILITY_RATIO_RESET = h("wickra_volatility_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLATILITY_RATIO_FREE = h("wickra_volatility_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLTY_STOP_NEW = h("wickra_volty_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_VOLTY_STOP_UPDATE = h("wickra_volty_stop_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VOLTY_STOP_BATCH = h("wickra_volty_stop_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLTY_STOP_WARMUP_PERIOD = h("wickra_volty_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLTY_STOP_IS_READY = h("wickra_volty_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLTY_STOP_RESET = h("wickra_volty_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLTY_STOP_FREE = h("wickra_volty_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_OSCILLATOR_NEW = h("wickra_volume_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_VOLUME_OSCILLATOR_UPDATE = h("wickra_volume_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VOLUME_OSCILLATOR_BATCH = h("wickra_volume_oscillator_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLUME_OSCILLATOR_WARMUP_PERIOD = h("wickra_volume_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_OSCILLATOR_IS_READY = h("wickra_volume_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLUME_OSCILLATOR_RESET = h("wickra_volume_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); + } + + private static void init20() { WICKRA_VOLUME_OSCILLATOR_FREE = h("wickra_volume_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_RSI_NEW = h("wickra_volume_rsi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VOLUME_RSI_UPDATE = h("wickra_volume_rsi_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VOLUME_RSI_BATCH = h("wickra_volume_rsi_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLUME_RSI_WARMUP_PERIOD = h("wickra_volume_rsi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_RSI_IS_READY = h("wickra_volume_rsi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLUME_RSI_RESET = h("wickra_volume_rsi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_RSI_FREE = h("wickra_volume_rsi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_PRICE_TREND_NEW = h("wickra_volume_price_trend_new", FunctionDescriptor.of(ADDRESS)); WICKRA_VOLUME_PRICE_TREND_UPDATE = h("wickra_volume_price_trend_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VOLUME_PRICE_TREND_BATCH = h("wickra_volume_price_trend_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLUME_PRICE_TREND_WARMUP_PERIOD = h("wickra_volume_price_trend_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_PRICE_TREND_IS_READY = h("wickra_volume_price_trend_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLUME_PRICE_TREND_RESET = h("wickra_volume_price_trend_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_PRICE_TREND_FREE = h("wickra_volume_price_trend_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VWAP_NEW = h("wickra_vwap_new", FunctionDescriptor.of(ADDRESS)); WICKRA_VWAP_UPDATE = h("wickra_vwap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VWAP_BATCH = h("wickra_vwap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VWAP_WARMUP_PERIOD = h("wickra_vwap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VWAP_IS_READY = h("wickra_vwap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VWAP_RESET = h("wickra_vwap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VWAP_FREE = h("wickra_vwap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_VWAP_NEW = h("wickra_rolling_vwap_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLLING_VWAP_UPDATE = h("wickra_rolling_vwap_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_ROLLING_VWAP_BATCH = h("wickra_rolling_vwap_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ROLLING_VWAP_WARMUP_PERIOD = h("wickra_rolling_vwap_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLLING_VWAP_IS_READY = h("wickra_rolling_vwap_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLLING_VWAP_RESET = h("wickra_rolling_vwap_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLLING_VWAP_FREE = h("wickra_rolling_vwap_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VWMA_NEW = h("wickra_vwma_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VWMA_UPDATE = h("wickra_vwma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VWMA_BATCH = h("wickra_vwma_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VWMA_WARMUP_PERIOD = h("wickra_vwma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VWMA_IS_READY = h("wickra_vwma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VWMA_RESET = h("wickra_vwma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VWMA_FREE = h("wickra_vwma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VZO_NEW = h("wickra_vzo_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VZO_UPDATE = h("wickra_vzo_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VZO_BATCH = h("wickra_vzo_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VZO_WARMUP_PERIOD = h("wickra_vzo_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VZO_IS_READY = h("wickra_vzo_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VZO_RESET = h("wickra_vzo_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VZO_FREE = h("wickra_vzo_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WAD_NEW = h("wickra_wad_new", FunctionDescriptor.of(ADDRESS)); WICKRA_WAD_UPDATE = h("wickra_wad_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_WAD_BATCH = h("wickra_wad_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WAD_WARMUP_PERIOD = h("wickra_wad_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WAD_IS_READY = h("wickra_wad_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WAD_RESET = h("wickra_wad_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WAD_FREE = h("wickra_wad_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WEDGE_NEW = h("wickra_wedge_new", FunctionDescriptor.of(ADDRESS)); WICKRA_WEDGE_UPDATE = h("wickra_wedge_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_WEDGE_BATCH = h("wickra_wedge_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WEDGE_WARMUP_PERIOD = h("wickra_wedge_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WEDGE_IS_READY = h("wickra_wedge_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WEDGE_RESET = h("wickra_wedge_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WEDGE_FREE = h("wickra_wedge_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WEIGHTED_CLOSE_NEW = h("wickra_weighted_close_new", FunctionDescriptor.of(ADDRESS)); WICKRA_WEIGHTED_CLOSE_UPDATE = h("wickra_weighted_close_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_WEIGHTED_CLOSE_BATCH = h("wickra_weighted_close_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WEIGHTED_CLOSE_WARMUP_PERIOD = h("wickra_weighted_close_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WEIGHTED_CLOSE_IS_READY = h("wickra_weighted_close_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WEIGHTED_CLOSE_RESET = h("wickra_weighted_close_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WEIGHTED_CLOSE_FREE = h("wickra_weighted_close_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WICK_RATIO_NEW = h("wickra_wick_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_WICK_RATIO_UPDATE = h("wickra_wick_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_WICK_RATIO_BATCH = h("wickra_wick_ratio_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WICK_RATIO_WARMUP_PERIOD = h("wickra_wick_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WICK_RATIO_IS_READY = h("wickra_wick_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WICK_RATIO_RESET = h("wickra_wick_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WICK_RATIO_FREE = h("wickra_wick_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WILLIAMS_R_NEW = h("wickra_williams_r_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_WILLIAMS_R_UPDATE = h("wickra_williams_r_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_WILLIAMS_R_BATCH = h("wickra_williams_r_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_WILLIAMS_R_WARMUP_PERIOD = h("wickra_williams_r_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WILLIAMS_R_IS_READY = h("wickra_williams_r_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WILLIAMS_R_RESET = h("wickra_williams_r_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WILLIAMS_R_FREE = h("wickra_williams_r_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_YANG_ZHANG_VOLATILITY_NEW = h("wickra_yang_zhang_volatility_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_YANG_ZHANG_VOLATILITY_UPDATE = h("wickra_yang_zhang_volatility_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_YANG_ZHANG_VOLATILITY_BATCH = h("wickra_yang_zhang_volatility_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_YANG_ZHANG_VOLATILITY_WARMUP_PERIOD = h("wickra_yang_zhang_volatility_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_YANG_ZHANG_VOLATILITY_IS_READY = h("wickra_yang_zhang_volatility_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_YANG_ZHANG_VOLATILITY_RESET = h("wickra_yang_zhang_volatility_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_YANG_ZHANG_VOLATILITY_FREE = h("wickra_yang_zhang_volatility_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_YOYO_EXIT_NEW = h("wickra_yoyo_exit_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_YOYO_EXIT_UPDATE = h("wickra_yoyo_exit_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); WICKRA_YOYO_EXIT_BATCH = h("wickra_yoyo_exit_batch", FunctionDescriptor.ofVoid(ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_YOYO_EXIT_WARMUP_PERIOD = h("wickra_yoyo_exit_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_YOYO_EXIT_IS_READY = h("wickra_yoyo_exit_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_YOYO_EXIT_RESET = h("wickra_yoyo_exit_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_YOYO_EXIT_FREE = h("wickra_yoyo_exit_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AMIHUD_ILLIQUIDITY_NEW = h("wickra_amihud_illiquidity_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_AMIHUD_ILLIQUIDITY_UPDATE = h("wickra_amihud_illiquidity_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_AMIHUD_ILLIQUIDITY_WARMUP_PERIOD = h("wickra_amihud_illiquidity_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AMIHUD_ILLIQUIDITY_IS_READY = h("wickra_amihud_illiquidity_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AMIHUD_ILLIQUIDITY_RESET = h("wickra_amihud_illiquidity_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AMIHUD_ILLIQUIDITY_FREE = h("wickra_amihud_illiquidity_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CUMULATIVE_VOLUME_DELTA_NEW = h("wickra_cumulative_volume_delta_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CUMULATIVE_VOLUME_DELTA_UPDATE = h("wickra_cumulative_volume_delta_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_CUMULATIVE_VOLUME_DELTA_WARMUP_PERIOD = h("wickra_cumulative_volume_delta_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CUMULATIVE_VOLUME_DELTA_IS_READY = h("wickra_cumulative_volume_delta_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CUMULATIVE_VOLUME_DELTA_RESET = h("wickra_cumulative_volume_delta_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CUMULATIVE_VOLUME_DELTA_FREE = h("wickra_cumulative_volume_delta_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PIN_NEW = h("wickra_pin_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PIN_UPDATE = h("wickra_pin_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_PIN_WARMUP_PERIOD = h("wickra_pin_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PIN_IS_READY = h("wickra_pin_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PIN_RESET = h("wickra_pin_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PIN_FREE = h("wickra_pin_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLL_MEASURE_NEW = h("wickra_roll_measure_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ROLL_MEASURE_UPDATE = h("wickra_roll_measure_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_ROLL_MEASURE_WARMUP_PERIOD = h("wickra_roll_measure_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ROLL_MEASURE_IS_READY = h("wickra_roll_measure_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ROLL_MEASURE_RESET = h("wickra_roll_measure_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ROLL_MEASURE_FREE = h("wickra_roll_measure_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SIGNED_VOLUME_NEW = h("wickra_signed_volume_new", FunctionDescriptor.of(ADDRESS)); WICKRA_SIGNED_VOLUME_UPDATE = h("wickra_signed_volume_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); - WICKRA_SIGNED_VOLUME_RESET = h("wickra_signed_volume_reset", FunctionDescriptor.ofVoid(ADDRESS)); - WICKRA_SIGNED_VOLUME_FREE = h("wickra_signed_volume_free", FunctionDescriptor.ofVoid(ADDRESS)); + WICKRA_SIGNED_VOLUME_WARMUP_PERIOD = h("wickra_signed_volume_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SIGNED_VOLUME_IS_READY = h("wickra_signed_volume_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); } - private static void init15() { + private static void init21() { + WICKRA_SIGNED_VOLUME_RESET = h("wickra_signed_volume_reset", FunctionDescriptor.ofVoid(ADDRESS)); + WICKRA_SIGNED_VOLUME_FREE = h("wickra_signed_volume_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRADE_IMBALANCE_NEW = h("wickra_trade_imbalance_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TRADE_IMBALANCE_UPDATE = h("wickra_trade_imbalance_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_TRADE_IMBALANCE_WARMUP_PERIOD = h("wickra_trade_imbalance_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRADE_IMBALANCE_IS_READY = h("wickra_trade_imbalance_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRADE_IMBALANCE_RESET = h("wickra_trade_imbalance_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRADE_IMBALANCE_FREE = h("wickra_trade_imbalance_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRADE_SIGN_AUTOCORRELATION_NEW = h("wickra_trade_sign_autocorrelation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_TRADE_SIGN_AUTOCORRELATION_UPDATE = h("wickra_trade_sign_autocorrelation_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_TRADE_SIGN_AUTOCORRELATION_WARMUP_PERIOD = h("wickra_trade_sign_autocorrelation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRADE_SIGN_AUTOCORRELATION_IS_READY = h("wickra_trade_sign_autocorrelation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRADE_SIGN_AUTOCORRELATION_RESET = h("wickra_trade_sign_autocorrelation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRADE_SIGN_AUTOCORRELATION_FREE = h("wickra_trade_sign_autocorrelation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VPIN_NEW = h("wickra_vpin_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_LONG)); WICKRA_VPIN_UPDATE = h("wickra_vpin_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG)); + WICKRA_VPIN_WARMUP_PERIOD = h("wickra_vpin_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VPIN_IS_READY = h("wickra_vpin_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VPIN_RESET = h("wickra_vpin_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VPIN_FREE = h("wickra_vpin_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EFFECTIVE_SPREAD_NEW = h("wickra_effective_spread_new", FunctionDescriptor.of(ADDRESS)); WICKRA_EFFECTIVE_SPREAD_UPDATE = h("wickra_effective_spread_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG, JAVA_DOUBLE)); + WICKRA_EFFECTIVE_SPREAD_WARMUP_PERIOD = h("wickra_effective_spread_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EFFECTIVE_SPREAD_IS_READY = h("wickra_effective_spread_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EFFECTIVE_SPREAD_RESET = h("wickra_effective_spread_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EFFECTIVE_SPREAD_FREE = h("wickra_effective_spread_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KYLES_LAMBDA_NEW = h("wickra_kyles_lambda_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_KYLES_LAMBDA_UPDATE = h("wickra_kyles_lambda_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG, JAVA_DOUBLE)); + WICKRA_KYLES_LAMBDA_WARMUP_PERIOD = h("wickra_kyles_lambda_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KYLES_LAMBDA_IS_READY = h("wickra_kyles_lambda_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KYLES_LAMBDA_RESET = h("wickra_kyles_lambda_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KYLES_LAMBDA_FREE = h("wickra_kyles_lambda_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REALIZED_SPREAD_NEW = h("wickra_realized_spread_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_REALIZED_SPREAD_UPDATE = h("wickra_realized_spread_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG, JAVA_DOUBLE)); + WICKRA_REALIZED_SPREAD_WARMUP_PERIOD = h("wickra_realized_spread_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_REALIZED_SPREAD_IS_READY = h("wickra_realized_spread_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_REALIZED_SPREAD_RESET = h("wickra_realized_spread_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_REALIZED_SPREAD_FREE = h("wickra_realized_spread_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CALENDAR_SPREAD_NEW = h("wickra_calendar_spread_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CALENDAR_SPREAD_UPDATE = h("wickra_calendar_spread_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_CALENDAR_SPREAD_WARMUP_PERIOD = h("wickra_calendar_spread_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CALENDAR_SPREAD_IS_READY = h("wickra_calendar_spread_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CALENDAR_SPREAD_RESET = h("wickra_calendar_spread_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CALENDAR_SPREAD_FREE = h("wickra_calendar_spread_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ESTIMATED_LEVERAGE_RATIO_NEW = h("wickra_estimated_leverage_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ESTIMATED_LEVERAGE_RATIO_UPDATE = h("wickra_estimated_leverage_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_ESTIMATED_LEVERAGE_RATIO_WARMUP_PERIOD = h("wickra_estimated_leverage_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ESTIMATED_LEVERAGE_RATIO_IS_READY = h("wickra_estimated_leverage_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ESTIMATED_LEVERAGE_RATIO_RESET = h("wickra_estimated_leverage_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ESTIMATED_LEVERAGE_RATIO_FREE = h("wickra_estimated_leverage_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_BASIS_NEW = h("wickra_funding_basis_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FUNDING_BASIS_UPDATE = h("wickra_funding_basis_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_FUNDING_BASIS_WARMUP_PERIOD = h("wickra_funding_basis_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FUNDING_BASIS_IS_READY = h("wickra_funding_basis_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FUNDING_BASIS_RESET = h("wickra_funding_basis_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_BASIS_FREE = h("wickra_funding_basis_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_IMPLIED_APR_NEW = h("wickra_funding_implied_apr_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_FUNDING_IMPLIED_APR_UPDATE = h("wickra_funding_implied_apr_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_FUNDING_IMPLIED_APR_WARMUP_PERIOD = h("wickra_funding_implied_apr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FUNDING_IMPLIED_APR_IS_READY = h("wickra_funding_implied_apr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FUNDING_IMPLIED_APR_RESET = h("wickra_funding_implied_apr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_IMPLIED_APR_FREE = h("wickra_funding_implied_apr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_RATE_NEW = h("wickra_funding_rate_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FUNDING_RATE_UPDATE = h("wickra_funding_rate_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_FUNDING_RATE_WARMUP_PERIOD = h("wickra_funding_rate_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FUNDING_RATE_IS_READY = h("wickra_funding_rate_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FUNDING_RATE_RESET = h("wickra_funding_rate_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_RATE_FREE = h("wickra_funding_rate_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_RATE_MEAN_NEW = h("wickra_funding_rate_mean_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FUNDING_RATE_MEAN_UPDATE = h("wickra_funding_rate_mean_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_FUNDING_RATE_MEAN_WARMUP_PERIOD = h("wickra_funding_rate_mean_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FUNDING_RATE_MEAN_IS_READY = h("wickra_funding_rate_mean_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FUNDING_RATE_MEAN_RESET = h("wickra_funding_rate_mean_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_RATE_MEAN_FREE = h("wickra_funding_rate_mean_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_RATE_Z_SCORE_NEW = h("wickra_funding_rate_z_score_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FUNDING_RATE_Z_SCORE_UPDATE = h("wickra_funding_rate_z_score_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_FUNDING_RATE_Z_SCORE_WARMUP_PERIOD = h("wickra_funding_rate_z_score_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FUNDING_RATE_Z_SCORE_IS_READY = h("wickra_funding_rate_z_score_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FUNDING_RATE_Z_SCORE_RESET = h("wickra_funding_rate_z_score_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FUNDING_RATE_Z_SCORE_FREE = h("wickra_funding_rate_z_score_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LONG_SHORT_RATIO_NEW = h("wickra_long_short_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_LONG_SHORT_RATIO_UPDATE = h("wickra_long_short_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_LONG_SHORT_RATIO_WARMUP_PERIOD = h("wickra_long_short_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LONG_SHORT_RATIO_IS_READY = h("wickra_long_short_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LONG_SHORT_RATIO_RESET = h("wickra_long_short_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LONG_SHORT_RATIO_FREE = h("wickra_long_short_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPEN_INTEREST_DELTA_NEW = h("wickra_open_interest_delta_new", FunctionDescriptor.of(ADDRESS)); WICKRA_OPEN_INTEREST_DELTA_UPDATE = h("wickra_open_interest_delta_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_OPEN_INTEREST_DELTA_WARMUP_PERIOD = h("wickra_open_interest_delta_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OPEN_INTEREST_DELTA_IS_READY = h("wickra_open_interest_delta_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OPEN_INTEREST_DELTA_RESET = h("wickra_open_interest_delta_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPEN_INTEREST_DELTA_FREE = h("wickra_open_interest_delta_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OI_PRICE_DIVERGENCE_NEW = h("wickra_oi_price_divergence_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_OI_PRICE_DIVERGENCE_UPDATE = h("wickra_oi_price_divergence_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_OI_PRICE_DIVERGENCE_WARMUP_PERIOD = h("wickra_oi_price_divergence_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OI_PRICE_DIVERGENCE_IS_READY = h("wickra_oi_price_divergence_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OI_PRICE_DIVERGENCE_RESET = h("wickra_oi_price_divergence_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OI_PRICE_DIVERGENCE_FREE = h("wickra_oi_price_divergence_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OI_TO_VOLUME_RATIO_NEW = h("wickra_oi_to_volume_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_OI_TO_VOLUME_RATIO_UPDATE = h("wickra_oi_to_volume_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_OI_TO_VOLUME_RATIO_WARMUP_PERIOD = h("wickra_oi_to_volume_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OI_TO_VOLUME_RATIO_IS_READY = h("wickra_oi_to_volume_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OI_TO_VOLUME_RATIO_RESET = h("wickra_oi_to_volume_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OI_TO_VOLUME_RATIO_FREE = h("wickra_oi_to_volume_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OI_WEIGHTED_NEW = h("wickra_oi_weighted_new", FunctionDescriptor.of(ADDRESS)); WICKRA_OI_WEIGHTED_UPDATE = h("wickra_oi_weighted_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_OI_WEIGHTED_WARMUP_PERIOD = h("wickra_oi_weighted_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OI_WEIGHTED_IS_READY = h("wickra_oi_weighted_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OI_WEIGHTED_RESET = h("wickra_oi_weighted_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OI_WEIGHTED_FREE = h("wickra_oi_weighted_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPEN_INTEREST_MOMENTUM_NEW = h("wickra_open_interest_momentum_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_OPEN_INTEREST_MOMENTUM_UPDATE = h("wickra_open_interest_momentum_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_OPEN_INTEREST_MOMENTUM_WARMUP_PERIOD = h("wickra_open_interest_momentum_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OPEN_INTEREST_MOMENTUM_IS_READY = h("wickra_open_interest_momentum_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OPEN_INTEREST_MOMENTUM_RESET = h("wickra_open_interest_momentum_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPEN_INTEREST_MOMENTUM_FREE = h("wickra_open_interest_momentum_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERPETUAL_PREMIUM_INDEX_NEW = h("wickra_perpetual_premium_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_PERPETUAL_PREMIUM_INDEX_UPDATE = h("wickra_perpetual_premium_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_PERPETUAL_PREMIUM_INDEX_WARMUP_PERIOD = h("wickra_perpetual_premium_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PERPETUAL_PREMIUM_INDEX_IS_READY = h("wickra_perpetual_premium_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init22() { WICKRA_PERPETUAL_PREMIUM_INDEX_RESET = h("wickra_perpetual_premium_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERPETUAL_PREMIUM_INDEX_FREE = h("wickra_perpetual_premium_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TAKER_BUY_SELL_RATIO_NEW = h("wickra_taker_buy_sell_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TAKER_BUY_SELL_RATIO_UPDATE = h("wickra_taker_buy_sell_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_TAKER_BUY_SELL_RATIO_WARMUP_PERIOD = h("wickra_taker_buy_sell_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TAKER_BUY_SELL_RATIO_IS_READY = h("wickra_taker_buy_sell_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TAKER_BUY_SELL_RATIO_RESET = h("wickra_taker_buy_sell_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TAKER_BUY_SELL_RATIO_FREE = h("wickra_taker_buy_sell_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TERM_STRUCTURE_BASIS_NEW = h("wickra_term_structure_basis_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TERM_STRUCTURE_BASIS_UPDATE = h("wickra_term_structure_basis_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG)); + WICKRA_TERM_STRUCTURE_BASIS_WARMUP_PERIOD = h("wickra_term_structure_basis_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TERM_STRUCTURE_BASIS_IS_READY = h("wickra_term_structure_basis_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TERM_STRUCTURE_BASIS_RESET = h("wickra_term_structure_basis_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TERM_STRUCTURE_BASIS_FREE = h("wickra_term_structure_basis_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEPTH_SLOPE_NEW = h("wickra_depth_slope_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DEPTH_SLOPE_UPDATE = h("wickra_depth_slope_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_DEPTH_SLOPE_WARMUP_PERIOD = h("wickra_depth_slope_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DEPTH_SLOPE_IS_READY = h("wickra_depth_slope_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DEPTH_SLOPE_RESET = h("wickra_depth_slope_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEPTH_SLOPE_FREE = h("wickra_depth_slope_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MICROPRICE_NEW = h("wickra_microprice_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MICROPRICE_UPDATE = h("wickra_microprice_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_MICROPRICE_WARMUP_PERIOD = h("wickra_microprice_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MICROPRICE_IS_READY = h("wickra_microprice_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MICROPRICE_RESET = h("wickra_microprice_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MICROPRICE_FREE = h("wickra_microprice_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_FULL_NEW = h("wickra_order_book_imbalance_full_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_FULL_UPDATE = h("wickra_order_book_imbalance_full_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ORDER_BOOK_IMBALANCE_FULL_WARMUP_PERIOD = h("wickra_order_book_imbalance_full_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ORDER_BOOK_IMBALANCE_FULL_IS_READY = h("wickra_order_book_imbalance_full_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_FULL_RESET = h("wickra_order_book_imbalance_full_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_FULL_FREE = h("wickra_order_book_imbalance_full_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP1_NEW = h("wickra_order_book_imbalance_top1_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP1_UPDATE = h("wickra_order_book_imbalance_top1_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ORDER_BOOK_IMBALANCE_TOP1_WARMUP_PERIOD = h("wickra_order_book_imbalance_top1_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ORDER_BOOK_IMBALANCE_TOP1_IS_READY = h("wickra_order_book_imbalance_top1_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP1_RESET = h("wickra_order_book_imbalance_top1_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP1_FREE = h("wickra_order_book_imbalance_top1_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_NEW = h("wickra_order_book_imbalance_top_n_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_UPDATE = h("wickra_order_book_imbalance_top_n_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_WARMUP_PERIOD = h("wickra_order_book_imbalance_top_n_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_IS_READY = h("wickra_order_book_imbalance_top_n_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_RESET = h("wickra_order_book_imbalance_top_n_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_BOOK_IMBALANCE_TOP_N_FREE = h("wickra_order_book_imbalance_top_n_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_FLOW_IMBALANCE_NEW = h("wickra_order_flow_imbalance_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ORDER_FLOW_IMBALANCE_UPDATE = h("wickra_order_flow_imbalance_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_ORDER_FLOW_IMBALANCE_WARMUP_PERIOD = h("wickra_order_flow_imbalance_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ORDER_FLOW_IMBALANCE_IS_READY = h("wickra_order_flow_imbalance_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ORDER_FLOW_IMBALANCE_RESET = h("wickra_order_flow_imbalance_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ORDER_FLOW_IMBALANCE_FREE = h("wickra_order_flow_imbalance_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QUOTED_SPREAD_NEW = h("wickra_quoted_spread_new", FunctionDescriptor.of(ADDRESS)); WICKRA_QUOTED_SPREAD_UPDATE = h("wickra_quoted_spread_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_QUOTED_SPREAD_WARMUP_PERIOD = h("wickra_quoted_spread_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_QUOTED_SPREAD_IS_READY = h("wickra_quoted_spread_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_QUOTED_SPREAD_RESET = h("wickra_quoted_spread_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QUOTED_SPREAD_FREE = h("wickra_quoted_spread_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ABSOLUTE_BREADTH_INDEX_NEW = h("wickra_absolute_breadth_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ABSOLUTE_BREADTH_INDEX_UPDATE = h("wickra_absolute_breadth_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_ABSOLUTE_BREADTH_INDEX_WARMUP_PERIOD = h("wickra_absolute_breadth_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ABSOLUTE_BREADTH_INDEX_IS_READY = h("wickra_absolute_breadth_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ABSOLUTE_BREADTH_INDEX_RESET = h("wickra_absolute_breadth_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ABSOLUTE_BREADTH_INDEX_FREE = h("wickra_absolute_breadth_index_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init16() { WICKRA_AD_VOLUME_LINE_NEW = h("wickra_ad_volume_line_new", FunctionDescriptor.of(ADDRESS)); WICKRA_AD_VOLUME_LINE_UPDATE = h("wickra_ad_volume_line_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_AD_VOLUME_LINE_WARMUP_PERIOD = h("wickra_ad_volume_line_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AD_VOLUME_LINE_IS_READY = h("wickra_ad_volume_line_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AD_VOLUME_LINE_RESET = h("wickra_ad_volume_line_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AD_VOLUME_LINE_FREE = h("wickra_ad_volume_line_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADVANCE_DECLINE_NEW = h("wickra_advance_decline_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ADVANCE_DECLINE_UPDATE = h("wickra_advance_decline_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_ADVANCE_DECLINE_WARMUP_PERIOD = h("wickra_advance_decline_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADVANCE_DECLINE_IS_READY = h("wickra_advance_decline_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADVANCE_DECLINE_RESET = h("wickra_advance_decline_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADVANCE_DECLINE_FREE = h("wickra_advance_decline_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADVANCE_DECLINE_RATIO_NEW = h("wickra_advance_decline_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_ADVANCE_DECLINE_RATIO_UPDATE = h("wickra_advance_decline_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_ADVANCE_DECLINE_RATIO_WARMUP_PERIOD = h("wickra_advance_decline_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADVANCE_DECLINE_RATIO_IS_READY = h("wickra_advance_decline_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADVANCE_DECLINE_RATIO_RESET = h("wickra_advance_decline_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADVANCE_DECLINE_RATIO_FREE = h("wickra_advance_decline_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BREADTH_THRUST_NEW = h("wickra_breadth_thrust_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_BREADTH_THRUST_UPDATE = h("wickra_breadth_thrust_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_BREADTH_THRUST_WARMUP_PERIOD = h("wickra_breadth_thrust_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BREADTH_THRUST_IS_READY = h("wickra_breadth_thrust_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BREADTH_THRUST_RESET = h("wickra_breadth_thrust_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BREADTH_THRUST_FREE = h("wickra_breadth_thrust_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BULLISH_PERCENT_INDEX_NEW = h("wickra_bullish_percent_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_BULLISH_PERCENT_INDEX_UPDATE = h("wickra_bullish_percent_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_BULLISH_PERCENT_INDEX_WARMUP_PERIOD = h("wickra_bullish_percent_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BULLISH_PERCENT_INDEX_IS_READY = h("wickra_bullish_percent_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BULLISH_PERCENT_INDEX_RESET = h("wickra_bullish_percent_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BULLISH_PERCENT_INDEX_FREE = h("wickra_bullish_percent_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CUMULATIVE_VOLUME_INDEX_NEW = h("wickra_cumulative_volume_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CUMULATIVE_VOLUME_INDEX_UPDATE = h("wickra_cumulative_volume_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_CUMULATIVE_VOLUME_INDEX_WARMUP_PERIOD = h("wickra_cumulative_volume_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CUMULATIVE_VOLUME_INDEX_IS_READY = h("wickra_cumulative_volume_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CUMULATIVE_VOLUME_INDEX_RESET = h("wickra_cumulative_volume_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CUMULATIVE_VOLUME_INDEX_FREE = h("wickra_cumulative_volume_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_LOW_INDEX_NEW = h("wickra_high_low_index_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_HIGH_LOW_INDEX_UPDATE = h("wickra_high_low_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_HIGH_LOW_INDEX_WARMUP_PERIOD = h("wickra_high_low_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIGH_LOW_INDEX_IS_READY = h("wickra_high_low_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIGH_LOW_INDEX_RESET = h("wickra_high_low_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_LOW_INDEX_FREE = h("wickra_high_low_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MC_CLELLAN_OSCILLATOR_NEW = h("wickra_mc_clellan_oscillator_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MC_CLELLAN_OSCILLATOR_UPDATE = h("wickra_mc_clellan_oscillator_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_MC_CLELLAN_OSCILLATOR_WARMUP_PERIOD = h("wickra_mc_clellan_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MC_CLELLAN_OSCILLATOR_IS_READY = h("wickra_mc_clellan_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MC_CLELLAN_OSCILLATOR_RESET = h("wickra_mc_clellan_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MC_CLELLAN_OSCILLATOR_FREE = h("wickra_mc_clellan_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MC_CLELLAN_SUMMATION_INDEX_NEW = h("wickra_mc_clellan_summation_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_MC_CLELLAN_SUMMATION_INDEX_UPDATE = h("wickra_mc_clellan_summation_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_MC_CLELLAN_SUMMATION_INDEX_WARMUP_PERIOD = h("wickra_mc_clellan_summation_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MC_CLELLAN_SUMMATION_INDEX_IS_READY = h("wickra_mc_clellan_summation_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MC_CLELLAN_SUMMATION_INDEX_RESET = h("wickra_mc_clellan_summation_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MC_CLELLAN_SUMMATION_INDEX_FREE = h("wickra_mc_clellan_summation_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NEW_HIGHS_NEW_LOWS_NEW = h("wickra_new_highs_new_lows_new", FunctionDescriptor.of(ADDRESS)); WICKRA_NEW_HIGHS_NEW_LOWS_UPDATE = h("wickra_new_highs_new_lows_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_NEW_HIGHS_NEW_LOWS_WARMUP_PERIOD = h("wickra_new_highs_new_lows_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_NEW_HIGHS_NEW_LOWS_IS_READY = h("wickra_new_highs_new_lows_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init23() { WICKRA_NEW_HIGHS_NEW_LOWS_RESET = h("wickra_new_highs_new_lows_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NEW_HIGHS_NEW_LOWS_FREE = h("wickra_new_highs_new_lows_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERCENT_ABOVE_MA_NEW = h("wickra_percent_above_ma_new", FunctionDescriptor.of(ADDRESS)); WICKRA_PERCENT_ABOVE_MA_UPDATE = h("wickra_percent_above_ma_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_PERCENT_ABOVE_MA_WARMUP_PERIOD = h("wickra_percent_above_ma_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PERCENT_ABOVE_MA_IS_READY = h("wickra_percent_above_ma_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PERCENT_ABOVE_MA_RESET = h("wickra_percent_above_ma_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PERCENT_ABOVE_MA_FREE = h("wickra_percent_above_ma_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TICK_INDEX_NEW = h("wickra_tick_index_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TICK_INDEX_UPDATE = h("wickra_tick_index_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_TICK_INDEX_WARMUP_PERIOD = h("wickra_tick_index_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TICK_INDEX_IS_READY = h("wickra_tick_index_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TICK_INDEX_RESET = h("wickra_tick_index_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TICK_INDEX_FREE = h("wickra_tick_index_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIN_NEW = h("wickra_trin_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TRIN_UPDATE = h("wickra_trin_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_TRIN_WARMUP_PERIOD = h("wickra_trin_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TRIN_IS_READY = h("wickra_trin_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TRIN_RESET = h("wickra_trin_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TRIN_FREE = h("wickra_trin_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UP_DOWN_VOLUME_RATIO_NEW = h("wickra_up_down_volume_ratio_new", FunctionDescriptor.of(ADDRESS)); WICKRA_UP_DOWN_VOLUME_RATIO_UPDATE = h("wickra_up_down_volume_ratio_update", FunctionDescriptor.of(JAVA_DOUBLE, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, ADDRESS, JAVA_LONG, JAVA_LONG)); + WICKRA_UP_DOWN_VOLUME_RATIO_WARMUP_PERIOD = h("wickra_up_down_volume_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_UP_DOWN_VOLUME_RATIO_IS_READY = h("wickra_up_down_volume_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_UP_DOWN_VOLUME_RATIO_RESET = h("wickra_up_down_volume_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_UP_DOWN_VOLUME_RATIO_FREE = h("wickra_up_down_volume_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ACCELERATION_BANDS_NEW = h("wickra_acceleration_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_ACCELERATION_BANDS_UPDATE = h("wickra_acceleration_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ACCELERATION_BANDS_WARMUP_PERIOD = h("wickra_acceleration_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ACCELERATION_BANDS_IS_READY = h("wickra_acceleration_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ACCELERATION_BANDS_RESET = h("wickra_acceleration_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ACCELERATION_BANDS_FREE = h("wickra_acceleration_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADX_NEW = h("wickra_adx_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ADX_UPDATE = h("wickra_adx_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ADX_WARMUP_PERIOD = h("wickra_adx_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ADX_IS_READY = h("wickra_adx_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ADX_RESET = h("wickra_adx_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ADX_FREE = h("wickra_adx_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ALLIGATOR_NEW = h("wickra_alligator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_ALLIGATOR_UPDATE = h("wickra_alligator_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ALLIGATOR_WARMUP_PERIOD = h("wickra_alligator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ALLIGATOR_IS_READY = h("wickra_alligator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ALLIGATOR_RESET = h("wickra_alligator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ALLIGATOR_FREE = h("wickra_alligator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ANDREWS_PITCHFORK_NEW = h("wickra_andrews_pitchfork_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ANDREWS_PITCHFORK_UPDATE = h("wickra_andrews_pitchfork_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ANDREWS_PITCHFORK_WARMUP_PERIOD = h("wickra_andrews_pitchfork_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ANDREWS_PITCHFORK_IS_READY = h("wickra_andrews_pitchfork_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ANDREWS_PITCHFORK_RESET = h("wickra_andrews_pitchfork_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ANDREWS_PITCHFORK_FREE = h("wickra_andrews_pitchfork_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AROON_NEW = h("wickra_aroon_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_AROON_UPDATE = h("wickra_aroon_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_AROON_WARMUP_PERIOD = h("wickra_aroon_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AROON_IS_READY = h("wickra_aroon_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AROON_RESET = h("wickra_aroon_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AROON_FREE = h("wickra_aroon_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_BANDS_NEW = h("wickra_atr_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_ATR_BANDS_UPDATE = h("wickra_atr_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ATR_BANDS_WARMUP_PERIOD = h("wickra_atr_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ATR_BANDS_IS_READY = h("wickra_atr_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ATR_BANDS_RESET = h("wickra_atr_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_BANDS_FREE = h("wickra_atr_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_RATCHET_NEW = h("wickra_atr_ratchet_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_ATR_RATCHET_UPDATE = h("wickra_atr_ratchet_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ATR_RATCHET_WARMUP_PERIOD = h("wickra_atr_ratchet_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ATR_RATCHET_IS_READY = h("wickra_atr_ratchet_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ATR_RATCHET_RESET = h("wickra_atr_ratchet_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ATR_RATCHET_FREE = h("wickra_atr_ratchet_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AUTO_FIB_NEW = h("wickra_auto_fib_new", FunctionDescriptor.of(ADDRESS)); WICKRA_AUTO_FIB_UPDATE = h("wickra_auto_fib_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_AUTO_FIB_WARMUP_PERIOD = h("wickra_auto_fib_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_AUTO_FIB_IS_READY = h("wickra_auto_fib_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_AUTO_FIB_RESET = h("wickra_auto_fib_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_AUTO_FIB_FREE = h("wickra_auto_fib_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BOLLINGER_BANDS_NEW = h("wickra_bollinger_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_BOLLINGER_BANDS_UPDATE = h("wickra_bollinger_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_BOLLINGER_BANDS_WARMUP_PERIOD = h("wickra_bollinger_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BOLLINGER_BANDS_IS_READY = h("wickra_bollinger_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BOLLINGER_BANDS_RESET = h("wickra_bollinger_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BOLLINGER_BANDS_FREE = h("wickra_bollinger_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BOMAR_BANDS_NEW = h("wickra_bomar_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_BOMAR_BANDS_UPDATE = h("wickra_bomar_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_BOMAR_BANDS_WARMUP_PERIOD = h("wickra_bomar_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_BOMAR_BANDS_IS_READY = h("wickra_bomar_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_BOMAR_BANDS_RESET = h("wickra_bomar_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_BOMAR_BANDS_FREE = h("wickra_bomar_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CAMARILLA_NEW = h("wickra_camarilla_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CAMARILLA_UPDATE = h("wickra_camarilla_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_CAMARILLA_WARMUP_PERIOD = h("wickra_camarilla_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CAMARILLA_IS_READY = h("wickra_camarilla_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CAMARILLA_RESET = h("wickra_camarilla_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CAMARILLA_FREE = h("wickra_camarilla_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CANDLE_VOLUME_NEW = h("wickra_candle_volume_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_CANDLE_VOLUME_UPDATE = h("wickra_candle_volume_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_CANDLE_VOLUME_WARMUP_PERIOD = h("wickra_candle_volume_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CANDLE_VOLUME_IS_READY = h("wickra_candle_volume_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CANDLE_VOLUME_RESET = h("wickra_candle_volume_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CANDLE_VOLUME_FREE = h("wickra_candle_volume_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CENTRAL_PIVOT_RANGE_NEW = h("wickra_central_pivot_range_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CENTRAL_PIVOT_RANGE_UPDATE = h("wickra_central_pivot_range_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_CENTRAL_PIVOT_RANGE_WARMUP_PERIOD = h("wickra_central_pivot_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CENTRAL_PIVOT_RANGE_IS_READY = h("wickra_central_pivot_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CENTRAL_PIVOT_RANGE_RESET = h("wickra_central_pivot_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CENTRAL_PIVOT_RANGE_FREE = h("wickra_central_pivot_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHANDE_KROLL_STOP_NEW = h("wickra_chande_kroll_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_LONG)); WICKRA_CHANDE_KROLL_STOP_UPDATE = h("wickra_chande_kroll_stop_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_CHANDE_KROLL_STOP_WARMUP_PERIOD = h("wickra_chande_kroll_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CHANDE_KROLL_STOP_IS_READY = h("wickra_chande_kroll_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CHANDE_KROLL_STOP_RESET = h("wickra_chande_kroll_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHANDE_KROLL_STOP_FREE = h("wickra_chande_kroll_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHANDELIER_EXIT_NEW = h("wickra_chandelier_exit_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_CHANDELIER_EXIT_UPDATE = h("wickra_chandelier_exit_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_CHANDELIER_EXIT_WARMUP_PERIOD = h("wickra_chandelier_exit_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CHANDELIER_EXIT_IS_READY = h("wickra_chandelier_exit_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_CHANDELIER_EXIT_RESET = h("wickra_chandelier_exit_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CHANDELIER_EXIT_FREE = h("wickra_chandelier_exit_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_CLASSIC_PIVOTS_NEW = h("wickra_classic_pivots_new", FunctionDescriptor.of(ADDRESS)); WICKRA_CLASSIC_PIVOTS_UPDATE = h("wickra_classic_pivots_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); - WICKRA_CLASSIC_PIVOTS_RESET = h("wickra_classic_pivots_reset", FunctionDescriptor.ofVoid(ADDRESS)); - WICKRA_CLASSIC_PIVOTS_FREE = h("wickra_classic_pivots_free", FunctionDescriptor.ofVoid(ADDRESS)); + WICKRA_CLASSIC_PIVOTS_WARMUP_PERIOD = h("wickra_classic_pivots_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_CLASSIC_PIVOTS_IS_READY = h("wickra_classic_pivots_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); } - private static void init17() { + private static void init24() { + WICKRA_CLASSIC_PIVOTS_RESET = h("wickra_classic_pivots_reset", FunctionDescriptor.ofVoid(ADDRESS)); + WICKRA_CLASSIC_PIVOTS_FREE = h("wickra_classic_pivots_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COINTEGRATION_NEW = h("wickra_cointegration_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_COINTEGRATION_UPDATE = h("wickra_cointegration_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, ADDRESS)); + WICKRA_COINTEGRATION_WARMUP_PERIOD = h("wickra_cointegration_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_COINTEGRATION_IS_READY = h("wickra_cointegration_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_COINTEGRATION_RESET = h("wickra_cointegration_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COINTEGRATION_FREE = h("wickra_cointegration_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COMPOSITE_PROFILE_NEW = h("wickra_composite_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_COMPOSITE_PROFILE_UPDATE = h("wickra_composite_profile_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_COMPOSITE_PROFILE_WARMUP_PERIOD = h("wickra_composite_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_COMPOSITE_PROFILE_IS_READY = h("wickra_composite_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_COMPOSITE_PROFILE_RESET = h("wickra_composite_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_COMPOSITE_PROFILE_FREE = h("wickra_composite_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEMARK_PIVOTS_NEW = h("wickra_demark_pivots_new", FunctionDescriptor.of(ADDRESS)); WICKRA_DEMARK_PIVOTS_UPDATE = h("wickra_demark_pivots_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_DEMARK_PIVOTS_WARMUP_PERIOD = h("wickra_demark_pivots_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DEMARK_PIVOTS_IS_READY = h("wickra_demark_pivots_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DEMARK_PIVOTS_RESET = h("wickra_demark_pivots_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DEMARK_PIVOTS_FREE = h("wickra_demark_pivots_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DONCHIAN_NEW = h("wickra_donchian_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DONCHIAN_UPDATE = h("wickra_donchian_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_DONCHIAN_WARMUP_PERIOD = h("wickra_donchian_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DONCHIAN_IS_READY = h("wickra_donchian_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DONCHIAN_RESET = h("wickra_donchian_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DONCHIAN_FREE = h("wickra_donchian_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DONCHIAN_STOP_NEW = h("wickra_donchian_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_DONCHIAN_STOP_UPDATE = h("wickra_donchian_stop_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_DONCHIAN_STOP_WARMUP_PERIOD = h("wickra_donchian_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DONCHIAN_STOP_IS_READY = h("wickra_donchian_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DONCHIAN_STOP_RESET = h("wickra_donchian_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DONCHIAN_STOP_FREE = h("wickra_donchian_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOUBLE_BOLLINGER_NEW = h("wickra_double_bollinger_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_DOUBLE_BOLLINGER_UPDATE = h("wickra_double_bollinger_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_DOUBLE_BOLLINGER_WARMUP_PERIOD = h("wickra_double_bollinger_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DOUBLE_BOLLINGER_IS_READY = h("wickra_double_bollinger_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DOUBLE_BOLLINGER_RESET = h("wickra_double_bollinger_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOUBLE_BOLLINGER_FREE = h("wickra_double_bollinger_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ELDER_RAY_NEW = h("wickra_elder_ray_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_ELDER_RAY_UPDATE = h("wickra_elder_ray_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ELDER_RAY_WARMUP_PERIOD = h("wickra_elder_ray_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ELDER_RAY_IS_READY = h("wickra_elder_ray_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ELDER_RAY_RESET = h("wickra_elder_ray_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ELDER_RAY_FREE = h("wickra_elder_ray_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ELDER_SAFE_ZONE_NEW = h("wickra_elder_safe_zone_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_ELDER_SAFE_ZONE_UPDATE = h("wickra_elder_safe_zone_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ELDER_SAFE_ZONE_WARMUP_PERIOD = h("wickra_elder_safe_zone_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ELDER_SAFE_ZONE_IS_READY = h("wickra_elder_safe_zone_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ELDER_SAFE_ZONE_RESET = h("wickra_elder_safe_zone_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ELDER_SAFE_ZONE_FREE = h("wickra_elder_safe_zone_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EQUIVOLUME_NEW = h("wickra_equivolume_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_EQUIVOLUME_UPDATE = h("wickra_equivolume_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_EQUIVOLUME_WARMUP_PERIOD = h("wickra_equivolume_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_EQUIVOLUME_IS_READY = h("wickra_equivolume_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_EQUIVOLUME_RESET = h("wickra_equivolume_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_EQUIVOLUME_FREE = h("wickra_equivolume_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_ARCS_NEW = h("wickra_fib_arcs_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_ARCS_UPDATE = h("wickra_fib_arcs_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_ARCS_WARMUP_PERIOD = h("wickra_fib_arcs_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_ARCS_IS_READY = h("wickra_fib_arcs_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_ARCS_RESET = h("wickra_fib_arcs_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_ARCS_FREE = h("wickra_fib_arcs_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_CHANNEL_NEW = h("wickra_fib_channel_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_CHANNEL_UPDATE = h("wickra_fib_channel_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_CHANNEL_WARMUP_PERIOD = h("wickra_fib_channel_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_CHANNEL_IS_READY = h("wickra_fib_channel_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_CHANNEL_RESET = h("wickra_fib_channel_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_CHANNEL_FREE = h("wickra_fib_channel_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_CONFLUENCE_NEW = h("wickra_fib_confluence_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_CONFLUENCE_UPDATE = h("wickra_fib_confluence_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_CONFLUENCE_WARMUP_PERIOD = h("wickra_fib_confluence_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_CONFLUENCE_IS_READY = h("wickra_fib_confluence_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_CONFLUENCE_RESET = h("wickra_fib_confluence_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_CONFLUENCE_FREE = h("wickra_fib_confluence_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_EXTENSION_NEW = h("wickra_fib_extension_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_EXTENSION_UPDATE = h("wickra_fib_extension_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_EXTENSION_WARMUP_PERIOD = h("wickra_fib_extension_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_EXTENSION_IS_READY = h("wickra_fib_extension_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_EXTENSION_RESET = h("wickra_fib_extension_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_EXTENSION_FREE = h("wickra_fib_extension_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_FAN_NEW = h("wickra_fib_fan_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_FAN_UPDATE = h("wickra_fib_fan_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_FAN_WARMUP_PERIOD = h("wickra_fib_fan_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_FAN_IS_READY = h("wickra_fib_fan_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_FAN_RESET = h("wickra_fib_fan_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_FAN_FREE = h("wickra_fib_fan_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_PROJECTION_NEW = h("wickra_fib_projection_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_PROJECTION_UPDATE = h("wickra_fib_projection_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_PROJECTION_WARMUP_PERIOD = h("wickra_fib_projection_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_PROJECTION_IS_READY = h("wickra_fib_projection_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_PROJECTION_RESET = h("wickra_fib_projection_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_PROJECTION_FREE = h("wickra_fib_projection_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_RETRACEMENT_NEW = h("wickra_fib_retracement_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_RETRACEMENT_UPDATE = h("wickra_fib_retracement_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_RETRACEMENT_WARMUP_PERIOD = h("wickra_fib_retracement_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_RETRACEMENT_IS_READY = h("wickra_fib_retracement_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_RETRACEMENT_RESET = h("wickra_fib_retracement_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_RETRACEMENT_FREE = h("wickra_fib_retracement_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_TIME_ZONES_NEW = h("wickra_fib_time_zones_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIB_TIME_ZONES_UPDATE = h("wickra_fib_time_zones_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIB_TIME_ZONES_WARMUP_PERIOD = h("wickra_fib_time_zones_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIB_TIME_ZONES_IS_READY = h("wickra_fib_time_zones_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIB_TIME_ZONES_RESET = h("wickra_fib_time_zones_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIB_TIME_ZONES_FREE = h("wickra_fib_time_zones_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIBONACCI_PIVOTS_NEW = h("wickra_fibonacci_pivots_new", FunctionDescriptor.of(ADDRESS)); WICKRA_FIBONACCI_PIVOTS_UPDATE = h("wickra_fibonacci_pivots_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FIBONACCI_PIVOTS_WARMUP_PERIOD = h("wickra_fibonacci_pivots_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FIBONACCI_PIVOTS_IS_READY = h("wickra_fibonacci_pivots_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FIBONACCI_PIVOTS_RESET = h("wickra_fibonacci_pivots_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FIBONACCI_PIVOTS_FREE = h("wickra_fibonacci_pivots_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FRACTAL_CHAOS_BANDS_NEW = h("wickra_fractal_chaos_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_FRACTAL_CHAOS_BANDS_UPDATE = h("wickra_fractal_chaos_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_FRACTAL_CHAOS_BANDS_WARMUP_PERIOD = h("wickra_fractal_chaos_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FRACTAL_CHAOS_BANDS_IS_READY = h("wickra_fractal_chaos_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FRACTAL_CHAOS_BANDS_RESET = h("wickra_fractal_chaos_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FRACTAL_CHAOS_BANDS_FREE = h("wickra_fractal_chaos_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GATOR_OSCILLATOR_NEW = h("wickra_gator_oscillator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_GATOR_OSCILLATOR_UPDATE = h("wickra_gator_oscillator_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_GATOR_OSCILLATOR_WARMUP_PERIOD = h("wickra_gator_oscillator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GATOR_OSCILLATOR_IS_READY = h("wickra_gator_oscillator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init25() { WICKRA_GATOR_OSCILLATOR_RESET = h("wickra_gator_oscillator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GATOR_OSCILLATOR_FREE = h("wickra_gator_oscillator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GOLDEN_POCKET_NEW = h("wickra_golden_pocket_new", FunctionDescriptor.of(ADDRESS)); WICKRA_GOLDEN_POCKET_UPDATE = h("wickra_golden_pocket_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_GOLDEN_POCKET_WARMUP_PERIOD = h("wickra_golden_pocket_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_GOLDEN_POCKET_IS_READY = h("wickra_golden_pocket_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_GOLDEN_POCKET_RESET = h("wickra_golden_pocket_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_GOLDEN_POCKET_FREE = h("wickra_golden_pocket_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HEIKIN_ASHI_NEW = h("wickra_heikin_ashi_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HEIKIN_ASHI_UPDATE = h("wickra_heikin_ashi_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_HEIKIN_ASHI_WARMUP_PERIOD = h("wickra_heikin_ashi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HEIKIN_ASHI_IS_READY = h("wickra_heikin_ashi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HEIKIN_ASHI_RESET = h("wickra_heikin_ashi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HEIKIN_ASHI_FREE = h("wickra_heikin_ashi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_LOW_VOLUME_NODES_NEW = h("wickra_high_low_volume_nodes_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_HIGH_LOW_VOLUME_NODES_UPDATE = h("wickra_high_low_volume_nodes_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_HIGH_LOW_VOLUME_NODES_WARMUP_PERIOD = h("wickra_high_low_volume_nodes_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HIGH_LOW_VOLUME_NODES_IS_READY = h("wickra_high_low_volume_nodes_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HIGH_LOW_VOLUME_NODES_RESET = h("wickra_high_low_volume_nodes_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HIGH_LOW_VOLUME_NODES_FREE = h("wickra_high_low_volume_nodes_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HT_PHASOR_NEW = h("wickra_ht_phasor_new", FunctionDescriptor.of(ADDRESS)); WICKRA_HT_PHASOR_UPDATE = h("wickra_ht_phasor_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_HT_PHASOR_WARMUP_PERIOD = h("wickra_ht_phasor_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HT_PHASOR_IS_READY = h("wickra_ht_phasor_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HT_PHASOR_RESET = h("wickra_ht_phasor_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HT_PHASOR_FREE = h("wickra_ht_phasor_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HURST_CHANNEL_NEW = h("wickra_hurst_channel_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_HURST_CHANNEL_UPDATE = h("wickra_hurst_channel_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_HURST_CHANNEL_WARMUP_PERIOD = h("wickra_hurst_channel_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_HURST_CHANNEL_IS_READY = h("wickra_hurst_channel_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_HURST_CHANNEL_RESET = h("wickra_hurst_channel_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_HURST_CHANNEL_FREE = h("wickra_hurst_channel_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ICHIMOKU_NEW = h("wickra_ichimoku_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_ICHIMOKU_UPDATE = h("wickra_ichimoku_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ICHIMOKU_WARMUP_PERIOD = h("wickra_ichimoku_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ICHIMOKU_IS_READY = h("wickra_ichimoku_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ICHIMOKU_RESET = h("wickra_ichimoku_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ICHIMOKU_FREE = h("wickra_ichimoku_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INITIAL_BALANCE_NEW = h("wickra_initial_balance_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_INITIAL_BALANCE_UPDATE = h("wickra_initial_balance_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_INITIAL_BALANCE_WARMUP_PERIOD = h("wickra_initial_balance_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INITIAL_BALANCE_IS_READY = h("wickra_initial_balance_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INITIAL_BALANCE_RESET = h("wickra_initial_balance_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INITIAL_BALANCE_FREE = h("wickra_initial_balance_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KALMAN_HEDGE_RATIO_NEW = h("wickra_kalman_hedge_ratio_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_KALMAN_HEDGE_RATIO_UPDATE = h("wickra_kalman_hedge_ratio_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, ADDRESS)); + WICKRA_KALMAN_HEDGE_RATIO_WARMUP_PERIOD = h("wickra_kalman_hedge_ratio_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KALMAN_HEDGE_RATIO_IS_READY = h("wickra_kalman_hedge_ratio_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KALMAN_HEDGE_RATIO_RESET = h("wickra_kalman_hedge_ratio_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KALMAN_HEDGE_RATIO_FREE = h("wickra_kalman_hedge_ratio_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KASE_DEV_STOP_NEW = h("wickra_kase_dev_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_KASE_DEV_STOP_UPDATE = h("wickra_kase_dev_stop_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_KASE_DEV_STOP_WARMUP_PERIOD = h("wickra_kase_dev_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KASE_DEV_STOP_IS_READY = h("wickra_kase_dev_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KASE_DEV_STOP_RESET = h("wickra_kase_dev_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KASE_DEV_STOP_FREE = h("wickra_kase_dev_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KASE_PERMISSION_STOCHASTIC_NEW = h("wickra_kase_permission_stochastic_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_KASE_PERMISSION_STOCHASTIC_UPDATE = h("wickra_kase_permission_stochastic_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_KASE_PERMISSION_STOCHASTIC_WARMUP_PERIOD = h("wickra_kase_permission_stochastic_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KASE_PERMISSION_STOCHASTIC_IS_READY = h("wickra_kase_permission_stochastic_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KASE_PERMISSION_STOCHASTIC_RESET = h("wickra_kase_permission_stochastic_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KASE_PERMISSION_STOCHASTIC_FREE = h("wickra_kase_permission_stochastic_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init18() { WICKRA_KELTNER_NEW = h("wickra_keltner_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_KELTNER_UPDATE = h("wickra_keltner_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_KELTNER_WARMUP_PERIOD = h("wickra_keltner_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KELTNER_IS_READY = h("wickra_keltner_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KELTNER_RESET = h("wickra_keltner_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KELTNER_FREE = h("wickra_keltner_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KST_NEW = h("wickra_kst_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_KST_UPDATE = h("wickra_kst_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_KST_WARMUP_PERIOD = h("wickra_kst_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_KST_IS_READY = h("wickra_kst_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_KST_RESET = h("wickra_kst_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_KST_FREE = h("wickra_kst_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LEAD_LAG_CROSS_CORRELATION_NEW = h("wickra_lead_lag_cross_correlation_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_LEAD_LAG_CROSS_CORRELATION_UPDATE = h("wickra_lead_lag_cross_correlation_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, ADDRESS)); + WICKRA_LEAD_LAG_CROSS_CORRELATION_WARMUP_PERIOD = h("wickra_lead_lag_cross_correlation_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LEAD_LAG_CROSS_CORRELATION_IS_READY = h("wickra_lead_lag_cross_correlation_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LEAD_LAG_CROSS_CORRELATION_RESET = h("wickra_lead_lag_cross_correlation_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LEAD_LAG_CROSS_CORRELATION_FREE = h("wickra_lead_lag_cross_correlation_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_CHANNEL_NEW = h("wickra_lin_reg_channel_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_LIN_REG_CHANNEL_UPDATE = h("wickra_lin_reg_channel_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_LIN_REG_CHANNEL_WARMUP_PERIOD = h("wickra_lin_reg_channel_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LIN_REG_CHANNEL_IS_READY = h("wickra_lin_reg_channel_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LIN_REG_CHANNEL_RESET = h("wickra_lin_reg_channel_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIN_REG_CHANNEL_FREE = h("wickra_lin_reg_channel_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIQUIDATION_FEATURES_NEW = h("wickra_liquidation_features_new", FunctionDescriptor.of(ADDRESS)); WICKRA_LIQUIDATION_FEATURES_UPDATE = h("wickra_liquidation_features_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_LIQUIDATION_FEATURES_WARMUP_PERIOD = h("wickra_liquidation_features_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_LIQUIDATION_FEATURES_IS_READY = h("wickra_liquidation_features_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_LIQUIDATION_FEATURES_RESET = h("wickra_liquidation_features_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_LIQUIDATION_FEATURES_FREE = h("wickra_liquidation_features_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MA_ENVELOPE_NEW = h("wickra_ma_envelope_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_MA_ENVELOPE_UPDATE = h("wickra_ma_envelope_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_MA_ENVELOPE_WARMUP_PERIOD = h("wickra_ma_envelope_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MA_ENVELOPE_IS_READY = h("wickra_ma_envelope_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MA_ENVELOPE_RESET = h("wickra_ma_envelope_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MA_ENVELOPE_FREE = h("wickra_ma_envelope_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_INDICATOR_NEW = h("wickra_macd_indicator_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_MACD_INDICATOR_UPDATE = h("wickra_macd_indicator_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_MACD_INDICATOR_WARMUP_PERIOD = h("wickra_macd_indicator_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MACD_INDICATOR_IS_READY = h("wickra_macd_indicator_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MACD_INDICATOR_RESET = h("wickra_macd_indicator_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_INDICATOR_FREE = h("wickra_macd_indicator_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_FIX_NEW = h("wickra_macd_fix_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MACD_FIX_UPDATE = h("wickra_macd_fix_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_MACD_FIX_WARMUP_PERIOD = h("wickra_macd_fix_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MACD_FIX_IS_READY = h("wickra_macd_fix_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MACD_FIX_RESET = h("wickra_macd_fix_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_FIX_FREE = h("wickra_macd_fix_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MAMA_NEW = h("wickra_mama_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_MAMA_UPDATE = h("wickra_mama_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_MAMA_WARMUP_PERIOD = h("wickra_mama_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MAMA_IS_READY = h("wickra_mama_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MAMA_RESET = h("wickra_mama_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MAMA_FREE = h("wickra_mama_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_CHANNEL_NEW = h("wickra_median_channel_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_MEDIAN_CHANNEL_UPDATE = h("wickra_median_channel_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_MEDIAN_CHANNEL_WARMUP_PERIOD = h("wickra_median_channel_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MEDIAN_CHANNEL_IS_READY = h("wickra_median_channel_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init26() { WICKRA_MEDIAN_CHANNEL_RESET = h("wickra_median_channel_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MEDIAN_CHANNEL_FREE = h("wickra_median_channel_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MODIFIED_MA_STOP_NEW = h("wickra_modified_ma_stop_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MODIFIED_MA_STOP_UPDATE = h("wickra_modified_ma_stop_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_MODIFIED_MA_STOP_WARMUP_PERIOD = h("wickra_modified_ma_stop_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MODIFIED_MA_STOP_IS_READY = h("wickra_modified_ma_stop_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MODIFIED_MA_STOP_RESET = h("wickra_modified_ma_stop_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MODIFIED_MA_STOP_FREE = h("wickra_modified_ma_stop_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MURREY_MATH_LINES_NEW = h("wickra_murrey_math_lines_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_MURREY_MATH_LINES_UPDATE = h("wickra_murrey_math_lines_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_MURREY_MATH_LINES_WARMUP_PERIOD = h("wickra_murrey_math_lines_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MURREY_MATH_LINES_IS_READY = h("wickra_murrey_math_lines_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MURREY_MATH_LINES_RESET = h("wickra_murrey_math_lines_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MURREY_MATH_LINES_FREE = h("wickra_murrey_math_lines_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NRTR_NEW = h("wickra_nrtr_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_NRTR_UPDATE = h("wickra_nrtr_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_NRTR_WARMUP_PERIOD = h("wickra_nrtr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_NRTR_IS_READY = h("wickra_nrtr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_NRTR_RESET = h("wickra_nrtr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_NRTR_FREE = h("wickra_nrtr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPENING_RANGE_NEW = h("wickra_opening_range_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_OPENING_RANGE_UPDATE = h("wickra_opening_range_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_OPENING_RANGE_WARMUP_PERIOD = h("wickra_opening_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OPENING_RANGE_IS_READY = h("wickra_opening_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OPENING_RANGE_RESET = h("wickra_opening_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OPENING_RANGE_FREE = h("wickra_opening_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OVERNIGHT_INTRADAY_RETURN_NEW = h("wickra_overnight_intraday_return_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_OVERNIGHT_INTRADAY_RETURN_UPDATE = h("wickra_overnight_intraday_return_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_OVERNIGHT_INTRADAY_RETURN_WARMUP_PERIOD = h("wickra_overnight_intraday_return_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_OVERNIGHT_INTRADAY_RETURN_IS_READY = h("wickra_overnight_intraday_return_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_OVERNIGHT_INTRADAY_RETURN_RESET = h("wickra_overnight_intraday_return_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_OVERNIGHT_INTRADAY_RETURN_FREE = h("wickra_overnight_intraday_return_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROJECTION_BANDS_NEW = h("wickra_projection_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_PROJECTION_BANDS_UPDATE = h("wickra_projection_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_PROJECTION_BANDS_WARMUP_PERIOD = h("wickra_projection_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_PROJECTION_BANDS_IS_READY = h("wickra_projection_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_PROJECTION_BANDS_RESET = h("wickra_projection_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_PROJECTION_BANDS_FREE = h("wickra_projection_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QQE_NEW = h("wickra_qqe_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_QQE_UPDATE = h("wickra_qqe_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_QQE_WARMUP_PERIOD = h("wickra_qqe_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_QQE_IS_READY = h("wickra_qqe_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_QQE_RESET = h("wickra_qqe_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QQE_FREE = h("wickra_qqe_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QUARTILE_BANDS_NEW = h("wickra_quartile_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_QUARTILE_BANDS_UPDATE = h("wickra_quartile_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_QUARTILE_BANDS_WARMUP_PERIOD = h("wickra_quartile_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_QUARTILE_BANDS_IS_READY = h("wickra_quartile_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_QUARTILE_BANDS_RESET = h("wickra_quartile_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_QUARTILE_BANDS_FREE = h("wickra_quartile_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RELATIVE_STRENGTH_AB_NEW = h("wickra_relative_strength_ab_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_RELATIVE_STRENGTH_AB_UPDATE = h("wickra_relative_strength_ab_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, ADDRESS)); + WICKRA_RELATIVE_STRENGTH_AB_WARMUP_PERIOD = h("wickra_relative_strength_ab_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RELATIVE_STRENGTH_AB_IS_READY = h("wickra_relative_strength_ab_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RELATIVE_STRENGTH_AB_RESET = h("wickra_relative_strength_ab_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RELATIVE_STRENGTH_AB_FREE = h("wickra_relative_strength_ab_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RWI_NEW = h("wickra_rwi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_RWI_UPDATE = h("wickra_rwi_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_RWI_WARMUP_PERIOD = h("wickra_rwi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_RWI_IS_READY = h("wickra_rwi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_RWI_RESET = h("wickra_rwi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_RWI_FREE = h("wickra_rwi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SESSION_HIGH_LOW_NEW = h("wickra_session_high_low_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_SESSION_HIGH_LOW_UPDATE = h("wickra_session_high_low_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_SESSION_HIGH_LOW_WARMUP_PERIOD = h("wickra_session_high_low_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SESSION_HIGH_LOW_IS_READY = h("wickra_session_high_low_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SESSION_HIGH_LOW_RESET = h("wickra_session_high_low_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SESSION_HIGH_LOW_FREE = h("wickra_session_high_low_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SESSION_RANGE_NEW = h("wickra_session_range_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_SESSION_RANGE_UPDATE = h("wickra_session_range_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_SESSION_RANGE_WARMUP_PERIOD = h("wickra_session_range_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SESSION_RANGE_IS_READY = h("wickra_session_range_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SESSION_RANGE_RESET = h("wickra_session_range_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SESSION_RANGE_FREE = h("wickra_session_range_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMOOTHED_HEIKIN_ASHI_NEW = h("wickra_smoothed_heikin_ashi_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_SMOOTHED_HEIKIN_ASHI_UPDATE = h("wickra_smoothed_heikin_ashi_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_SMOOTHED_HEIKIN_ASHI_WARMUP_PERIOD = h("wickra_smoothed_heikin_ashi_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SMOOTHED_HEIKIN_ASHI_IS_READY = h("wickra_smoothed_heikin_ashi_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SMOOTHED_HEIKIN_ASHI_RESET = h("wickra_smoothed_heikin_ashi_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SMOOTHED_HEIKIN_ASHI_FREE = h("wickra_smoothed_heikin_ashi_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPREAD_BOLLINGER_BANDS_NEW = h("wickra_spread_bollinger_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_SPREAD_BOLLINGER_BANDS_UPDATE = h("wickra_spread_bollinger_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, ADDRESS)); + WICKRA_SPREAD_BOLLINGER_BANDS_WARMUP_PERIOD = h("wickra_spread_bollinger_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SPREAD_BOLLINGER_BANDS_IS_READY = h("wickra_spread_bollinger_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SPREAD_BOLLINGER_BANDS_RESET = h("wickra_spread_bollinger_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SPREAD_BOLLINGER_BANDS_FREE = h("wickra_spread_bollinger_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STANDARD_ERROR_BANDS_NEW = h("wickra_standard_error_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_STANDARD_ERROR_BANDS_UPDATE = h("wickra_standard_error_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_STANDARD_ERROR_BANDS_WARMUP_PERIOD = h("wickra_standard_error_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STANDARD_ERROR_BANDS_IS_READY = h("wickra_standard_error_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STANDARD_ERROR_BANDS_RESET = h("wickra_standard_error_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STANDARD_ERROR_BANDS_FREE = h("wickra_standard_error_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STARC_BANDS_NEW = h("wickra_starc_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_STARC_BANDS_UPDATE = h("wickra_starc_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_STARC_BANDS_WARMUP_PERIOD = h("wickra_starc_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STARC_BANDS_IS_READY = h("wickra_starc_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STARC_BANDS_RESET = h("wickra_starc_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STARC_BANDS_FREE = h("wickra_starc_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STOCHASTIC_NEW = h("wickra_stochastic_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_STOCHASTIC_UPDATE = h("wickra_stochastic_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_STOCHASTIC_WARMUP_PERIOD = h("wickra_stochastic_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_STOCHASTIC_IS_READY = h("wickra_stochastic_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_STOCHASTIC_RESET = h("wickra_stochastic_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_STOCHASTIC_FREE = h("wickra_stochastic_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SUPER_TREND_NEW = h("wickra_super_trend_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE)); WICKRA_SUPER_TREND_UPDATE = h("wickra_super_trend_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_SUPER_TREND_WARMUP_PERIOD = h("wickra_super_trend_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_SUPER_TREND_IS_READY = h("wickra_super_trend_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_SUPER_TREND_RESET = h("wickra_super_trend_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_SUPER_TREND_FREE = h("wickra_super_trend_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_LINES_NEW = h("wickra_td_lines_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_TD_LINES_UPDATE = h("wickra_td_lines_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_TD_LINES_WARMUP_PERIOD = h("wickra_td_lines_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_LINES_IS_READY = h("wickra_td_lines_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_LINES_RESET = h("wickra_td_lines_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_LINES_FREE = h("wickra_td_lines_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_MOVING_AVERAGE_NEW = h("wickra_td_moving_average_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_TD_MOVING_AVERAGE_UPDATE = h("wickra_td_moving_average_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); - WICKRA_TD_MOVING_AVERAGE_RESET = h("wickra_td_moving_average_reset", FunctionDescriptor.ofVoid(ADDRESS)); - WICKRA_TD_MOVING_AVERAGE_FREE = h("wickra_td_moving_average_free", FunctionDescriptor.ofVoid(ADDRESS)); + WICKRA_TD_MOVING_AVERAGE_WARMUP_PERIOD = h("wickra_td_moving_average_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_MOVING_AVERAGE_IS_READY = h("wickra_td_moving_average_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); } - private static void init19() { + private static void init27() { + WICKRA_TD_MOVING_AVERAGE_RESET = h("wickra_td_moving_average_reset", FunctionDescriptor.ofVoid(ADDRESS)); + WICKRA_TD_MOVING_AVERAGE_FREE = h("wickra_td_moving_average_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_RANGE_PROJECTION_NEW = h("wickra_td_range_projection_new", FunctionDescriptor.of(ADDRESS)); WICKRA_TD_RANGE_PROJECTION_UPDATE = h("wickra_td_range_projection_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_TD_RANGE_PROJECTION_WARMUP_PERIOD = h("wickra_td_range_projection_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_RANGE_PROJECTION_IS_READY = h("wickra_td_range_projection_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_RANGE_PROJECTION_RESET = h("wickra_td_range_projection_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_RANGE_PROJECTION_FREE = h("wickra_td_range_projection_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_RISK_LEVEL_NEW = h("wickra_td_risk_level_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_TD_RISK_LEVEL_UPDATE = h("wickra_td_risk_level_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_TD_RISK_LEVEL_WARMUP_PERIOD = h("wickra_td_risk_level_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_RISK_LEVEL_IS_READY = h("wickra_td_risk_level_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_RISK_LEVEL_RESET = h("wickra_td_risk_level_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_RISK_LEVEL_FREE = h("wickra_td_risk_level_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_SEQUENTIAL_NEW = h("wickra_td_sequential_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_TD_SEQUENTIAL_UPDATE = h("wickra_td_sequential_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_TD_SEQUENTIAL_WARMUP_PERIOD = h("wickra_td_sequential_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TD_SEQUENTIAL_IS_READY = h("wickra_td_sequential_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TD_SEQUENTIAL_RESET = h("wickra_td_sequential_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TD_SEQUENTIAL_FREE = h("wickra_td_sequential_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TTM_SQUEEZE_NEW = h("wickra_ttm_squeeze_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_DOUBLE, JAVA_DOUBLE)); WICKRA_TTM_SQUEEZE_UPDATE = h("wickra_ttm_squeeze_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_TTM_SQUEEZE_WARMUP_PERIOD = h("wickra_ttm_squeeze_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TTM_SQUEEZE_IS_READY = h("wickra_ttm_squeeze_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TTM_SQUEEZE_RESET = h("wickra_ttm_squeeze_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TTM_SQUEEZE_FREE = h("wickra_ttm_squeeze_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VALUE_AREA_NEW = h("wickra_value_area_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_DOUBLE)); WICKRA_VALUE_AREA_UPDATE = h("wickra_value_area_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_VALUE_AREA_WARMUP_PERIOD = h("wickra_value_area_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VALUE_AREA_IS_READY = h("wickra_value_area_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VALUE_AREA_RESET = h("wickra_value_area_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VALUE_AREA_FREE = h("wickra_value_area_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLATILITY_CONE_NEW = h("wickra_volatility_cone_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_VOLATILITY_CONE_UPDATE = h("wickra_volatility_cone_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_VOLATILITY_CONE_WARMUP_PERIOD = h("wickra_volatility_cone_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLATILITY_CONE_IS_READY = h("wickra_volatility_cone_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLATILITY_CONE_RESET = h("wickra_volatility_cone_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLATILITY_CONE_FREE = h("wickra_volatility_cone_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_WEIGHTED_MACD_NEW = h("wickra_volume_weighted_macd_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_VOLUME_WEIGHTED_MACD_UPDATE = h("wickra_volume_weighted_macd_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_WEIGHTED_MACD_WARMUP_PERIOD = h("wickra_volume_weighted_macd_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_WEIGHTED_MACD_IS_READY = h("wickra_volume_weighted_macd_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLUME_WEIGHTED_MACD_RESET = h("wickra_volume_weighted_macd_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_WEIGHTED_MACD_FREE = h("wickra_volume_weighted_macd_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_WEIGHTED_SR_NEW = h("wickra_volume_weighted_sr_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VOLUME_WEIGHTED_SR_UPDATE = h("wickra_volume_weighted_sr_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_WEIGHTED_SR_WARMUP_PERIOD = h("wickra_volume_weighted_sr_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_WEIGHTED_SR_IS_READY = h("wickra_volume_weighted_sr_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLUME_WEIGHTED_SR_RESET = h("wickra_volume_weighted_sr_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_WEIGHTED_SR_FREE = h("wickra_volume_weighted_sr_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VORTEX_NEW = h("wickra_vortex_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG)); WICKRA_VORTEX_UPDATE = h("wickra_vortex_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_VORTEX_WARMUP_PERIOD = h("wickra_vortex_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VORTEX_IS_READY = h("wickra_vortex_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VORTEX_RESET = h("wickra_vortex_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VORTEX_FREE = h("wickra_vortex_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VWAP_STD_DEV_BANDS_NEW = h("wickra_vwap_std_dev_bands_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_VWAP_STD_DEV_BANDS_UPDATE = h("wickra_vwap_std_dev_bands_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_VWAP_STD_DEV_BANDS_WARMUP_PERIOD = h("wickra_vwap_std_dev_bands_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VWAP_STD_DEV_BANDS_IS_READY = h("wickra_vwap_std_dev_bands_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VWAP_STD_DEV_BANDS_RESET = h("wickra_vwap_std_dev_bands_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VWAP_STD_DEV_BANDS_FREE = h("wickra_vwap_std_dev_bands_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WAVE_TREND_NEW = h("wickra_wave_trend_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_WAVE_TREND_UPDATE = h("wickra_wave_trend_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_WAVE_TREND_WARMUP_PERIOD = h("wickra_wave_trend_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WAVE_TREND_IS_READY = h("wickra_wave_trend_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WAVE_TREND_RESET = h("wickra_wave_trend_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WAVE_TREND_FREE = h("wickra_wave_trend_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WILLIAMS_FRACTALS_NEW = h("wickra_williams_fractals_new", FunctionDescriptor.of(ADDRESS)); WICKRA_WILLIAMS_FRACTALS_UPDATE = h("wickra_williams_fractals_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_WILLIAMS_FRACTALS_WARMUP_PERIOD = h("wickra_williams_fractals_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WILLIAMS_FRACTALS_IS_READY = h("wickra_williams_fractals_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WILLIAMS_FRACTALS_RESET = h("wickra_williams_fractals_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WILLIAMS_FRACTALS_FREE = h("wickra_williams_fractals_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WOODIE_PIVOTS_NEW = h("wickra_woodie_pivots_new", FunctionDescriptor.of(ADDRESS)); WICKRA_WOODIE_PIVOTS_UPDATE = h("wickra_woodie_pivots_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_WOODIE_PIVOTS_WARMUP_PERIOD = h("wickra_woodie_pivots_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_WOODIE_PIVOTS_IS_READY = h("wickra_woodie_pivots_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_WOODIE_PIVOTS_RESET = h("wickra_woodie_pivots_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_WOODIE_PIVOTS_FREE = h("wickra_woodie_pivots_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ZERO_LAG_MACD_NEW = h("wickra_zero_lag_macd_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG, JAVA_LONG)); WICKRA_ZERO_LAG_MACD_UPDATE = h("wickra_zero_lag_macd_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_ZERO_LAG_MACD_WARMUP_PERIOD = h("wickra_zero_lag_macd_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ZERO_LAG_MACD_IS_READY = h("wickra_zero_lag_macd_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ZERO_LAG_MACD_RESET = h("wickra_zero_lag_macd_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ZERO_LAG_MACD_FREE = h("wickra_zero_lag_macd_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ZIG_ZAG_NEW = h("wickra_zig_zag_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_ZIG_ZAG_UPDATE = h("wickra_zig_zag_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS)); + WICKRA_ZIG_ZAG_WARMUP_PERIOD = h("wickra_zig_zag_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_ZIG_ZAG_IS_READY = h("wickra_zig_zag_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_ZIG_ZAG_RESET = h("wickra_zig_zag_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_ZIG_ZAG_FREE = h("wickra_zig_zag_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DAY_OF_WEEK_PROFILE_NEW = h("wickra_day_of_week_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_INT)); WICKRA_DAY_OF_WEEK_PROFILE_UPDATE = h("wickra_day_of_week_profile_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, JAVA_LONG)); + WICKRA_DAY_OF_WEEK_PROFILE_WARMUP_PERIOD = h("wickra_day_of_week_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_DAY_OF_WEEK_PROFILE_IS_READY = h("wickra_day_of_week_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_DAY_OF_WEEK_PROFILE_RESET = h("wickra_day_of_week_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DAY_OF_WEEK_PROFILE_FREE = h("wickra_day_of_week_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INTRADAY_VOLATILITY_PROFILE_NEW = h("wickra_intraday_volatility_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_INT)); WICKRA_INTRADAY_VOLATILITY_PROFILE_UPDATE = h("wickra_intraday_volatility_profile_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, JAVA_LONG)); + WICKRA_INTRADAY_VOLATILITY_PROFILE_WARMUP_PERIOD = h("wickra_intraday_volatility_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_INTRADAY_VOLATILITY_PROFILE_IS_READY = h("wickra_intraday_volatility_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_INTRADAY_VOLATILITY_PROFILE_RESET = h("wickra_intraday_volatility_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_INTRADAY_VOLATILITY_PROFILE_FREE = h("wickra_intraday_volatility_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TIME_OF_DAY_RETURN_PROFILE_NEW = h("wickra_time_of_day_return_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_INT)); WICKRA_TIME_OF_DAY_RETURN_PROFILE_UPDATE = h("wickra_time_of_day_return_profile_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, JAVA_LONG)); + WICKRA_TIME_OF_DAY_RETURN_PROFILE_WARMUP_PERIOD = h("wickra_time_of_day_return_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TIME_OF_DAY_RETURN_PROFILE_IS_READY = h("wickra_time_of_day_return_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TIME_OF_DAY_RETURN_PROFILE_RESET = h("wickra_time_of_day_return_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TIME_OF_DAY_RETURN_PROFILE_FREE = h("wickra_time_of_day_return_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TPO_PROFILE_NEW = h("wickra_tpo_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_TPO_PROFILE_UPDATE = h("wickra_tpo_profile_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_TPO_PROFILE_WARMUP_PERIOD = h("wickra_tpo_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_TPO_PROFILE_IS_READY = h("wickra_tpo_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_TPO_PROFILE_RESET = h("wickra_tpo_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TPO_PROFILE_FREE = h("wickra_tpo_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_BY_TIME_PROFILE_NEW = h("wickra_volume_by_time_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_INT)); WICKRA_VOLUME_BY_TIME_PROFILE_UPDATE = h("wickra_volume_by_time_profile_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, JAVA_LONG)); + WICKRA_VOLUME_BY_TIME_PROFILE_WARMUP_PERIOD = h("wickra_volume_by_time_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_BY_TIME_PROFILE_IS_READY = h("wickra_volume_by_time_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); + } + + private static void init28() { WICKRA_VOLUME_BY_TIME_PROFILE_RESET = h("wickra_volume_by_time_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_BY_TIME_PROFILE_FREE = h("wickra_volume_by_time_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_PROFILE_NEW = h("wickra_volume_profile_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_LONG)); WICKRA_VOLUME_PROFILE_UPDATE = h("wickra_volume_profile_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG)); + WICKRA_VOLUME_PROFILE_WARMUP_PERIOD = h("wickra_volume_profile_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_VOLUME_PROFILE_IS_READY = h("wickra_volume_profile_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_VOLUME_PROFILE_RESET = h("wickra_volume_profile_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_PROFILE_FREE = h("wickra_volume_profile_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_DOLLAR_BARS_NEW = h("wickra_dollar_bars_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); @@ -4908,19 +6955,20 @@ public final class NativeMethods { WICKRA_TICK_BARS_UPDATE = h("wickra_tick_bars_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, JAVA_LONG)); WICKRA_TICK_BARS_RESET = h("wickra_tick_bars_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_TICK_BARS_FREE = h("wickra_tick_bars_free", FunctionDescriptor.ofVoid(ADDRESS)); - } - - private static void init20() { WICKRA_VOLUME_BARS_NEW = h("wickra_volume_bars_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_VOLUME_BARS_UPDATE = h("wickra_volume_bars_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS, JAVA_LONG)); WICKRA_VOLUME_BARS_RESET = h("wickra_volume_bars_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_VOLUME_BARS_FREE = h("wickra_volume_bars_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_EXT_NEW = h("wickra_macd_ext_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG, JAVA_BYTE, JAVA_LONG, JAVA_BYTE, JAVA_LONG, JAVA_BYTE)); WICKRA_MACD_EXT_UPDATE = h("wickra_macd_ext_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, ADDRESS)); + WICKRA_MACD_EXT_WARMUP_PERIOD = h("wickra_macd_ext_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_MACD_EXT_IS_READY = h("wickra_macd_ext_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_MACD_EXT_RESET = h("wickra_macd_ext_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_MACD_EXT_FREE = h("wickra_macd_ext_free", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FOOTPRINT_NEW = h("wickra_footprint_new", FunctionDescriptor.of(ADDRESS, JAVA_DOUBLE)); WICKRA_FOOTPRINT_UPDATE = h("wickra_footprint_update", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_BYTE, JAVA_LONG, ADDRESS, JAVA_LONG)); + WICKRA_FOOTPRINT_WARMUP_PERIOD = h("wickra_footprint_warmup_period", FunctionDescriptor.of(JAVA_LONG, ADDRESS)); + WICKRA_FOOTPRINT_IS_READY = h("wickra_footprint_is_ready", FunctionDescriptor.of(JAVA_BYTE, ADDRESS)); WICKRA_FOOTPRINT_RESET = h("wickra_footprint_reset", FunctionDescriptor.ofVoid(ADDRESS)); WICKRA_FOOTPRINT_FREE = h("wickra_footprint_free", FunctionDescriptor.ofVoid(ADDRESS)); } diff --git a/bindings/java/src/test/java/org/wickra/ArchetypeTests.java b/bindings/java/src/test/java/org/wickra/ArchetypeTests.java index e3fde661..1e9ae5bf 100644 --- a/bindings/java/src/test/java/org/wickra/ArchetypeTests.java +++ b/bindings/java/src/test/java/org/wickra/ArchetypeTests.java @@ -3,6 +3,7 @@ package org.wickra; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -34,6 +35,21 @@ class ArchetypeTests { } } + @Test + void queryWarmupPeriodAndIsReady() { + try (Sma sma = new Sma(3)) { + assertEquals(3, sma.warmupPeriod()); + assertFalse(sma.isReady()); + sma.update(1.0); + sma.update(2.0); + assertFalse(sma.isReady()); + sma.update(3.0); + assertTrue(sma.isReady()); + sma.reset(); + assertFalse(sma.isReady()); + } + } + @Test void scalarEmaBatchMatchesStreaming() { double[] input = new double[50]; diff --git a/bindings/r/NAMESPACE b/bindings/r/NAMESPACE index f5206111..095c1863 100644 --- a/bindings/r/NAMESPACE +++ b/bindings/r/NAMESPACE @@ -1,8 +1,10 @@ # Generated by roxygen2: do not edit by hand S3method(batch,wickra_indicator) +S3method(is_ready,wickra_indicator) S3method(reset,wickra_indicator) S3method(update,wickra_indicator) +S3method(warmup_period,wickra_indicator) export(AbandonedBaby) export(Abcd) export(AbsoluteBreadthIndex) @@ -518,5 +520,7 @@ export(ZeroLagMacd) export(ZigZag) export(Zlema) export(batch) +export(is_ready) export(reset) +export(warmup_period) importFrom(stats,update) diff --git a/bindings/r/R/methods.R b/bindings/r/R/methods.R index 0af1d0ae..7d5810e0 100644 --- a/bindings/r/R/methods.R +++ b/bindings/r/R/methods.R @@ -76,3 +76,45 @@ reset.wickra_indicator <- function(object) { .Call(paste0("wk_", object$prefix, "_reset"), object$ptr, PACKAGE = "wickra") invisible(object) } + +#' Number of updates an indicator needs before it produces a value +#' +#' Not available for the alt-chart bar builders ([RenkoBars()], [KagiBars()], +#' [PointAndFigureBars()], …), which have no warmup. +#' +#' @param object A `wickra_indicator`. +#' @return A single integer: the warmup period. +#' @examples +#' warmup_period(Sma(14)) # 14 +#' @export +warmup_period <- function(object) { + UseMethod("warmup_period") +} + +#' @rdname warmup_period +#' @export +warmup_period.wickra_indicator <- function(object) { + .Call(paste0("wk_", object$prefix, "_warmup_period"), object$ptr, PACKAGE = "wickra") +} + +#' Whether an indicator has consumed enough input to emit a value +#' +#' Not available for the alt-chart bar builders, which have no warmup. +#' +#' @param object A `wickra_indicator`. +#' @return A single logical. +#' @examples +#' sma <- Sma(3) +#' is_ready(sma) # FALSE +#' for (x in c(1, 2, 3)) update(sma, x) +#' is_ready(sma) # TRUE +#' @export +is_ready <- function(object) { + UseMethod("is_ready") +} + +#' @rdname is_ready +#' @export +is_ready.wickra_indicator <- function(object) { + .Call(paste0("wk_", object$prefix, "_is_ready"), object$ptr, PACKAGE = "wickra") +} diff --git a/bindings/r/src/wickra.c b/bindings/r/src/wickra.c index f3750d37..10033e84 100644 --- a/bindings/r/src/wickra.c +++ b/bindings/r/src/wickra.c @@ -34,6 +34,14 @@ SEXP wk_abandoned_baby_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_abandoned_baby_warmup_period(SEXP e) { + struct AbandonedBaby *h = (struct AbandonedBaby *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_abandoned_baby_warmup_period(h)); +} +SEXP wk_abandoned_baby_is_ready(SEXP e) { + struct AbandonedBaby *h = (struct AbandonedBaby *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_abandoned_baby_is_ready(h)); +} SEXP wk_abandoned_baby_reset(SEXP e) { struct AbandonedBaby *h = (struct AbandonedBaby *)R_ExternalPtrAddr(e); wickra_abandoned_baby_reset(h); @@ -67,6 +75,14 @@ SEXP wk_abcd_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_abcd_warmup_period(SEXP e) { + struct Abcd *h = (struct Abcd *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_abcd_warmup_period(h)); +} +SEXP wk_abcd_is_ready(SEXP e) { + struct Abcd *h = (struct Abcd *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_abcd_is_ready(h)); +} SEXP wk_abcd_reset(SEXP e) { struct Abcd *h = (struct Abcd *)R_ExternalPtrAddr(e); wickra_abcd_reset(h); @@ -90,6 +106,14 @@ SEXP wk_absolute_breadth_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 struct AbsoluteBreadthIndex *h = (struct AbsoluteBreadthIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_absolute_breadth_index_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_absolute_breadth_index_warmup_period(SEXP e) { + struct AbsoluteBreadthIndex *h = (struct AbsoluteBreadthIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_absolute_breadth_index_warmup_period(h)); +} +SEXP wk_absolute_breadth_index_is_ready(SEXP e) { + struct AbsoluteBreadthIndex *h = (struct AbsoluteBreadthIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_absolute_breadth_index_is_ready(h)); +} SEXP wk_absolute_breadth_index_reset(SEXP e) { struct AbsoluteBreadthIndex *h = (struct AbsoluteBreadthIndex *)R_ExternalPtrAddr(e); wickra_absolute_breadth_index_reset(h); @@ -125,6 +149,14 @@ SEXP wk_acceleration_bands_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE UNPROTECT(2); return r; } +SEXP wk_acceleration_bands_warmup_period(SEXP e) { + struct AccelerationBands *h = (struct AccelerationBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_acceleration_bands_warmup_period(h)); +} +SEXP wk_acceleration_bands_is_ready(SEXP e) { + struct AccelerationBands *h = (struct AccelerationBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_acceleration_bands_is_ready(h)); +} SEXP wk_acceleration_bands_reset(SEXP e) { struct AccelerationBands *h = (struct AccelerationBands *)R_ExternalPtrAddr(e); wickra_acceleration_bands_reset(h); @@ -158,6 +190,14 @@ SEXP wk_accelerator_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_accelerator_oscillator_warmup_period(SEXP e) { + struct AcceleratorOscillator *h = (struct AcceleratorOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_accelerator_oscillator_warmup_period(h)); +} +SEXP wk_accelerator_oscillator_is_ready(SEXP e) { + struct AcceleratorOscillator *h = (struct AcceleratorOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_accelerator_oscillator_is_ready(h)); +} SEXP wk_accelerator_oscillator_reset(SEXP e) { struct AcceleratorOscillator *h = (struct AcceleratorOscillator *)R_ExternalPtrAddr(e); wickra_accelerator_oscillator_reset(h); @@ -191,6 +231,14 @@ SEXP wk_ad_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_ad_oscillator_warmup_period(SEXP e) { + struct AdOscillator *h = (struct AdOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ad_oscillator_warmup_period(h)); +} +SEXP wk_ad_oscillator_is_ready(SEXP e) { + struct AdOscillator *h = (struct AdOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ad_oscillator_is_ready(h)); +} SEXP wk_ad_oscillator_reset(SEXP e) { struct AdOscillator *h = (struct AdOscillator *)R_ExternalPtrAddr(e); wickra_ad_oscillator_reset(h); @@ -214,6 +262,14 @@ SEXP wk_ad_volume_line_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a struct AdVolumeLine *h = (struct AdVolumeLine *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_ad_volume_line_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_ad_volume_line_warmup_period(SEXP e) { + struct AdVolumeLine *h = (struct AdVolumeLine *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ad_volume_line_warmup_period(h)); +} +SEXP wk_ad_volume_line_is_ready(SEXP e) { + struct AdVolumeLine *h = (struct AdVolumeLine *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ad_volume_line_is_ready(h)); +} SEXP wk_ad_volume_line_reset(SEXP e) { struct AdVolumeLine *h = (struct AdVolumeLine *)R_ExternalPtrAddr(e); wickra_ad_volume_line_reset(h); @@ -247,6 +303,14 @@ SEXP wk_adaptive_cci_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_adaptive_cci_warmup_period(SEXP e) { + struct AdaptiveCci *h = (struct AdaptiveCci *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adaptive_cci_warmup_period(h)); +} +SEXP wk_adaptive_cci_is_ready(SEXP e) { + struct AdaptiveCci *h = (struct AdaptiveCci *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adaptive_cci_is_ready(h)); +} SEXP wk_adaptive_cci_reset(SEXP e) { struct AdaptiveCci *h = (struct AdaptiveCci *)R_ExternalPtrAddr(e); wickra_adaptive_cci_reset(h); @@ -278,6 +342,14 @@ SEXP wk_adaptive_cycle_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_adaptive_cycle_warmup_period(SEXP e) { + struct AdaptiveCycle *h = (struct AdaptiveCycle *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adaptive_cycle_warmup_period(h)); +} +SEXP wk_adaptive_cycle_is_ready(SEXP e) { + struct AdaptiveCycle *h = (struct AdaptiveCycle *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adaptive_cycle_is_ready(h)); +} SEXP wk_adaptive_cycle_reset(SEXP e) { struct AdaptiveCycle *h = (struct AdaptiveCycle *)R_ExternalPtrAddr(e); wickra_adaptive_cycle_reset(h); @@ -309,6 +381,14 @@ SEXP wk_adaptive_laguerre_filter_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_adaptive_laguerre_filter_warmup_period(SEXP e) { + struct AdaptiveLaguerreFilter *h = (struct AdaptiveLaguerreFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adaptive_laguerre_filter_warmup_period(h)); +} +SEXP wk_adaptive_laguerre_filter_is_ready(SEXP e) { + struct AdaptiveLaguerreFilter *h = (struct AdaptiveLaguerreFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adaptive_laguerre_filter_is_ready(h)); +} SEXP wk_adaptive_laguerre_filter_reset(SEXP e) { struct AdaptiveLaguerreFilter *h = (struct AdaptiveLaguerreFilter *)R_ExternalPtrAddr(e); wickra_adaptive_laguerre_filter_reset(h); @@ -340,6 +420,14 @@ SEXP wk_adaptive_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_adaptive_rsi_warmup_period(SEXP e) { + struct AdaptiveRsi *h = (struct AdaptiveRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adaptive_rsi_warmup_period(h)); +} +SEXP wk_adaptive_rsi_is_ready(SEXP e) { + struct AdaptiveRsi *h = (struct AdaptiveRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adaptive_rsi_is_ready(h)); +} SEXP wk_adaptive_rsi_reset(SEXP e) { struct AdaptiveRsi *h = (struct AdaptiveRsi *)R_ExternalPtrAddr(e); wickra_adaptive_rsi_reset(h); @@ -373,6 +461,14 @@ SEXP wk_adl_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_adl_warmup_period(SEXP e) { + struct Adl *h = (struct Adl *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adl_warmup_period(h)); +} +SEXP wk_adl_is_ready(SEXP e) { + struct Adl *h = (struct Adl *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adl_is_ready(h)); +} SEXP wk_adl_reset(SEXP e) { struct Adl *h = (struct Adl *)R_ExternalPtrAddr(e); wickra_adl_reset(h); @@ -406,6 +502,14 @@ SEXP wk_advance_block_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_advance_block_warmup_period(SEXP e) { + struct AdvanceBlock *h = (struct AdvanceBlock *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_advance_block_warmup_period(h)); +} +SEXP wk_advance_block_is_ready(SEXP e) { + struct AdvanceBlock *h = (struct AdvanceBlock *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_advance_block_is_ready(h)); +} SEXP wk_advance_block_reset(SEXP e) { struct AdvanceBlock *h = (struct AdvanceBlock *)R_ExternalPtrAddr(e); wickra_advance_block_reset(h); @@ -429,6 +533,14 @@ SEXP wk_advance_decline_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP struct AdvanceDecline *h = (struct AdvanceDecline *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_advance_decline_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_advance_decline_warmup_period(SEXP e) { + struct AdvanceDecline *h = (struct AdvanceDecline *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_advance_decline_warmup_period(h)); +} +SEXP wk_advance_decline_is_ready(SEXP e) { + struct AdvanceDecline *h = (struct AdvanceDecline *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_advance_decline_is_ready(h)); +} SEXP wk_advance_decline_reset(SEXP e) { struct AdvanceDecline *h = (struct AdvanceDecline *)R_ExternalPtrAddr(e); wickra_advance_decline_reset(h); @@ -452,6 +564,14 @@ SEXP wk_advance_decline_ratio_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct AdvanceDeclineRatio *h = (struct AdvanceDeclineRatio *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_advance_decline_ratio_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_advance_decline_ratio_warmup_period(SEXP e) { + struct AdvanceDeclineRatio *h = (struct AdvanceDeclineRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_advance_decline_ratio_warmup_period(h)); +} +SEXP wk_advance_decline_ratio_is_ready(SEXP e) { + struct AdvanceDeclineRatio *h = (struct AdvanceDeclineRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_advance_decline_ratio_is_ready(h)); +} SEXP wk_advance_decline_ratio_reset(SEXP e) { struct AdvanceDeclineRatio *h = (struct AdvanceDeclineRatio *)R_ExternalPtrAddr(e); wickra_advance_decline_ratio_reset(h); @@ -487,6 +607,14 @@ SEXP wk_adx_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(2); return r; } +SEXP wk_adx_warmup_period(SEXP e) { + struct Adx *h = (struct Adx *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adx_warmup_period(h)); +} +SEXP wk_adx_is_ready(SEXP e) { + struct Adx *h = (struct Adx *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adx_is_ready(h)); +} SEXP wk_adx_reset(SEXP e) { struct Adx *h = (struct Adx *)R_ExternalPtrAddr(e); wickra_adx_reset(h); @@ -520,6 +648,14 @@ SEXP wk_adxr_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_adxr_warmup_period(SEXP e) { + struct Adxr *h = (struct Adxr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_adxr_warmup_period(h)); +} +SEXP wk_adxr_is_ready(SEXP e) { + struct Adxr *h = (struct Adxr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_adxr_is_ready(h)); +} SEXP wk_adxr_reset(SEXP e) { struct Adxr *h = (struct Adxr *)R_ExternalPtrAddr(e); wickra_adxr_reset(h); @@ -555,6 +691,14 @@ SEXP wk_alligator_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(2); return r; } +SEXP wk_alligator_warmup_period(SEXP e) { + struct Alligator *h = (struct Alligator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_alligator_warmup_period(h)); +} +SEXP wk_alligator_is_ready(SEXP e) { + struct Alligator *h = (struct Alligator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_alligator_is_ready(h)); +} SEXP wk_alligator_reset(SEXP e) { struct Alligator *h = (struct Alligator *)R_ExternalPtrAddr(e); wickra_alligator_reset(h); @@ -586,6 +730,14 @@ SEXP wk_alma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_alma_warmup_period(SEXP e) { + struct Alma *h = (struct Alma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_alma_warmup_period(h)); +} +SEXP wk_alma_is_ready(SEXP e) { + struct Alma *h = (struct Alma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_alma_is_ready(h)); +} SEXP wk_alma_reset(SEXP e) { struct Alma *h = (struct Alma *)R_ExternalPtrAddr(e); wickra_alma_reset(h); @@ -617,6 +769,14 @@ SEXP wk_alpha_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_alpha_warmup_period(SEXP e) { + struct Alpha *h = (struct Alpha *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_alpha_warmup_period(h)); +} +SEXP wk_alpha_is_ready(SEXP e) { + struct Alpha *h = (struct Alpha *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_alpha_is_ready(h)); +} SEXP wk_alpha_reset(SEXP e) { struct Alpha *h = (struct Alpha *)R_ExternalPtrAddr(e); wickra_alpha_reset(h); @@ -640,6 +800,14 @@ SEXP wk_amihud_illiquidity_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct AmihudIlliquidity *h = (struct AmihudIlliquidity *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_amihud_illiquidity_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_amihud_illiquidity_warmup_period(SEXP e) { + struct AmihudIlliquidity *h = (struct AmihudIlliquidity *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_amihud_illiquidity_warmup_period(h)); +} +SEXP wk_amihud_illiquidity_is_ready(SEXP e) { + struct AmihudIlliquidity *h = (struct AmihudIlliquidity *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_amihud_illiquidity_is_ready(h)); +} SEXP wk_amihud_illiquidity_reset(SEXP e) { struct AmihudIlliquidity *h = (struct AmihudIlliquidity *)R_ExternalPtrAddr(e); wickra_amihud_illiquidity_reset(h); @@ -671,6 +839,14 @@ SEXP wk_anchored_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_anchored_rsi_warmup_period(SEXP e) { + struct AnchoredRsi *h = (struct AnchoredRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_anchored_rsi_warmup_period(h)); +} +SEXP wk_anchored_rsi_is_ready(SEXP e) { + struct AnchoredRsi *h = (struct AnchoredRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_anchored_rsi_is_ready(h)); +} SEXP wk_anchored_rsi_reset(SEXP e) { struct AnchoredRsi *h = (struct AnchoredRsi *)R_ExternalPtrAddr(e); wickra_anchored_rsi_reset(h); @@ -704,6 +880,14 @@ SEXP wk_anchored_vwap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_anchored_vwap_warmup_period(SEXP e) { + struct AnchoredVwap *h = (struct AnchoredVwap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_anchored_vwap_warmup_period(h)); +} +SEXP wk_anchored_vwap_is_ready(SEXP e) { + struct AnchoredVwap *h = (struct AnchoredVwap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_anchored_vwap_is_ready(h)); +} SEXP wk_anchored_vwap_reset(SEXP e) { struct AnchoredVwap *h = (struct AnchoredVwap *)R_ExternalPtrAddr(e); wickra_anchored_vwap_reset(h); @@ -739,6 +923,14 @@ SEXP wk_andrews_pitchfork_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(2); return r; } +SEXP wk_andrews_pitchfork_warmup_period(SEXP e) { + struct AndrewsPitchfork *h = (struct AndrewsPitchfork *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_andrews_pitchfork_warmup_period(h)); +} +SEXP wk_andrews_pitchfork_is_ready(SEXP e) { + struct AndrewsPitchfork *h = (struct AndrewsPitchfork *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_andrews_pitchfork_is_ready(h)); +} SEXP wk_andrews_pitchfork_reset(SEXP e) { struct AndrewsPitchfork *h = (struct AndrewsPitchfork *)R_ExternalPtrAddr(e); wickra_andrews_pitchfork_reset(h); @@ -770,6 +962,14 @@ SEXP wk_apo_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_apo_warmup_period(SEXP e) { + struct Apo *h = (struct Apo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_apo_warmup_period(h)); +} +SEXP wk_apo_is_ready(SEXP e) { + struct Apo *h = (struct Apo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_apo_is_ready(h)); +} SEXP wk_apo_reset(SEXP e) { struct Apo *h = (struct Apo *)R_ExternalPtrAddr(e); wickra_apo_reset(h); @@ -803,6 +1003,14 @@ SEXP wk_aroon_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(2); return r; } +SEXP wk_aroon_warmup_period(SEXP e) { + struct Aroon *h = (struct Aroon *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_aroon_warmup_period(h)); +} +SEXP wk_aroon_is_ready(SEXP e) { + struct Aroon *h = (struct Aroon *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_aroon_is_ready(h)); +} SEXP wk_aroon_reset(SEXP e) { struct Aroon *h = (struct Aroon *)R_ExternalPtrAddr(e); wickra_aroon_reset(h); @@ -836,6 +1044,14 @@ SEXP wk_aroon_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_aroon_oscillator_warmup_period(SEXP e) { + struct AroonOscillator *h = (struct AroonOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_aroon_oscillator_warmup_period(h)); +} +SEXP wk_aroon_oscillator_is_ready(SEXP e) { + struct AroonOscillator *h = (struct AroonOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_aroon_oscillator_is_ready(h)); +} SEXP wk_aroon_oscillator_reset(SEXP e) { struct AroonOscillator *h = (struct AroonOscillator *)R_ExternalPtrAddr(e); wickra_aroon_oscillator_reset(h); @@ -869,6 +1085,14 @@ SEXP wk_atr_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_atr_warmup_period(SEXP e) { + struct Atr *h = (struct Atr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_atr_warmup_period(h)); +} +SEXP wk_atr_is_ready(SEXP e) { + struct Atr *h = (struct Atr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_atr_is_ready(h)); +} SEXP wk_atr_reset(SEXP e) { struct Atr *h = (struct Atr *)R_ExternalPtrAddr(e); wickra_atr_reset(h); @@ -904,6 +1128,14 @@ SEXP wk_atr_bands_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(2); return r; } +SEXP wk_atr_bands_warmup_period(SEXP e) { + struct AtrBands *h = (struct AtrBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_atr_bands_warmup_period(h)); +} +SEXP wk_atr_bands_is_ready(SEXP e) { + struct AtrBands *h = (struct AtrBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_atr_bands_is_ready(h)); +} SEXP wk_atr_bands_reset(SEXP e) { struct AtrBands *h = (struct AtrBands *)R_ExternalPtrAddr(e); wickra_atr_bands_reset(h); @@ -937,6 +1169,14 @@ SEXP wk_atr_ratchet_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(2); return r; } +SEXP wk_atr_ratchet_warmup_period(SEXP e) { + struct AtrRatchet *h = (struct AtrRatchet *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_atr_ratchet_warmup_period(h)); +} +SEXP wk_atr_ratchet_is_ready(SEXP e) { + struct AtrRatchet *h = (struct AtrRatchet *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_atr_ratchet_is_ready(h)); +} SEXP wk_atr_ratchet_reset(SEXP e) { struct AtrRatchet *h = (struct AtrRatchet *)R_ExternalPtrAddr(e); wickra_atr_ratchet_reset(h); @@ -970,6 +1210,14 @@ SEXP wk_atr_trailing_stop_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_atr_trailing_stop_warmup_period(SEXP e) { + struct AtrTrailingStop *h = (struct AtrTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_atr_trailing_stop_warmup_period(h)); +} +SEXP wk_atr_trailing_stop_is_ready(SEXP e) { + struct AtrTrailingStop *h = (struct AtrTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_atr_trailing_stop_is_ready(h)); +} SEXP wk_atr_trailing_stop_reset(SEXP e) { struct AtrTrailingStop *h = (struct AtrTrailingStop *)R_ExternalPtrAddr(e); wickra_atr_trailing_stop_reset(h); @@ -1013,6 +1261,14 @@ SEXP wk_auto_fib_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(2); return r; } +SEXP wk_auto_fib_warmup_period(SEXP e) { + struct AutoFib *h = (struct AutoFib *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_auto_fib_warmup_period(h)); +} +SEXP wk_auto_fib_is_ready(SEXP e) { + struct AutoFib *h = (struct AutoFib *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_auto_fib_is_ready(h)); +} SEXP wk_auto_fib_reset(SEXP e) { struct AutoFib *h = (struct AutoFib *)R_ExternalPtrAddr(e); wickra_auto_fib_reset(h); @@ -1044,6 +1300,14 @@ SEXP wk_autocorrelation_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_autocorrelation_warmup_period(SEXP e) { + struct Autocorrelation *h = (struct Autocorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_autocorrelation_warmup_period(h)); +} +SEXP wk_autocorrelation_is_ready(SEXP e) { + struct Autocorrelation *h = (struct Autocorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_autocorrelation_is_ready(h)); +} SEXP wk_autocorrelation_reset(SEXP e) { struct Autocorrelation *h = (struct Autocorrelation *)R_ExternalPtrAddr(e); wickra_autocorrelation_reset(h); @@ -1075,6 +1339,14 @@ SEXP wk_autocorrelation_periodogram_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_autocorrelation_periodogram_warmup_period(SEXP e) { + struct AutocorrelationPeriodogram *h = (struct AutocorrelationPeriodogram *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_autocorrelation_periodogram_warmup_period(h)); +} +SEXP wk_autocorrelation_periodogram_is_ready(SEXP e) { + struct AutocorrelationPeriodogram *h = (struct AutocorrelationPeriodogram *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_autocorrelation_periodogram_is_ready(h)); +} SEXP wk_autocorrelation_periodogram_reset(SEXP e) { struct AutocorrelationPeriodogram *h = (struct AutocorrelationPeriodogram *)R_ExternalPtrAddr(e); wickra_autocorrelation_periodogram_reset(h); @@ -1108,6 +1380,14 @@ SEXP wk_average_daily_range_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE UNPROTECT(1); return out; } +SEXP wk_average_daily_range_warmup_period(SEXP e) { + struct AverageDailyRange *h = (struct AverageDailyRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_average_daily_range_warmup_period(h)); +} +SEXP wk_average_daily_range_is_ready(SEXP e) { + struct AverageDailyRange *h = (struct AverageDailyRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_average_daily_range_is_ready(h)); +} SEXP wk_average_daily_range_reset(SEXP e) { struct AverageDailyRange *h = (struct AverageDailyRange *)R_ExternalPtrAddr(e); wickra_average_daily_range_reset(h); @@ -1139,6 +1419,14 @@ SEXP wk_average_drawdown_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_average_drawdown_warmup_period(SEXP e) { + struct AverageDrawdown *h = (struct AverageDrawdown *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_average_drawdown_warmup_period(h)); +} +SEXP wk_average_drawdown_is_ready(SEXP e) { + struct AverageDrawdown *h = (struct AverageDrawdown *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_average_drawdown_is_ready(h)); +} SEXP wk_average_drawdown_reset(SEXP e) { struct AverageDrawdown *h = (struct AverageDrawdown *)R_ExternalPtrAddr(e); wickra_average_drawdown_reset(h); @@ -1172,6 +1460,14 @@ SEXP wk_avg_price_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_avg_price_warmup_period(SEXP e) { + struct AvgPrice *h = (struct AvgPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_avg_price_warmup_period(h)); +} +SEXP wk_avg_price_is_ready(SEXP e) { + struct AvgPrice *h = (struct AvgPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_avg_price_is_ready(h)); +} SEXP wk_avg_price_reset(SEXP e) { struct AvgPrice *h = (struct AvgPrice *)R_ExternalPtrAddr(e); wickra_avg_price_reset(h); @@ -1205,6 +1501,14 @@ SEXP wk_awesome_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_awesome_oscillator_warmup_period(SEXP e) { + struct AwesomeOscillator *h = (struct AwesomeOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_awesome_oscillator_warmup_period(h)); +} +SEXP wk_awesome_oscillator_is_ready(SEXP e) { + struct AwesomeOscillator *h = (struct AwesomeOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_awesome_oscillator_is_ready(h)); +} SEXP wk_awesome_oscillator_reset(SEXP e) { struct AwesomeOscillator *h = (struct AwesomeOscillator *)R_ExternalPtrAddr(e); wickra_awesome_oscillator_reset(h); @@ -1238,6 +1542,14 @@ SEXP wk_awesome_oscillator_histogram_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SE UNPROTECT(1); return out; } +SEXP wk_awesome_oscillator_histogram_warmup_period(SEXP e) { + struct AwesomeOscillatorHistogram *h = (struct AwesomeOscillatorHistogram *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_awesome_oscillator_histogram_warmup_period(h)); +} +SEXP wk_awesome_oscillator_histogram_is_ready(SEXP e) { + struct AwesomeOscillatorHistogram *h = (struct AwesomeOscillatorHistogram *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_awesome_oscillator_histogram_is_ready(h)); +} SEXP wk_awesome_oscillator_histogram_reset(SEXP e) { struct AwesomeOscillatorHistogram *h = (struct AwesomeOscillatorHistogram *)R_ExternalPtrAddr(e); wickra_awesome_oscillator_histogram_reset(h); @@ -1271,6 +1583,14 @@ SEXP wk_balance_of_power_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_balance_of_power_warmup_period(SEXP e) { + struct BalanceOfPower *h = (struct BalanceOfPower *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_balance_of_power_warmup_period(h)); +} +SEXP wk_balance_of_power_is_ready(SEXP e) { + struct BalanceOfPower *h = (struct BalanceOfPower *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_balance_of_power_is_ready(h)); +} SEXP wk_balance_of_power_reset(SEXP e) { struct BalanceOfPower *h = (struct BalanceOfPower *)R_ExternalPtrAddr(e); wickra_balance_of_power_reset(h); @@ -1302,6 +1622,14 @@ SEXP wk_bandpass_filter_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_bandpass_filter_warmup_period(SEXP e) { + struct BandpassFilter *h = (struct BandpassFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bandpass_filter_warmup_period(h)); +} +SEXP wk_bandpass_filter_is_ready(SEXP e) { + struct BandpassFilter *h = (struct BandpassFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bandpass_filter_is_ready(h)); +} SEXP wk_bandpass_filter_reset(SEXP e) { struct BandpassFilter *h = (struct BandpassFilter *)R_ExternalPtrAddr(e); wickra_bandpass_filter_reset(h); @@ -1335,6 +1663,14 @@ SEXP wk_bat_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_bat_warmup_period(SEXP e) { + struct Bat *h = (struct Bat *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bat_warmup_period(h)); +} +SEXP wk_bat_is_ready(SEXP e) { + struct Bat *h = (struct Bat *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bat_is_ready(h)); +} SEXP wk_bat_reset(SEXP e) { struct Bat *h = (struct Bat *)R_ExternalPtrAddr(e); wickra_bat_reset(h); @@ -1368,6 +1704,14 @@ SEXP wk_belt_hold_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_belt_hold_warmup_period(SEXP e) { + struct BeltHold *h = (struct BeltHold *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_belt_hold_warmup_period(h)); +} +SEXP wk_belt_hold_is_ready(SEXP e) { + struct BeltHold *h = (struct BeltHold *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_belt_hold_is_ready(h)); +} SEXP wk_belt_hold_reset(SEXP e) { struct BeltHold *h = (struct BeltHold *)R_ExternalPtrAddr(e); wickra_belt_hold_reset(h); @@ -1399,6 +1743,14 @@ SEXP wk_beta_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_beta_warmup_period(SEXP e) { + struct Beta *h = (struct Beta *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_beta_warmup_period(h)); +} +SEXP wk_beta_is_ready(SEXP e) { + struct Beta *h = (struct Beta *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_beta_is_ready(h)); +} SEXP wk_beta_reset(SEXP e) { struct Beta *h = (struct Beta *)R_ExternalPtrAddr(e); wickra_beta_reset(h); @@ -1430,6 +1782,14 @@ SEXP wk_beta_neutral_spread_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_beta_neutral_spread_warmup_period(SEXP e) { + struct BetaNeutralSpread *h = (struct BetaNeutralSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_beta_neutral_spread_warmup_period(h)); +} +SEXP wk_beta_neutral_spread_is_ready(SEXP e) { + struct BetaNeutralSpread *h = (struct BetaNeutralSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_beta_neutral_spread_is_ready(h)); +} SEXP wk_beta_neutral_spread_reset(SEXP e) { struct BetaNeutralSpread *h = (struct BetaNeutralSpread *)R_ExternalPtrAddr(e); wickra_beta_neutral_spread_reset(h); @@ -1463,6 +1823,14 @@ SEXP wk_better_volume_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_better_volume_warmup_period(SEXP e) { + struct BetterVolume *h = (struct BetterVolume *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_better_volume_warmup_period(h)); +} +SEXP wk_better_volume_is_ready(SEXP e) { + struct BetterVolume *h = (struct BetterVolume *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_better_volume_is_ready(h)); +} SEXP wk_better_volume_reset(SEXP e) { struct BetterVolume *h = (struct BetterVolume *)R_ExternalPtrAddr(e); wickra_better_volume_reset(h); @@ -1494,6 +1862,14 @@ SEXP wk_bipower_variation_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_bipower_variation_warmup_period(SEXP e) { + struct BipowerVariation *h = (struct BipowerVariation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bipower_variation_warmup_period(h)); +} +SEXP wk_bipower_variation_is_ready(SEXP e) { + struct BipowerVariation *h = (struct BipowerVariation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bipower_variation_is_ready(h)); +} SEXP wk_bipower_variation_reset(SEXP e) { struct BipowerVariation *h = (struct BipowerVariation *)R_ExternalPtrAddr(e); wickra_bipower_variation_reset(h); @@ -1527,6 +1903,14 @@ SEXP wk_body_size_pct_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_body_size_pct_warmup_period(SEXP e) { + struct BodySizePct *h = (struct BodySizePct *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_body_size_pct_warmup_period(h)); +} +SEXP wk_body_size_pct_is_ready(SEXP e) { + struct BodySizePct *h = (struct BodySizePct *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_body_size_pct_is_ready(h)); +} SEXP wk_body_size_pct_reset(SEXP e) { struct BodySizePct *h = (struct BodySizePct *)R_ExternalPtrAddr(e); wickra_body_size_pct_reset(h); @@ -1564,6 +1948,14 @@ SEXP wk_bollinger_bands_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_bollinger_bands_warmup_period(SEXP e) { + struct BollingerBands *h = (struct BollingerBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bollinger_bands_warmup_period(h)); +} +SEXP wk_bollinger_bands_is_ready(SEXP e) { + struct BollingerBands *h = (struct BollingerBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bollinger_bands_is_ready(h)); +} SEXP wk_bollinger_bands_reset(SEXP e) { struct BollingerBands *h = (struct BollingerBands *)R_ExternalPtrAddr(e); wickra_bollinger_bands_reset(h); @@ -1595,6 +1987,14 @@ SEXP wk_bollinger_bandwidth_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_bollinger_bandwidth_warmup_period(SEXP e) { + struct BollingerBandwidth *h = (struct BollingerBandwidth *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bollinger_bandwidth_warmup_period(h)); +} +SEXP wk_bollinger_bandwidth_is_ready(SEXP e) { + struct BollingerBandwidth *h = (struct BollingerBandwidth *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bollinger_bandwidth_is_ready(h)); +} SEXP wk_bollinger_bandwidth_reset(SEXP e) { struct BollingerBandwidth *h = (struct BollingerBandwidth *)R_ExternalPtrAddr(e); wickra_bollinger_bandwidth_reset(h); @@ -1630,6 +2030,14 @@ SEXP wk_bomar_bands_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_bomar_bands_warmup_period(SEXP e) { + struct BomarBands *h = (struct BomarBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bomar_bands_warmup_period(h)); +} +SEXP wk_bomar_bands_is_ready(SEXP e) { + struct BomarBands *h = (struct BomarBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bomar_bands_is_ready(h)); +} SEXP wk_bomar_bands_reset(SEXP e) { struct BomarBands *h = (struct BomarBands *)R_ExternalPtrAddr(e); wickra_bomar_bands_reset(h); @@ -1653,6 +2061,14 @@ SEXP wk_breadth_thrust_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a struct BreadthThrust *h = (struct BreadthThrust *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_breadth_thrust_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_breadth_thrust_warmup_period(SEXP e) { + struct BreadthThrust *h = (struct BreadthThrust *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_breadth_thrust_warmup_period(h)); +} +SEXP wk_breadth_thrust_is_ready(SEXP e) { + struct BreadthThrust *h = (struct BreadthThrust *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_breadth_thrust_is_ready(h)); +} SEXP wk_breadth_thrust_reset(SEXP e) { struct BreadthThrust *h = (struct BreadthThrust *)R_ExternalPtrAddr(e); wickra_breadth_thrust_reset(h); @@ -1686,6 +2102,14 @@ SEXP wk_breakaway_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_breakaway_warmup_period(SEXP e) { + struct Breakaway *h = (struct Breakaway *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_breakaway_warmup_period(h)); +} +SEXP wk_breakaway_is_ready(SEXP e) { + struct Breakaway *h = (struct Breakaway *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_breakaway_is_ready(h)); +} SEXP wk_breakaway_reset(SEXP e) { struct Breakaway *h = (struct Breakaway *)R_ExternalPtrAddr(e); wickra_breakaway_reset(h); @@ -1709,6 +2133,14 @@ SEXP wk_bullish_percent_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct BullishPercentIndex *h = (struct BullishPercentIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_bullish_percent_index_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_bullish_percent_index_warmup_period(SEXP e) { + struct BullishPercentIndex *h = (struct BullishPercentIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_bullish_percent_index_warmup_period(h)); +} +SEXP wk_bullish_percent_index_is_ready(SEXP e) { + struct BullishPercentIndex *h = (struct BullishPercentIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_bullish_percent_index_is_ready(h)); +} SEXP wk_bullish_percent_index_reset(SEXP e) { struct BullishPercentIndex *h = (struct BullishPercentIndex *)R_ExternalPtrAddr(e); wickra_bullish_percent_index_reset(h); @@ -1740,6 +2172,14 @@ SEXP wk_burke_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_burke_ratio_warmup_period(SEXP e) { + struct BurkeRatio *h = (struct BurkeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_burke_ratio_warmup_period(h)); +} +SEXP wk_burke_ratio_is_ready(SEXP e) { + struct BurkeRatio *h = (struct BurkeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_burke_ratio_is_ready(h)); +} SEXP wk_burke_ratio_reset(SEXP e) { struct BurkeRatio *h = (struct BurkeRatio *)R_ExternalPtrAddr(e); wickra_burke_ratio_reset(h); @@ -1773,6 +2213,14 @@ SEXP wk_butterfly_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_butterfly_warmup_period(SEXP e) { + struct Butterfly *h = (struct Butterfly *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_butterfly_warmup_period(h)); +} +SEXP wk_butterfly_is_ready(SEXP e) { + struct Butterfly *h = (struct Butterfly *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_butterfly_is_ready(h)); +} SEXP wk_butterfly_reset(SEXP e) { struct Butterfly *h = (struct Butterfly *)R_ExternalPtrAddr(e); wickra_butterfly_reset(h); @@ -1796,6 +2244,14 @@ SEXP wk_calendar_spread_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP struct CalendarSpread *h = (struct CalendarSpread *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_calendar_spread_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_calendar_spread_warmup_period(SEXP e) { + struct CalendarSpread *h = (struct CalendarSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_calendar_spread_warmup_period(h)); +} +SEXP wk_calendar_spread_is_ready(SEXP e) { + struct CalendarSpread *h = (struct CalendarSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_calendar_spread_is_ready(h)); +} SEXP wk_calendar_spread_reset(SEXP e) { struct CalendarSpread *h = (struct CalendarSpread *)R_ExternalPtrAddr(e); wickra_calendar_spread_reset(h); @@ -1827,6 +2283,14 @@ SEXP wk_calmar_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_calmar_ratio_warmup_period(SEXP e) { + struct CalmarRatio *h = (struct CalmarRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_calmar_ratio_warmup_period(h)); +} +SEXP wk_calmar_ratio_is_ready(SEXP e) { + struct CalmarRatio *h = (struct CalmarRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_calmar_ratio_is_ready(h)); +} SEXP wk_calmar_ratio_reset(SEXP e) { struct CalmarRatio *h = (struct CalmarRatio *)R_ExternalPtrAddr(e); wickra_calmar_ratio_reset(h); @@ -1874,6 +2338,14 @@ SEXP wk_camarilla_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(2); return r; } +SEXP wk_camarilla_warmup_period(SEXP e) { + struct Camarilla *h = (struct Camarilla *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_camarilla_warmup_period(h)); +} +SEXP wk_camarilla_is_ready(SEXP e) { + struct Camarilla *h = (struct Camarilla *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_camarilla_is_ready(h)); +} SEXP wk_camarilla_reset(SEXP e) { struct Camarilla *h = (struct Camarilla *)R_ExternalPtrAddr(e); wickra_camarilla_reset(h); @@ -1907,6 +2379,14 @@ SEXP wk_candle_volume_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_candle_volume_warmup_period(SEXP e) { + struct CandleVolume *h = (struct CandleVolume *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_candle_volume_warmup_period(h)); +} +SEXP wk_candle_volume_is_ready(SEXP e) { + struct CandleVolume *h = (struct CandleVolume *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_candle_volume_is_ready(h)); +} SEXP wk_candle_volume_reset(SEXP e) { struct CandleVolume *h = (struct CandleVolume *)R_ExternalPtrAddr(e); wickra_candle_volume_reset(h); @@ -1940,6 +2420,14 @@ SEXP wk_cci_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_cci_warmup_period(SEXP e) { + struct Cci *h = (struct Cci *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cci_warmup_period(h)); +} +SEXP wk_cci_is_ready(SEXP e) { + struct Cci *h = (struct Cci *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cci_is_ready(h)); +} SEXP wk_cci_reset(SEXP e) { struct Cci *h = (struct Cci *)R_ExternalPtrAddr(e); wickra_cci_reset(h); @@ -1971,6 +2459,14 @@ SEXP wk_center_of_gravity_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_center_of_gravity_warmup_period(SEXP e) { + struct CenterOfGravity *h = (struct CenterOfGravity *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_center_of_gravity_warmup_period(h)); +} +SEXP wk_center_of_gravity_is_ready(SEXP e) { + struct CenterOfGravity *h = (struct CenterOfGravity *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_center_of_gravity_is_ready(h)); +} SEXP wk_center_of_gravity_reset(SEXP e) { struct CenterOfGravity *h = (struct CenterOfGravity *)R_ExternalPtrAddr(e); wickra_center_of_gravity_reset(h); @@ -2006,6 +2502,14 @@ SEXP wk_central_pivot_range_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(2); return r; } +SEXP wk_central_pivot_range_warmup_period(SEXP e) { + struct CentralPivotRange *h = (struct CentralPivotRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_central_pivot_range_warmup_period(h)); +} +SEXP wk_central_pivot_range_is_ready(SEXP e) { + struct CentralPivotRange *h = (struct CentralPivotRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_central_pivot_range_is_ready(h)); +} SEXP wk_central_pivot_range_reset(SEXP e) { struct CentralPivotRange *h = (struct CentralPivotRange *)R_ExternalPtrAddr(e); wickra_central_pivot_range_reset(h); @@ -2037,6 +2541,14 @@ SEXP wk_cfo_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_cfo_warmup_period(SEXP e) { + struct Cfo *h = (struct Cfo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cfo_warmup_period(h)); +} +SEXP wk_cfo_is_ready(SEXP e) { + struct Cfo *h = (struct Cfo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cfo_is_ready(h)); +} SEXP wk_cfo_reset(SEXP e) { struct Cfo *h = (struct Cfo *)R_ExternalPtrAddr(e); wickra_cfo_reset(h); @@ -2070,6 +2582,14 @@ SEXP wk_chaikin_money_flow_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_chaikin_money_flow_warmup_period(SEXP e) { + struct ChaikinMoneyFlow *h = (struct ChaikinMoneyFlow *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_chaikin_money_flow_warmup_period(h)); +} +SEXP wk_chaikin_money_flow_is_ready(SEXP e) { + struct ChaikinMoneyFlow *h = (struct ChaikinMoneyFlow *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_chaikin_money_flow_is_ready(h)); +} SEXP wk_chaikin_money_flow_reset(SEXP e) { struct ChaikinMoneyFlow *h = (struct ChaikinMoneyFlow *)R_ExternalPtrAddr(e); wickra_chaikin_money_flow_reset(h); @@ -2103,6 +2623,14 @@ SEXP wk_chaikin_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_chaikin_oscillator_warmup_period(SEXP e) { + struct ChaikinOscillator *h = (struct ChaikinOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_chaikin_oscillator_warmup_period(h)); +} +SEXP wk_chaikin_oscillator_is_ready(SEXP e) { + struct ChaikinOscillator *h = (struct ChaikinOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_chaikin_oscillator_is_ready(h)); +} SEXP wk_chaikin_oscillator_reset(SEXP e) { struct ChaikinOscillator *h = (struct ChaikinOscillator *)R_ExternalPtrAddr(e); wickra_chaikin_oscillator_reset(h); @@ -2136,6 +2664,14 @@ SEXP wk_chaikin_volatility_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_chaikin_volatility_warmup_period(SEXP e) { + struct ChaikinVolatility *h = (struct ChaikinVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_chaikin_volatility_warmup_period(h)); +} +SEXP wk_chaikin_volatility_is_ready(SEXP e) { + struct ChaikinVolatility *h = (struct ChaikinVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_chaikin_volatility_is_ready(h)); +} SEXP wk_chaikin_volatility_reset(SEXP e) { struct ChaikinVolatility *h = (struct ChaikinVolatility *)R_ExternalPtrAddr(e); wickra_chaikin_volatility_reset(h); @@ -2169,6 +2705,14 @@ SEXP wk_chande_kroll_stop_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(2); return r; } +SEXP wk_chande_kroll_stop_warmup_period(SEXP e) { + struct ChandeKrollStop *h = (struct ChandeKrollStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_chande_kroll_stop_warmup_period(h)); +} +SEXP wk_chande_kroll_stop_is_ready(SEXP e) { + struct ChandeKrollStop *h = (struct ChandeKrollStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_chande_kroll_stop_is_ready(h)); +} SEXP wk_chande_kroll_stop_reset(SEXP e) { struct ChandeKrollStop *h = (struct ChandeKrollStop *)R_ExternalPtrAddr(e); wickra_chande_kroll_stop_reset(h); @@ -2202,6 +2746,14 @@ SEXP wk_chandelier_exit_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_chandelier_exit_warmup_period(SEXP e) { + struct ChandelierExit *h = (struct ChandelierExit *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_chandelier_exit_warmup_period(h)); +} +SEXP wk_chandelier_exit_is_ready(SEXP e) { + struct ChandelierExit *h = (struct ChandelierExit *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_chandelier_exit_is_ready(h)); +} SEXP wk_chandelier_exit_reset(SEXP e) { struct ChandelierExit *h = (struct ChandelierExit *)R_ExternalPtrAddr(e); wickra_chandelier_exit_reset(h); @@ -2235,6 +2787,14 @@ SEXP wk_choppiness_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_choppiness_index_warmup_period(SEXP e) { + struct ChoppinessIndex *h = (struct ChoppinessIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_choppiness_index_warmup_period(h)); +} +SEXP wk_choppiness_index_is_ready(SEXP e) { + struct ChoppinessIndex *h = (struct ChoppinessIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_choppiness_index_is_ready(h)); +} SEXP wk_choppiness_index_reset(SEXP e) { struct ChoppinessIndex *h = (struct ChoppinessIndex *)R_ExternalPtrAddr(e); wickra_choppiness_index_reset(h); @@ -2278,6 +2838,14 @@ SEXP wk_classic_pivots_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(2); return r; } +SEXP wk_classic_pivots_warmup_period(SEXP e) { + struct ClassicPivots *h = (struct ClassicPivots *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_classic_pivots_warmup_period(h)); +} +SEXP wk_classic_pivots_is_ready(SEXP e) { + struct ClassicPivots *h = (struct ClassicPivots *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_classic_pivots_is_ready(h)); +} SEXP wk_classic_pivots_reset(SEXP e) { struct ClassicPivots *h = (struct ClassicPivots *)R_ExternalPtrAddr(e); wickra_classic_pivots_reset(h); @@ -2311,6 +2879,14 @@ SEXP wk_close_vs_open_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_close_vs_open_warmup_period(SEXP e) { + struct CloseVsOpen *h = (struct CloseVsOpen *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_close_vs_open_warmup_period(h)); +} +SEXP wk_close_vs_open_is_ready(SEXP e) { + struct CloseVsOpen *h = (struct CloseVsOpen *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_close_vs_open_is_ready(h)); +} SEXP wk_close_vs_open_reset(SEXP e) { struct CloseVsOpen *h = (struct CloseVsOpen *)R_ExternalPtrAddr(e); wickra_close_vs_open_reset(h); @@ -2344,6 +2920,14 @@ SEXP wk_closing_marubozu_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_closing_marubozu_warmup_period(SEXP e) { + struct ClosingMarubozu *h = (struct ClosingMarubozu *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_closing_marubozu_warmup_period(h)); +} +SEXP wk_closing_marubozu_is_ready(SEXP e) { + struct ClosingMarubozu *h = (struct ClosingMarubozu *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_closing_marubozu_is_ready(h)); +} SEXP wk_closing_marubozu_reset(SEXP e) { struct ClosingMarubozu *h = (struct ClosingMarubozu *)R_ExternalPtrAddr(e); wickra_closing_marubozu_reset(h); @@ -2375,6 +2959,14 @@ SEXP wk_cmo_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_cmo_warmup_period(SEXP e) { + struct Cmo *h = (struct Cmo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cmo_warmup_period(h)); +} +SEXP wk_cmo_is_ready(SEXP e) { + struct Cmo *h = (struct Cmo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cmo_is_ready(h)); +} SEXP wk_cmo_reset(SEXP e) { struct Cmo *h = (struct Cmo *)R_ExternalPtrAddr(e); wickra_cmo_reset(h); @@ -2406,6 +2998,14 @@ SEXP wk_coefficient_of_variation_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_coefficient_of_variation_warmup_period(SEXP e) { + struct CoefficientOfVariation *h = (struct CoefficientOfVariation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_coefficient_of_variation_warmup_period(h)); +} +SEXP wk_coefficient_of_variation_is_ready(SEXP e) { + struct CoefficientOfVariation *h = (struct CoefficientOfVariation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_coefficient_of_variation_is_ready(h)); +} SEXP wk_coefficient_of_variation_reset(SEXP e) { struct CoefficientOfVariation *h = (struct CoefficientOfVariation *)R_ExternalPtrAddr(e); wickra_coefficient_of_variation_reset(h); @@ -2441,6 +3041,14 @@ SEXP wk_cointegration_update(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(2); return r; } +SEXP wk_cointegration_warmup_period(SEXP e) { + struct Cointegration *h = (struct Cointegration *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cointegration_warmup_period(h)); +} +SEXP wk_cointegration_is_ready(SEXP e) { + struct Cointegration *h = (struct Cointegration *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cointegration_is_ready(h)); +} SEXP wk_cointegration_reset(SEXP e) { struct Cointegration *h = (struct Cointegration *)R_ExternalPtrAddr(e); wickra_cointegration_reset(h); @@ -2472,6 +3080,14 @@ SEXP wk_common_sense_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_common_sense_ratio_warmup_period(SEXP e) { + struct CommonSenseRatio *h = (struct CommonSenseRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_common_sense_ratio_warmup_period(h)); +} +SEXP wk_common_sense_ratio_is_ready(SEXP e) { + struct CommonSenseRatio *h = (struct CommonSenseRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_common_sense_ratio_is_ready(h)); +} SEXP wk_common_sense_ratio_reset(SEXP e) { struct CommonSenseRatio *h = (struct CommonSenseRatio *)R_ExternalPtrAddr(e); wickra_common_sense_ratio_reset(h); @@ -2507,6 +3123,14 @@ SEXP wk_composite_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(2); return r; } +SEXP wk_composite_profile_warmup_period(SEXP e) { + struct CompositeProfile *h = (struct CompositeProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_composite_profile_warmup_period(h)); +} +SEXP wk_composite_profile_is_ready(SEXP e) { + struct CompositeProfile *h = (struct CompositeProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_composite_profile_is_ready(h)); +} SEXP wk_composite_profile_reset(SEXP e) { struct CompositeProfile *h = (struct CompositeProfile *)R_ExternalPtrAddr(e); wickra_composite_profile_reset(h); @@ -2540,6 +3164,14 @@ SEXP wk_concealing_baby_swallow_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 UNPROTECT(1); return out; } +SEXP wk_concealing_baby_swallow_warmup_period(SEXP e) { + struct ConcealingBabySwallow *h = (struct ConcealingBabySwallow *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_concealing_baby_swallow_warmup_period(h)); +} +SEXP wk_concealing_baby_swallow_is_ready(SEXP e) { + struct ConcealingBabySwallow *h = (struct ConcealingBabySwallow *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_concealing_baby_swallow_is_ready(h)); +} SEXP wk_concealing_baby_swallow_reset(SEXP e) { struct ConcealingBabySwallow *h = (struct ConcealingBabySwallow *)R_ExternalPtrAddr(e); wickra_concealing_baby_swallow_reset(h); @@ -2571,6 +3203,14 @@ SEXP wk_conditional_value_at_risk_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_conditional_value_at_risk_warmup_period(SEXP e) { + struct ConditionalValueAtRisk *h = (struct ConditionalValueAtRisk *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_conditional_value_at_risk_warmup_period(h)); +} +SEXP wk_conditional_value_at_risk_is_ready(SEXP e) { + struct ConditionalValueAtRisk *h = (struct ConditionalValueAtRisk *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_conditional_value_at_risk_is_ready(h)); +} SEXP wk_conditional_value_at_risk_reset(SEXP e) { struct ConditionalValueAtRisk *h = (struct ConditionalValueAtRisk *)R_ExternalPtrAddr(e); wickra_conditional_value_at_risk_reset(h); @@ -2602,6 +3242,14 @@ SEXP wk_connors_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_connors_rsi_warmup_period(SEXP e) { + struct ConnorsRsi *h = (struct ConnorsRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_connors_rsi_warmup_period(h)); +} +SEXP wk_connors_rsi_is_ready(SEXP e) { + struct ConnorsRsi *h = (struct ConnorsRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_connors_rsi_is_ready(h)); +} SEXP wk_connors_rsi_reset(SEXP e) { struct ConnorsRsi *h = (struct ConnorsRsi *)R_ExternalPtrAddr(e); wickra_connors_rsi_reset(h); @@ -2633,6 +3281,14 @@ SEXP wk_coppock_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_coppock_warmup_period(SEXP e) { + struct Coppock *h = (struct Coppock *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_coppock_warmup_period(h)); +} +SEXP wk_coppock_is_ready(SEXP e) { + struct Coppock *h = (struct Coppock *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_coppock_is_ready(h)); +} SEXP wk_coppock_reset(SEXP e) { struct Coppock *h = (struct Coppock *)R_ExternalPtrAddr(e); wickra_coppock_reset(h); @@ -2664,6 +3320,14 @@ SEXP wk_correlation_trend_indicator_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_correlation_trend_indicator_warmup_period(SEXP e) { + struct CorrelationTrendIndicator *h = (struct CorrelationTrendIndicator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_correlation_trend_indicator_warmup_period(h)); +} +SEXP wk_correlation_trend_indicator_is_ready(SEXP e) { + struct CorrelationTrendIndicator *h = (struct CorrelationTrendIndicator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_correlation_trend_indicator_is_ready(h)); +} SEXP wk_correlation_trend_indicator_reset(SEXP e) { struct CorrelationTrendIndicator *h = (struct CorrelationTrendIndicator *)R_ExternalPtrAddr(e); wickra_correlation_trend_indicator_reset(h); @@ -2697,6 +3361,14 @@ SEXP wk_counterattack_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_counterattack_warmup_period(SEXP e) { + struct Counterattack *h = (struct Counterattack *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_counterattack_warmup_period(h)); +} +SEXP wk_counterattack_is_ready(SEXP e) { + struct Counterattack *h = (struct Counterattack *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_counterattack_is_ready(h)); +} SEXP wk_counterattack_reset(SEXP e) { struct Counterattack *h = (struct Counterattack *)R_ExternalPtrAddr(e); wickra_counterattack_reset(h); @@ -2730,6 +3402,14 @@ SEXP wk_crab_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_crab_warmup_period(SEXP e) { + struct Crab *h = (struct Crab *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_crab_warmup_period(h)); +} +SEXP wk_crab_is_ready(SEXP e) { + struct Crab *h = (struct Crab *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_crab_is_ready(h)); +} SEXP wk_crab_reset(SEXP e) { struct Crab *h = (struct Crab *)R_ExternalPtrAddr(e); wickra_crab_reset(h); @@ -2753,6 +3433,14 @@ SEXP wk_cumulative_volume_delta_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a struct CumulativeVolumeDelta *h = (struct CumulativeVolumeDelta *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_cumulative_volume_delta_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_cumulative_volume_delta_warmup_period(SEXP e) { + struct CumulativeVolumeDelta *h = (struct CumulativeVolumeDelta *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cumulative_volume_delta_warmup_period(h)); +} +SEXP wk_cumulative_volume_delta_is_ready(SEXP e) { + struct CumulativeVolumeDelta *h = (struct CumulativeVolumeDelta *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cumulative_volume_delta_is_ready(h)); +} SEXP wk_cumulative_volume_delta_reset(SEXP e) { struct CumulativeVolumeDelta *h = (struct CumulativeVolumeDelta *)R_ExternalPtrAddr(e); wickra_cumulative_volume_delta_reset(h); @@ -2776,6 +3464,14 @@ SEXP wk_cumulative_volume_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a struct CumulativeVolumeIndex *h = (struct CumulativeVolumeIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_cumulative_volume_index_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_cumulative_volume_index_warmup_period(SEXP e) { + struct CumulativeVolumeIndex *h = (struct CumulativeVolumeIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cumulative_volume_index_warmup_period(h)); +} +SEXP wk_cumulative_volume_index_is_ready(SEXP e) { + struct CumulativeVolumeIndex *h = (struct CumulativeVolumeIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cumulative_volume_index_is_ready(h)); +} SEXP wk_cumulative_volume_index_reset(SEXP e) { struct CumulativeVolumeIndex *h = (struct CumulativeVolumeIndex *)R_ExternalPtrAddr(e); wickra_cumulative_volume_index_reset(h); @@ -2809,6 +3505,14 @@ SEXP wk_cup_and_handle_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_cup_and_handle_warmup_period(SEXP e) { + struct CupAndHandle *h = (struct CupAndHandle *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cup_and_handle_warmup_period(h)); +} +SEXP wk_cup_and_handle_is_ready(SEXP e) { + struct CupAndHandle *h = (struct CupAndHandle *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cup_and_handle_is_ready(h)); +} SEXP wk_cup_and_handle_reset(SEXP e) { struct CupAndHandle *h = (struct CupAndHandle *)R_ExternalPtrAddr(e); wickra_cup_and_handle_reset(h); @@ -2840,6 +3544,14 @@ SEXP wk_cybernetic_cycle_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_cybernetic_cycle_warmup_period(SEXP e) { + struct CyberneticCycle *h = (struct CyberneticCycle *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cybernetic_cycle_warmup_period(h)); +} +SEXP wk_cybernetic_cycle_is_ready(SEXP e) { + struct CyberneticCycle *h = (struct CyberneticCycle *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cybernetic_cycle_is_ready(h)); +} SEXP wk_cybernetic_cycle_reset(SEXP e) { struct CyberneticCycle *h = (struct CyberneticCycle *)R_ExternalPtrAddr(e); wickra_cybernetic_cycle_reset(h); @@ -2873,6 +3585,14 @@ SEXP wk_cypher_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(1); return out; } +SEXP wk_cypher_warmup_period(SEXP e) { + struct Cypher *h = (struct Cypher *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_cypher_warmup_period(h)); +} +SEXP wk_cypher_is_ready(SEXP e) { + struct Cypher *h = (struct Cypher *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_cypher_is_ready(h)); +} SEXP wk_cypher_reset(SEXP e) { struct Cypher *h = (struct Cypher *)R_ExternalPtrAddr(e); wickra_cypher_reset(h); @@ -2903,6 +3623,14 @@ SEXP wk_day_of_week_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(2); return vv; } +SEXP wk_day_of_week_profile_warmup_period(SEXP e) { + struct DayOfWeekProfile *h = (struct DayOfWeekProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_day_of_week_profile_warmup_period(h)); +} +SEXP wk_day_of_week_profile_is_ready(SEXP e) { + struct DayOfWeekProfile *h = (struct DayOfWeekProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_day_of_week_profile_is_ready(h)); +} SEXP wk_day_of_week_profile_reset(SEXP e) { struct DayOfWeekProfile *h = (struct DayOfWeekProfile *)R_ExternalPtrAddr(e); wickra_day_of_week_profile_reset(h); @@ -2934,6 +3662,14 @@ SEXP wk_decycler_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_decycler_warmup_period(SEXP e) { + struct Decycler *h = (struct Decycler *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_decycler_warmup_period(h)); +} +SEXP wk_decycler_is_ready(SEXP e) { + struct Decycler *h = (struct Decycler *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_decycler_is_ready(h)); +} SEXP wk_decycler_reset(SEXP e) { struct Decycler *h = (struct Decycler *)R_ExternalPtrAddr(e); wickra_decycler_reset(h); @@ -2965,6 +3701,14 @@ SEXP wk_decycler_oscillator_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_decycler_oscillator_warmup_period(SEXP e) { + struct DecyclerOscillator *h = (struct DecyclerOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_decycler_oscillator_warmup_period(h)); +} +SEXP wk_decycler_oscillator_is_ready(SEXP e) { + struct DecyclerOscillator *h = (struct DecyclerOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_decycler_oscillator_is_ready(h)); +} SEXP wk_decycler_oscillator_reset(SEXP e) { struct DecyclerOscillator *h = (struct DecyclerOscillator *)R_ExternalPtrAddr(e); wickra_decycler_oscillator_reset(h); @@ -2996,6 +3740,14 @@ SEXP wk_dema_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_dema_warmup_period(SEXP e) { + struct Dema *h = (struct Dema *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_dema_warmup_period(h)); +} +SEXP wk_dema_is_ready(SEXP e) { + struct Dema *h = (struct Dema *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_dema_is_ready(h)); +} SEXP wk_dema_reset(SEXP e) { struct Dema *h = (struct Dema *)R_ExternalPtrAddr(e); wickra_dema_reset(h); @@ -3029,6 +3781,14 @@ SEXP wk_demand_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_demand_index_warmup_period(SEXP e) { + struct DemandIndex *h = (struct DemandIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_demand_index_warmup_period(h)); +} +SEXP wk_demand_index_is_ready(SEXP e) { + struct DemandIndex *h = (struct DemandIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_demand_index_is_ready(h)); +} SEXP wk_demand_index_reset(SEXP e) { struct DemandIndex *h = (struct DemandIndex *)R_ExternalPtrAddr(e); wickra_demand_index_reset(h); @@ -3064,6 +3824,14 @@ SEXP wk_demark_pivots_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_demark_pivots_warmup_period(SEXP e) { + struct DemarkPivots *h = (struct DemarkPivots *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_demark_pivots_warmup_period(h)); +} +SEXP wk_demark_pivots_is_ready(SEXP e) { + struct DemarkPivots *h = (struct DemarkPivots *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_demark_pivots_is_ready(h)); +} SEXP wk_demark_pivots_reset(SEXP e) { struct DemarkPivots *h = (struct DemarkPivots *)R_ExternalPtrAddr(e); wickra_demark_pivots_reset(h); @@ -3087,6 +3855,14 @@ SEXP wk_depth_slope_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct DepthSlope *h = (struct DepthSlope *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_depth_slope_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_depth_slope_warmup_period(SEXP e) { + struct DepthSlope *h = (struct DepthSlope *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_depth_slope_warmup_period(h)); +} +SEXP wk_depth_slope_is_ready(SEXP e) { + struct DepthSlope *h = (struct DepthSlope *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_depth_slope_is_ready(h)); +} SEXP wk_depth_slope_reset(SEXP e) { struct DepthSlope *h = (struct DepthSlope *)R_ExternalPtrAddr(e); wickra_depth_slope_reset(h); @@ -3118,6 +3894,14 @@ SEXP wk_derivative_oscillator_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_derivative_oscillator_warmup_period(SEXP e) { + struct DerivativeOscillator *h = (struct DerivativeOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_derivative_oscillator_warmup_period(h)); +} +SEXP wk_derivative_oscillator_is_ready(SEXP e) { + struct DerivativeOscillator *h = (struct DerivativeOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_derivative_oscillator_is_ready(h)); +} SEXP wk_derivative_oscillator_reset(SEXP e) { struct DerivativeOscillator *h = (struct DerivativeOscillator *)R_ExternalPtrAddr(e); wickra_derivative_oscillator_reset(h); @@ -3149,6 +3933,14 @@ SEXP wk_detrended_std_dev_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_detrended_std_dev_warmup_period(SEXP e) { + struct DetrendedStdDev *h = (struct DetrendedStdDev *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_detrended_std_dev_warmup_period(h)); +} +SEXP wk_detrended_std_dev_is_ready(SEXP e) { + struct DetrendedStdDev *h = (struct DetrendedStdDev *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_detrended_std_dev_is_ready(h)); +} SEXP wk_detrended_std_dev_reset(SEXP e) { struct DetrendedStdDev *h = (struct DetrendedStdDev *)R_ExternalPtrAddr(e); wickra_detrended_std_dev_reset(h); @@ -3180,6 +3972,14 @@ SEXP wk_disparity_index_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_disparity_index_warmup_period(SEXP e) { + struct DisparityIndex *h = (struct DisparityIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_disparity_index_warmup_period(h)); +} +SEXP wk_disparity_index_is_ready(SEXP e) { + struct DisparityIndex *h = (struct DisparityIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_disparity_index_is_ready(h)); +} SEXP wk_disparity_index_reset(SEXP e) { struct DisparityIndex *h = (struct DisparityIndex *)R_ExternalPtrAddr(e); wickra_disparity_index_reset(h); @@ -3211,6 +4011,14 @@ SEXP wk_distance_ssd_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_distance_ssd_warmup_period(SEXP e) { + struct DistanceSsd *h = (struct DistanceSsd *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_distance_ssd_warmup_period(h)); +} +SEXP wk_distance_ssd_is_ready(SEXP e) { + struct DistanceSsd *h = (struct DistanceSsd *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_distance_ssd_is_ready(h)); +} SEXP wk_distance_ssd_reset(SEXP e) { struct DistanceSsd *h = (struct DistanceSsd *)R_ExternalPtrAddr(e); wickra_distance_ssd_reset(h); @@ -3244,6 +4052,14 @@ SEXP wk_doji_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_doji_warmup_period(SEXP e) { + struct Doji *h = (struct Doji *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_doji_warmup_period(h)); +} +SEXP wk_doji_is_ready(SEXP e) { + struct Doji *h = (struct Doji *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_doji_is_ready(h)); +} SEXP wk_doji_reset(SEXP e) { struct Doji *h = (struct Doji *)R_ExternalPtrAddr(e); wickra_doji_reset(h); @@ -3277,6 +4093,14 @@ SEXP wk_doji_star_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_doji_star_warmup_period(SEXP e) { + struct DojiStar *h = (struct DojiStar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_doji_star_warmup_period(h)); +} +SEXP wk_doji_star_is_ready(SEXP e) { + struct DojiStar *h = (struct DojiStar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_doji_star_is_ready(h)); +} SEXP wk_doji_star_reset(SEXP e) { struct DojiStar *h = (struct DojiStar *)R_ExternalPtrAddr(e); wickra_doji_star_reset(h); @@ -3357,6 +4181,14 @@ SEXP wk_donchian_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(2); return r; } +SEXP wk_donchian_warmup_period(SEXP e) { + struct Donchian *h = (struct Donchian *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_donchian_warmup_period(h)); +} +SEXP wk_donchian_is_ready(SEXP e) { + struct Donchian *h = (struct Donchian *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_donchian_is_ready(h)); +} SEXP wk_donchian_reset(SEXP e) { struct Donchian *h = (struct Donchian *)R_ExternalPtrAddr(e); wickra_donchian_reset(h); @@ -3390,6 +4222,14 @@ SEXP wk_donchian_stop_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_donchian_stop_warmup_period(SEXP e) { + struct DonchianStop *h = (struct DonchianStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_donchian_stop_warmup_period(h)); +} +SEXP wk_donchian_stop_is_ready(SEXP e) { + struct DonchianStop *h = (struct DonchianStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_donchian_stop_is_ready(h)); +} SEXP wk_donchian_stop_reset(SEXP e) { struct DonchianStop *h = (struct DonchianStop *)R_ExternalPtrAddr(e); wickra_donchian_stop_reset(h); @@ -3429,6 +4269,14 @@ SEXP wk_double_bollinger_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_double_bollinger_warmup_period(SEXP e) { + struct DoubleBollinger *h = (struct DoubleBollinger *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_double_bollinger_warmup_period(h)); +} +SEXP wk_double_bollinger_is_ready(SEXP e) { + struct DoubleBollinger *h = (struct DoubleBollinger *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_double_bollinger_is_ready(h)); +} SEXP wk_double_bollinger_reset(SEXP e) { struct DoubleBollinger *h = (struct DoubleBollinger *)R_ExternalPtrAddr(e); wickra_double_bollinger_reset(h); @@ -3462,6 +4310,14 @@ SEXP wk_double_top_bottom_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_double_top_bottom_warmup_period(SEXP e) { + struct DoubleTopBottom *h = (struct DoubleTopBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_double_top_bottom_warmup_period(h)); +} +SEXP wk_double_top_bottom_is_ready(SEXP e) { + struct DoubleTopBottom *h = (struct DoubleTopBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_double_top_bottom_is_ready(h)); +} SEXP wk_double_top_bottom_reset(SEXP e) { struct DoubleTopBottom *h = (struct DoubleTopBottom *)R_ExternalPtrAddr(e); wickra_double_top_bottom_reset(h); @@ -3495,6 +4351,14 @@ SEXP wk_downside_gap_three_methods_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP UNPROTECT(1); return out; } +SEXP wk_downside_gap_three_methods_warmup_period(SEXP e) { + struct DownsideGapThreeMethods *h = (struct DownsideGapThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_downside_gap_three_methods_warmup_period(h)); +} +SEXP wk_downside_gap_three_methods_is_ready(SEXP e) { + struct DownsideGapThreeMethods *h = (struct DownsideGapThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_downside_gap_three_methods_is_ready(h)); +} SEXP wk_downside_gap_three_methods_reset(SEXP e) { struct DownsideGapThreeMethods *h = (struct DownsideGapThreeMethods *)R_ExternalPtrAddr(e); wickra_downside_gap_three_methods_reset(h); @@ -3526,6 +4390,14 @@ SEXP wk_dpo_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_dpo_warmup_period(SEXP e) { + struct Dpo *h = (struct Dpo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_dpo_warmup_period(h)); +} +SEXP wk_dpo_is_ready(SEXP e) { + struct Dpo *h = (struct Dpo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_dpo_is_ready(h)); +} SEXP wk_dpo_reset(SEXP e) { struct Dpo *h = (struct Dpo *)R_ExternalPtrAddr(e); wickra_dpo_reset(h); @@ -3559,6 +4431,14 @@ SEXP wk_dragonfly_doji_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_dragonfly_doji_warmup_period(SEXP e) { + struct DragonflyDoji *h = (struct DragonflyDoji *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_dragonfly_doji_warmup_period(h)); +} +SEXP wk_dragonfly_doji_is_ready(SEXP e) { + struct DragonflyDoji *h = (struct DragonflyDoji *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_dragonfly_doji_is_ready(h)); +} SEXP wk_dragonfly_doji_reset(SEXP e) { struct DragonflyDoji *h = (struct DragonflyDoji *)R_ExternalPtrAddr(e); wickra_dragonfly_doji_reset(h); @@ -3590,6 +4470,14 @@ SEXP wk_drawdown_duration_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_drawdown_duration_warmup_period(SEXP e) { + struct DrawdownDuration *h = (struct DrawdownDuration *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_drawdown_duration_warmup_period(h)); +} +SEXP wk_drawdown_duration_is_ready(SEXP e) { + struct DrawdownDuration *h = (struct DrawdownDuration *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_drawdown_duration_is_ready(h)); +} SEXP wk_drawdown_duration_reset(SEXP e) { struct DrawdownDuration *h = (struct DrawdownDuration *)R_ExternalPtrAddr(e); wickra_drawdown_duration_reset(h); @@ -3623,6 +4511,14 @@ SEXP wk_dumpling_top_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_dumpling_top_warmup_period(SEXP e) { + struct DumplingTop *h = (struct DumplingTop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_dumpling_top_warmup_period(h)); +} +SEXP wk_dumpling_top_is_ready(SEXP e) { + struct DumplingTop *h = (struct DumplingTop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_dumpling_top_is_ready(h)); +} SEXP wk_dumpling_top_reset(SEXP e) { struct DumplingTop *h = (struct DumplingTop *)R_ExternalPtrAddr(e); wickra_dumpling_top_reset(h); @@ -3656,6 +4552,14 @@ SEXP wk_dx_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) { UNPROTECT(1); return out; } +SEXP wk_dx_warmup_period(SEXP e) { + struct Dx *h = (struct Dx *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_dx_warmup_period(h)); +} +SEXP wk_dx_is_ready(SEXP e) { + struct Dx *h = (struct Dx *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_dx_is_ready(h)); +} SEXP wk_dx_reset(SEXP e) { struct Dx *h = (struct Dx *)R_ExternalPtrAddr(e); wickra_dx_reset(h); @@ -3687,6 +4591,14 @@ SEXP wk_dynamic_momentum_index_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_dynamic_momentum_index_warmup_period(SEXP e) { + struct DynamicMomentumIndex *h = (struct DynamicMomentumIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_dynamic_momentum_index_warmup_period(h)); +} +SEXP wk_dynamic_momentum_index_is_ready(SEXP e) { + struct DynamicMomentumIndex *h = (struct DynamicMomentumIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_dynamic_momentum_index_is_ready(h)); +} SEXP wk_dynamic_momentum_index_reset(SEXP e) { struct DynamicMomentumIndex *h = (struct DynamicMomentumIndex *)R_ExternalPtrAddr(e); wickra_dynamic_momentum_index_reset(h); @@ -3720,6 +4632,14 @@ SEXP wk_ease_of_movement_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_ease_of_movement_warmup_period(SEXP e) { + struct EaseOfMovement *h = (struct EaseOfMovement *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ease_of_movement_warmup_period(h)); +} +SEXP wk_ease_of_movement_is_ready(SEXP e) { + struct EaseOfMovement *h = (struct EaseOfMovement *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ease_of_movement_is_ready(h)); +} SEXP wk_ease_of_movement_reset(SEXP e) { struct EaseOfMovement *h = (struct EaseOfMovement *)R_ExternalPtrAddr(e); wickra_ease_of_movement_reset(h); @@ -3743,6 +4663,14 @@ SEXP wk_effective_spread_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP struct EffectiveSpread *h = (struct EffectiveSpread *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_effective_spread_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3), Rf_asReal(a4))); } +SEXP wk_effective_spread_warmup_period(SEXP e) { + struct EffectiveSpread *h = (struct EffectiveSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_effective_spread_warmup_period(h)); +} +SEXP wk_effective_spread_is_ready(SEXP e) { + struct EffectiveSpread *h = (struct EffectiveSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_effective_spread_is_ready(h)); +} SEXP wk_effective_spread_reset(SEXP e) { struct EffectiveSpread *h = (struct EffectiveSpread *)R_ExternalPtrAddr(e); wickra_effective_spread_reset(h); @@ -3774,6 +4702,14 @@ SEXP wk_ehlers_stochastic_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ehlers_stochastic_warmup_period(SEXP e) { + struct EhlersStochastic *h = (struct EhlersStochastic *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ehlers_stochastic_warmup_period(h)); +} +SEXP wk_ehlers_stochastic_is_ready(SEXP e) { + struct EhlersStochastic *h = (struct EhlersStochastic *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ehlers_stochastic_is_ready(h)); +} SEXP wk_ehlers_stochastic_reset(SEXP e) { struct EhlersStochastic *h = (struct EhlersStochastic *)R_ExternalPtrAddr(e); wickra_ehlers_stochastic_reset(h); @@ -3805,6 +4741,14 @@ SEXP wk_ehma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ehma_warmup_period(SEXP e) { + struct Ehma *h = (struct Ehma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ehma_warmup_period(h)); +} +SEXP wk_ehma_is_ready(SEXP e) { + struct Ehma *h = (struct Ehma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ehma_is_ready(h)); +} SEXP wk_ehma_reset(SEXP e) { struct Ehma *h = (struct Ehma *)R_ExternalPtrAddr(e); wickra_ehma_reset(h); @@ -3836,6 +4780,14 @@ SEXP wk_elder_impulse_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_elder_impulse_warmup_period(SEXP e) { + struct ElderImpulse *h = (struct ElderImpulse *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_elder_impulse_warmup_period(h)); +} +SEXP wk_elder_impulse_is_ready(SEXP e) { + struct ElderImpulse *h = (struct ElderImpulse *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_elder_impulse_is_ready(h)); +} SEXP wk_elder_impulse_reset(SEXP e) { struct ElderImpulse *h = (struct ElderImpulse *)R_ExternalPtrAddr(e); wickra_elder_impulse_reset(h); @@ -3869,6 +4821,14 @@ SEXP wk_elder_ray_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(2); return r; } +SEXP wk_elder_ray_warmup_period(SEXP e) { + struct ElderRay *h = (struct ElderRay *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_elder_ray_warmup_period(h)); +} +SEXP wk_elder_ray_is_ready(SEXP e) { + struct ElderRay *h = (struct ElderRay *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_elder_ray_is_ready(h)); +} SEXP wk_elder_ray_reset(SEXP e) { struct ElderRay *h = (struct ElderRay *)R_ExternalPtrAddr(e); wickra_elder_ray_reset(h); @@ -3902,6 +4862,14 @@ SEXP wk_elder_safe_zone_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_elder_safe_zone_warmup_period(SEXP e) { + struct ElderSafeZone *h = (struct ElderSafeZone *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_elder_safe_zone_warmup_period(h)); +} +SEXP wk_elder_safe_zone_is_ready(SEXP e) { + struct ElderSafeZone *h = (struct ElderSafeZone *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_elder_safe_zone_is_ready(h)); +} SEXP wk_elder_safe_zone_reset(SEXP e) { struct ElderSafeZone *h = (struct ElderSafeZone *)R_ExternalPtrAddr(e); wickra_elder_safe_zone_reset(h); @@ -3933,6 +4901,14 @@ SEXP wk_ema_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ema_warmup_period(SEXP e) { + struct Ema *h = (struct Ema *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ema_warmup_period(h)); +} +SEXP wk_ema_is_ready(SEXP e) { + struct Ema *h = (struct Ema *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ema_is_ready(h)); +} SEXP wk_ema_reset(SEXP e) { struct Ema *h = (struct Ema *)R_ExternalPtrAddr(e); wickra_ema_reset(h); @@ -3964,6 +4940,14 @@ SEXP wk_empirical_mode_decomposition_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_empirical_mode_decomposition_warmup_period(SEXP e) { + struct EmpiricalModeDecomposition *h = (struct EmpiricalModeDecomposition *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_empirical_mode_decomposition_warmup_period(h)); +} +SEXP wk_empirical_mode_decomposition_is_ready(SEXP e) { + struct EmpiricalModeDecomposition *h = (struct EmpiricalModeDecomposition *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_empirical_mode_decomposition_is_ready(h)); +} SEXP wk_empirical_mode_decomposition_reset(SEXP e) { struct EmpiricalModeDecomposition *h = (struct EmpiricalModeDecomposition *)R_ExternalPtrAddr(e); wickra_empirical_mode_decomposition_reset(h); @@ -3997,6 +4981,14 @@ SEXP wk_engulfing_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_engulfing_warmup_period(SEXP e) { + struct Engulfing *h = (struct Engulfing *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_engulfing_warmup_period(h)); +} +SEXP wk_engulfing_is_ready(SEXP e) { + struct Engulfing *h = (struct Engulfing *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_engulfing_is_ready(h)); +} SEXP wk_engulfing_reset(SEXP e) { struct Engulfing *h = (struct Engulfing *)R_ExternalPtrAddr(e); wickra_engulfing_reset(h); @@ -4030,6 +5022,14 @@ SEXP wk_equivolume_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(2); return r; } +SEXP wk_equivolume_warmup_period(SEXP e) { + struct Equivolume *h = (struct Equivolume *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_equivolume_warmup_period(h)); +} +SEXP wk_equivolume_is_ready(SEXP e) { + struct Equivolume *h = (struct Equivolume *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_equivolume_is_ready(h)); +} SEXP wk_equivolume_reset(SEXP e) { struct Equivolume *h = (struct Equivolume *)R_ExternalPtrAddr(e); wickra_equivolume_reset(h); @@ -4053,6 +5053,14 @@ SEXP wk_estimated_leverage_ratio_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP struct EstimatedLeverageRatio *h = (struct EstimatedLeverageRatio *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_estimated_leverage_ratio_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_estimated_leverage_ratio_warmup_period(SEXP e) { + struct EstimatedLeverageRatio *h = (struct EstimatedLeverageRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_estimated_leverage_ratio_warmup_period(h)); +} +SEXP wk_estimated_leverage_ratio_is_ready(SEXP e) { + struct EstimatedLeverageRatio *h = (struct EstimatedLeverageRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_estimated_leverage_ratio_is_ready(h)); +} SEXP wk_estimated_leverage_ratio_reset(SEXP e) { struct EstimatedLeverageRatio *h = (struct EstimatedLeverageRatio *)R_ExternalPtrAddr(e); wickra_estimated_leverage_ratio_reset(h); @@ -4084,6 +5092,14 @@ SEXP wk_even_better_sinewave_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_even_better_sinewave_warmup_period(SEXP e) { + struct EvenBetterSinewave *h = (struct EvenBetterSinewave *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_even_better_sinewave_warmup_period(h)); +} +SEXP wk_even_better_sinewave_is_ready(SEXP e) { + struct EvenBetterSinewave *h = (struct EvenBetterSinewave *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_even_better_sinewave_is_ready(h)); +} SEXP wk_even_better_sinewave_reset(SEXP e) { struct EvenBetterSinewave *h = (struct EvenBetterSinewave *)R_ExternalPtrAddr(e); wickra_even_better_sinewave_reset(h); @@ -4117,6 +5133,14 @@ SEXP wk_evening_doji_star_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_evening_doji_star_warmup_period(SEXP e) { + struct EveningDojiStar *h = (struct EveningDojiStar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_evening_doji_star_warmup_period(h)); +} +SEXP wk_evening_doji_star_is_ready(SEXP e) { + struct EveningDojiStar *h = (struct EveningDojiStar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_evening_doji_star_is_ready(h)); +} SEXP wk_evening_doji_star_reset(SEXP e) { struct EveningDojiStar *h = (struct EveningDojiStar *)R_ExternalPtrAddr(e); wickra_evening_doji_star_reset(h); @@ -4150,6 +5174,14 @@ SEXP wk_evwma_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5 UNPROTECT(1); return out; } +SEXP wk_evwma_warmup_period(SEXP e) { + struct Evwma *h = (struct Evwma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_evwma_warmup_period(h)); +} +SEXP wk_evwma_is_ready(SEXP e) { + struct Evwma *h = (struct Evwma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_evwma_is_ready(h)); +} SEXP wk_evwma_reset(SEXP e) { struct Evwma *h = (struct Evwma *)R_ExternalPtrAddr(e); wickra_evwma_reset(h); @@ -4181,6 +5213,14 @@ SEXP wk_ewma_volatility_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ewma_volatility_warmup_period(SEXP e) { + struct EwmaVolatility *h = (struct EwmaVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ewma_volatility_warmup_period(h)); +} +SEXP wk_ewma_volatility_is_ready(SEXP e) { + struct EwmaVolatility *h = (struct EwmaVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ewma_volatility_is_ready(h)); +} SEXP wk_ewma_volatility_reset(SEXP e) { struct EwmaVolatility *h = (struct EwmaVolatility *)R_ExternalPtrAddr(e); wickra_ewma_volatility_reset(h); @@ -4212,6 +5252,14 @@ SEXP wk_expectancy_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_expectancy_warmup_period(SEXP e) { + struct Expectancy *h = (struct Expectancy *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_expectancy_warmup_period(h)); +} +SEXP wk_expectancy_is_ready(SEXP e) { + struct Expectancy *h = (struct Expectancy *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_expectancy_is_ready(h)); +} SEXP wk_expectancy_reset(SEXP e) { struct Expectancy *h = (struct Expectancy *)R_ExternalPtrAddr(e); wickra_expectancy_reset(h); @@ -4245,6 +5293,14 @@ SEXP wk_falling_three_methods_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_falling_three_methods_warmup_period(SEXP e) { + struct FallingThreeMethods *h = (struct FallingThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_falling_three_methods_warmup_period(h)); +} +SEXP wk_falling_three_methods_is_ready(SEXP e) { + struct FallingThreeMethods *h = (struct FallingThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_falling_three_methods_is_ready(h)); +} SEXP wk_falling_three_methods_reset(SEXP e) { struct FallingThreeMethods *h = (struct FallingThreeMethods *)R_ExternalPtrAddr(e); wickra_falling_three_methods_reset(h); @@ -4276,6 +5332,14 @@ SEXP wk_fama_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_fama_warmup_period(SEXP e) { + struct Fama *h = (struct Fama *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fama_warmup_period(h)); +} +SEXP wk_fama_is_ready(SEXP e) { + struct Fama *h = (struct Fama *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fama_is_ready(h)); +} SEXP wk_fama_reset(SEXP e) { struct Fama *h = (struct Fama *)R_ExternalPtrAddr(e); wickra_fama_reset(h); @@ -4311,6 +5375,14 @@ SEXP wk_fib_arcs_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(2); return r; } +SEXP wk_fib_arcs_warmup_period(SEXP e) { + struct FibArcs *h = (struct FibArcs *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_arcs_warmup_period(h)); +} +SEXP wk_fib_arcs_is_ready(SEXP e) { + struct FibArcs *h = (struct FibArcs *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_arcs_is_ready(h)); +} SEXP wk_fib_arcs_reset(SEXP e) { struct FibArcs *h = (struct FibArcs *)R_ExternalPtrAddr(e); wickra_fib_arcs_reset(h); @@ -4348,6 +5420,14 @@ SEXP wk_fib_channel_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(2); return r; } +SEXP wk_fib_channel_warmup_period(SEXP e) { + struct FibChannel *h = (struct FibChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_channel_warmup_period(h)); +} +SEXP wk_fib_channel_is_ready(SEXP e) { + struct FibChannel *h = (struct FibChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_channel_is_ready(h)); +} SEXP wk_fib_channel_reset(SEXP e) { struct FibChannel *h = (struct FibChannel *)R_ExternalPtrAddr(e); wickra_fib_channel_reset(h); @@ -4381,6 +5461,14 @@ SEXP wk_fib_confluence_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(2); return r; } +SEXP wk_fib_confluence_warmup_period(SEXP e) { + struct FibConfluence *h = (struct FibConfluence *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_confluence_warmup_period(h)); +} +SEXP wk_fib_confluence_is_ready(SEXP e) { + struct FibConfluence *h = (struct FibConfluence *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_confluence_is_ready(h)); +} SEXP wk_fib_confluence_reset(SEXP e) { struct FibConfluence *h = (struct FibConfluence *)R_ExternalPtrAddr(e); wickra_fib_confluence_reset(h); @@ -4420,6 +5508,14 @@ SEXP wk_fib_extension_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_fib_extension_warmup_period(SEXP e) { + struct FibExtension *h = (struct FibExtension *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_extension_warmup_period(h)); +} +SEXP wk_fib_extension_is_ready(SEXP e) { + struct FibExtension *h = (struct FibExtension *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_extension_is_ready(h)); +} SEXP wk_fib_extension_reset(SEXP e) { struct FibExtension *h = (struct FibExtension *)R_ExternalPtrAddr(e); wickra_fib_extension_reset(h); @@ -4455,6 +5551,14 @@ SEXP wk_fib_fan_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(2); return r; } +SEXP wk_fib_fan_warmup_period(SEXP e) { + struct FibFan *h = (struct FibFan *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_fan_warmup_period(h)); +} +SEXP wk_fib_fan_is_ready(SEXP e) { + struct FibFan *h = (struct FibFan *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_fan_is_ready(h)); +} SEXP wk_fib_fan_reset(SEXP e) { struct FibFan *h = (struct FibFan *)R_ExternalPtrAddr(e); wickra_fib_fan_reset(h); @@ -4492,6 +5596,14 @@ SEXP wk_fib_projection_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(2); return r; } +SEXP wk_fib_projection_warmup_period(SEXP e) { + struct FibProjection *h = (struct FibProjection *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_projection_warmup_period(h)); +} +SEXP wk_fib_projection_is_ready(SEXP e) { + struct FibProjection *h = (struct FibProjection *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_projection_is_ready(h)); +} SEXP wk_fib_projection_reset(SEXP e) { struct FibProjection *h = (struct FibProjection *)R_ExternalPtrAddr(e); wickra_fib_projection_reset(h); @@ -4535,6 +5647,14 @@ SEXP wk_fib_retracement_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_fib_retracement_warmup_period(SEXP e) { + struct FibRetracement *h = (struct FibRetracement *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_retracement_warmup_period(h)); +} +SEXP wk_fib_retracement_is_ready(SEXP e) { + struct FibRetracement *h = (struct FibRetracement *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_retracement_is_ready(h)); +} SEXP wk_fib_retracement_reset(SEXP e) { struct FibRetracement *h = (struct FibRetracement *)R_ExternalPtrAddr(e); wickra_fib_retracement_reset(h); @@ -4568,6 +5688,14 @@ SEXP wk_fib_time_zones_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(2); return r; } +SEXP wk_fib_time_zones_warmup_period(SEXP e) { + struct FibTimeZones *h = (struct FibTimeZones *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fib_time_zones_warmup_period(h)); +} +SEXP wk_fib_time_zones_is_ready(SEXP e) { + struct FibTimeZones *h = (struct FibTimeZones *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fib_time_zones_is_ready(h)); +} SEXP wk_fib_time_zones_reset(SEXP e) { struct FibTimeZones *h = (struct FibTimeZones *)R_ExternalPtrAddr(e); wickra_fib_time_zones_reset(h); @@ -4611,6 +5739,14 @@ SEXP wk_fibonacci_pivots_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_fibonacci_pivots_warmup_period(SEXP e) { + struct FibonacciPivots *h = (struct FibonacciPivots *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fibonacci_pivots_warmup_period(h)); +} +SEXP wk_fibonacci_pivots_is_ready(SEXP e) { + struct FibonacciPivots *h = (struct FibonacciPivots *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fibonacci_pivots_is_ready(h)); +} SEXP wk_fibonacci_pivots_reset(SEXP e) { struct FibonacciPivots *h = (struct FibonacciPivots *)R_ExternalPtrAddr(e); wickra_fibonacci_pivots_reset(h); @@ -4642,6 +5778,14 @@ SEXP wk_fisher_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_fisher_rsi_warmup_period(SEXP e) { + struct FisherRsi *h = (struct FisherRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fisher_rsi_warmup_period(h)); +} +SEXP wk_fisher_rsi_is_ready(SEXP e) { + struct FisherRsi *h = (struct FisherRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fisher_rsi_is_ready(h)); +} SEXP wk_fisher_rsi_reset(SEXP e) { struct FisherRsi *h = (struct FisherRsi *)R_ExternalPtrAddr(e); wickra_fisher_rsi_reset(h); @@ -4673,6 +5817,14 @@ SEXP wk_fisher_transform_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_fisher_transform_warmup_period(SEXP e) { + struct FisherTransform *h = (struct FisherTransform *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fisher_transform_warmup_period(h)); +} +SEXP wk_fisher_transform_is_ready(SEXP e) { + struct FisherTransform *h = (struct FisherTransform *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fisher_transform_is_ready(h)); +} SEXP wk_fisher_transform_reset(SEXP e) { struct FisherTransform *h = (struct FisherTransform *)R_ExternalPtrAddr(e); wickra_fisher_transform_reset(h); @@ -4706,6 +5858,14 @@ SEXP wk_flag_pennant_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_flag_pennant_warmup_period(SEXP e) { + struct FlagPennant *h = (struct FlagPennant *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_flag_pennant_warmup_period(h)); +} +SEXP wk_flag_pennant_is_ready(SEXP e) { + struct FlagPennant *h = (struct FlagPennant *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_flag_pennant_is_ready(h)); +} SEXP wk_flag_pennant_reset(SEXP e) { struct FlagPennant *h = (struct FlagPennant *)R_ExternalPtrAddr(e); wickra_flag_pennant_reset(h); @@ -4745,6 +5905,14 @@ SEXP wk_footprint_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { UNPROTECT(3); return r; } +SEXP wk_footprint_warmup_period(SEXP e) { + struct Footprint *h = (struct Footprint *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_footprint_warmup_period(h)); +} +SEXP wk_footprint_is_ready(SEXP e) { + struct Footprint *h = (struct Footprint *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_footprint_is_ready(h)); +} SEXP wk_footprint_reset(SEXP e) { struct Footprint *h = (struct Footprint *)R_ExternalPtrAddr(e); wickra_footprint_reset(h); @@ -4778,6 +5946,14 @@ SEXP wk_force_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(1); return out; } +SEXP wk_force_index_warmup_period(SEXP e) { + struct ForceIndex *h = (struct ForceIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_force_index_warmup_period(h)); +} +SEXP wk_force_index_is_ready(SEXP e) { + struct ForceIndex *h = (struct ForceIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_force_index_is_ready(h)); +} SEXP wk_force_index_reset(SEXP e) { struct ForceIndex *h = (struct ForceIndex *)R_ExternalPtrAddr(e); wickra_force_index_reset(h); @@ -4811,6 +5987,14 @@ SEXP wk_fractal_chaos_bands_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(2); return r; } +SEXP wk_fractal_chaos_bands_warmup_period(SEXP e) { + struct FractalChaosBands *h = (struct FractalChaosBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fractal_chaos_bands_warmup_period(h)); +} +SEXP wk_fractal_chaos_bands_is_ready(SEXP e) { + struct FractalChaosBands *h = (struct FractalChaosBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fractal_chaos_bands_is_ready(h)); +} SEXP wk_fractal_chaos_bands_reset(SEXP e) { struct FractalChaosBands *h = (struct FractalChaosBands *)R_ExternalPtrAddr(e); wickra_fractal_chaos_bands_reset(h); @@ -4842,6 +6026,14 @@ SEXP wk_frama_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_frama_warmup_period(SEXP e) { + struct Frama *h = (struct Frama *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_frama_warmup_period(h)); +} +SEXP wk_frama_is_ready(SEXP e) { + struct Frama *h = (struct Frama *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_frama_is_ready(h)); +} SEXP wk_frama_reset(SEXP e) { struct Frama *h = (struct Frama *)R_ExternalPtrAddr(e); wickra_frama_reset(h); @@ -4875,6 +6067,14 @@ SEXP wk_fry_pan_bottom_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_fry_pan_bottom_warmup_period(SEXP e) { + struct FryPanBottom *h = (struct FryPanBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_fry_pan_bottom_warmup_period(h)); +} +SEXP wk_fry_pan_bottom_is_ready(SEXP e) { + struct FryPanBottom *h = (struct FryPanBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_fry_pan_bottom_is_ready(h)); +} SEXP wk_fry_pan_bottom_reset(SEXP e) { struct FryPanBottom *h = (struct FryPanBottom *)R_ExternalPtrAddr(e); wickra_fry_pan_bottom_reset(h); @@ -4898,6 +6098,14 @@ SEXP wk_funding_basis_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 struct FundingBasis *h = (struct FundingBasis *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_funding_basis_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_funding_basis_warmup_period(SEXP e) { + struct FundingBasis *h = (struct FundingBasis *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_funding_basis_warmup_period(h)); +} +SEXP wk_funding_basis_is_ready(SEXP e) { + struct FundingBasis *h = (struct FundingBasis *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_funding_basis_is_ready(h)); +} SEXP wk_funding_basis_reset(SEXP e) { struct FundingBasis *h = (struct FundingBasis *)R_ExternalPtrAddr(e); wickra_funding_basis_reset(h); @@ -4921,6 +6129,14 @@ SEXP wk_funding_implied_apr_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S struct FundingImpliedApr *h = (struct FundingImpliedApr *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_funding_implied_apr_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_funding_implied_apr_warmup_period(SEXP e) { + struct FundingImpliedApr *h = (struct FundingImpliedApr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_funding_implied_apr_warmup_period(h)); +} +SEXP wk_funding_implied_apr_is_ready(SEXP e) { + struct FundingImpliedApr *h = (struct FundingImpliedApr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_funding_implied_apr_is_ready(h)); +} SEXP wk_funding_implied_apr_reset(SEXP e) { struct FundingImpliedApr *h = (struct FundingImpliedApr *)R_ExternalPtrAddr(e); wickra_funding_implied_apr_reset(h); @@ -4944,6 +6160,14 @@ SEXP wk_funding_rate_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, struct FundingRate *h = (struct FundingRate *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_funding_rate_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_funding_rate_warmup_period(SEXP e) { + struct FundingRate *h = (struct FundingRate *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_funding_rate_warmup_period(h)); +} +SEXP wk_funding_rate_is_ready(SEXP e) { + struct FundingRate *h = (struct FundingRate *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_funding_rate_is_ready(h)); +} SEXP wk_funding_rate_reset(SEXP e) { struct FundingRate *h = (struct FundingRate *)R_ExternalPtrAddr(e); wickra_funding_rate_reset(h); @@ -4967,6 +6191,14 @@ SEXP wk_funding_rate_mean_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX struct FundingRateMean *h = (struct FundingRateMean *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_funding_rate_mean_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_funding_rate_mean_warmup_period(SEXP e) { + struct FundingRateMean *h = (struct FundingRateMean *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_funding_rate_mean_warmup_period(h)); +} +SEXP wk_funding_rate_mean_is_ready(SEXP e) { + struct FundingRateMean *h = (struct FundingRateMean *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_funding_rate_mean_is_ready(h)); +} SEXP wk_funding_rate_mean_reset(SEXP e) { struct FundingRateMean *h = (struct FundingRateMean *)R_ExternalPtrAddr(e); wickra_funding_rate_mean_reset(h); @@ -4990,6 +6222,14 @@ SEXP wk_funding_rate_z_score_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct FundingRateZScore *h = (struct FundingRateZScore *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_funding_rate_z_score_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_funding_rate_z_score_warmup_period(SEXP e) { + struct FundingRateZScore *h = (struct FundingRateZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_funding_rate_z_score_warmup_period(h)); +} +SEXP wk_funding_rate_z_score_is_ready(SEXP e) { + struct FundingRateZScore *h = (struct FundingRateZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_funding_rate_z_score_is_ready(h)); +} SEXP wk_funding_rate_z_score_reset(SEXP e) { struct FundingRateZScore *h = (struct FundingRateZScore *)R_ExternalPtrAddr(e); wickra_funding_rate_z_score_reset(h); @@ -5021,6 +6261,14 @@ SEXP wk_gain_loss_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_gain_loss_ratio_warmup_period(SEXP e) { + struct GainLossRatio *h = (struct GainLossRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_gain_loss_ratio_warmup_period(h)); +} +SEXP wk_gain_loss_ratio_is_ready(SEXP e) { + struct GainLossRatio *h = (struct GainLossRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_gain_loss_ratio_is_ready(h)); +} SEXP wk_gain_loss_ratio_reset(SEXP e) { struct GainLossRatio *h = (struct GainLossRatio *)R_ExternalPtrAddr(e); wickra_gain_loss_ratio_reset(h); @@ -5052,6 +6300,14 @@ SEXP wk_gain_to_pain_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_gain_to_pain_ratio_warmup_period(SEXP e) { + struct GainToPainRatio *h = (struct GainToPainRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_gain_to_pain_ratio_warmup_period(h)); +} +SEXP wk_gain_to_pain_ratio_is_ready(SEXP e) { + struct GainToPainRatio *h = (struct GainToPainRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_gain_to_pain_ratio_is_ready(h)); +} SEXP wk_gain_to_pain_ratio_reset(SEXP e) { struct GainToPainRatio *h = (struct GainToPainRatio *)R_ExternalPtrAddr(e); wickra_gain_to_pain_ratio_reset(h); @@ -5085,6 +6341,14 @@ SEXP wk_gap_side_by_side_white_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_gap_side_by_side_white_warmup_period(SEXP e) { + struct GapSideBySideWhite *h = (struct GapSideBySideWhite *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_gap_side_by_side_white_warmup_period(h)); +} +SEXP wk_gap_side_by_side_white_is_ready(SEXP e) { + struct GapSideBySideWhite *h = (struct GapSideBySideWhite *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_gap_side_by_side_white_is_ready(h)); +} SEXP wk_gap_side_by_side_white_reset(SEXP e) { struct GapSideBySideWhite *h = (struct GapSideBySideWhite *)R_ExternalPtrAddr(e); wickra_gap_side_by_side_white_reset(h); @@ -5116,6 +6380,14 @@ SEXP wk_garch11_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_garch11_warmup_period(SEXP e) { + struct Garch11 *h = (struct Garch11 *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_garch11_warmup_period(h)); +} +SEXP wk_garch11_is_ready(SEXP e) { + struct Garch11 *h = (struct Garch11 *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_garch11_is_ready(h)); +} SEXP wk_garch11_reset(SEXP e) { struct Garch11 *h = (struct Garch11 *)R_ExternalPtrAddr(e); wickra_garch11_reset(h); @@ -5149,6 +6421,14 @@ SEXP wk_garman_klass_volatility_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 UNPROTECT(1); return out; } +SEXP wk_garman_klass_volatility_warmup_period(SEXP e) { + struct GarmanKlassVolatility *h = (struct GarmanKlassVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_garman_klass_volatility_warmup_period(h)); +} +SEXP wk_garman_klass_volatility_is_ready(SEXP e) { + struct GarmanKlassVolatility *h = (struct GarmanKlassVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_garman_klass_volatility_is_ready(h)); +} SEXP wk_garman_klass_volatility_reset(SEXP e) { struct GarmanKlassVolatility *h = (struct GarmanKlassVolatility *)R_ExternalPtrAddr(e); wickra_garman_klass_volatility_reset(h); @@ -5182,6 +6462,14 @@ SEXP wk_gartley_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_gartley_warmup_period(SEXP e) { + struct Gartley *h = (struct Gartley *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_gartley_warmup_period(h)); +} +SEXP wk_gartley_is_ready(SEXP e) { + struct Gartley *h = (struct Gartley *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_gartley_is_ready(h)); +} SEXP wk_gartley_reset(SEXP e) { struct Gartley *h = (struct Gartley *)R_ExternalPtrAddr(e); wickra_gartley_reset(h); @@ -5215,6 +6503,14 @@ SEXP wk_gator_oscillator_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_gator_oscillator_warmup_period(SEXP e) { + struct GatorOscillator *h = (struct GatorOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_gator_oscillator_warmup_period(h)); +} +SEXP wk_gator_oscillator_is_ready(SEXP e) { + struct GatorOscillator *h = (struct GatorOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_gator_oscillator_is_ready(h)); +} SEXP wk_gator_oscillator_reset(SEXP e) { struct GatorOscillator *h = (struct GatorOscillator *)R_ExternalPtrAddr(e); wickra_gator_oscillator_reset(h); @@ -5246,6 +6542,14 @@ SEXP wk_generalized_dema_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_generalized_dema_warmup_period(SEXP e) { + struct GeneralizedDema *h = (struct GeneralizedDema *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_generalized_dema_warmup_period(h)); +} +SEXP wk_generalized_dema_is_ready(SEXP e) { + struct GeneralizedDema *h = (struct GeneralizedDema *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_generalized_dema_is_ready(h)); +} SEXP wk_generalized_dema_reset(SEXP e) { struct GeneralizedDema *h = (struct GeneralizedDema *)R_ExternalPtrAddr(e); wickra_generalized_dema_reset(h); @@ -5277,6 +6581,14 @@ SEXP wk_geometric_ma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_geometric_ma_warmup_period(SEXP e) { + struct GeometricMa *h = (struct GeometricMa *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_geometric_ma_warmup_period(h)); +} +SEXP wk_geometric_ma_is_ready(SEXP e) { + struct GeometricMa *h = (struct GeometricMa *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_geometric_ma_is_ready(h)); +} SEXP wk_geometric_ma_reset(SEXP e) { struct GeometricMa *h = (struct GeometricMa *)R_ExternalPtrAddr(e); wickra_geometric_ma_reset(h); @@ -5312,6 +6624,14 @@ SEXP wk_golden_pocket_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_golden_pocket_warmup_period(SEXP e) { + struct GoldenPocket *h = (struct GoldenPocket *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_golden_pocket_warmup_period(h)); +} +SEXP wk_golden_pocket_is_ready(SEXP e) { + struct GoldenPocket *h = (struct GoldenPocket *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_golden_pocket_is_ready(h)); +} SEXP wk_golden_pocket_reset(SEXP e) { struct GoldenPocket *h = (struct GoldenPocket *)R_ExternalPtrAddr(e); wickra_golden_pocket_reset(h); @@ -5343,6 +6663,14 @@ SEXP wk_granger_causality_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_granger_causality_warmup_period(SEXP e) { + struct GrangerCausality *h = (struct GrangerCausality *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_granger_causality_warmup_period(h)); +} +SEXP wk_granger_causality_is_ready(SEXP e) { + struct GrangerCausality *h = (struct GrangerCausality *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_granger_causality_is_ready(h)); +} SEXP wk_granger_causality_reset(SEXP e) { struct GrangerCausality *h = (struct GrangerCausality *)R_ExternalPtrAddr(e); wickra_granger_causality_reset(h); @@ -5376,6 +6704,14 @@ SEXP wk_gravestone_doji_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_gravestone_doji_warmup_period(SEXP e) { + struct GravestoneDoji *h = (struct GravestoneDoji *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_gravestone_doji_warmup_period(h)); +} +SEXP wk_gravestone_doji_is_ready(SEXP e) { + struct GravestoneDoji *h = (struct GravestoneDoji *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_gravestone_doji_is_ready(h)); +} SEXP wk_gravestone_doji_reset(SEXP e) { struct GravestoneDoji *h = (struct GravestoneDoji *)R_ExternalPtrAddr(e); wickra_gravestone_doji_reset(h); @@ -5409,6 +6745,14 @@ SEXP wk_hammer_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(1); return out; } +SEXP wk_hammer_warmup_period(SEXP e) { + struct Hammer *h = (struct Hammer *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hammer_warmup_period(h)); +} +SEXP wk_hammer_is_ready(SEXP e) { + struct Hammer *h = (struct Hammer *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hammer_is_ready(h)); +} SEXP wk_hammer_reset(SEXP e) { struct Hammer *h = (struct Hammer *)R_ExternalPtrAddr(e); wickra_hammer_reset(h); @@ -5442,6 +6786,14 @@ SEXP wk_hanging_man_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(1); return out; } +SEXP wk_hanging_man_warmup_period(SEXP e) { + struct HangingMan *h = (struct HangingMan *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hanging_man_warmup_period(h)); +} +SEXP wk_hanging_man_is_ready(SEXP e) { + struct HangingMan *h = (struct HangingMan *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hanging_man_is_ready(h)); +} SEXP wk_hanging_man_reset(SEXP e) { struct HangingMan *h = (struct HangingMan *)R_ExternalPtrAddr(e); wickra_hanging_man_reset(h); @@ -5475,6 +6827,14 @@ SEXP wk_harami_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(1); return out; } +SEXP wk_harami_warmup_period(SEXP e) { + struct Harami *h = (struct Harami *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_harami_warmup_period(h)); +} +SEXP wk_harami_is_ready(SEXP e) { + struct Harami *h = (struct Harami *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_harami_is_ready(h)); +} SEXP wk_harami_reset(SEXP e) { struct Harami *h = (struct Harami *)R_ExternalPtrAddr(e); wickra_harami_reset(h); @@ -5508,6 +6868,14 @@ SEXP wk_harami_cross_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_harami_cross_warmup_period(SEXP e) { + struct HaramiCross *h = (struct HaramiCross *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_harami_cross_warmup_period(h)); +} +SEXP wk_harami_cross_is_ready(SEXP e) { + struct HaramiCross *h = (struct HaramiCross *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_harami_cross_is_ready(h)); +} SEXP wk_harami_cross_reset(SEXP e) { struct HaramiCross *h = (struct HaramiCross *)R_ExternalPtrAddr(e); wickra_harami_cross_reset(h); @@ -5539,6 +6907,14 @@ SEXP wk_hasbrouck_information_share_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_hasbrouck_information_share_warmup_period(SEXP e) { + struct HasbrouckInformationShare *h = (struct HasbrouckInformationShare *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hasbrouck_information_share_warmup_period(h)); +} +SEXP wk_hasbrouck_information_share_is_ready(SEXP e) { + struct HasbrouckInformationShare *h = (struct HasbrouckInformationShare *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hasbrouck_information_share_is_ready(h)); +} SEXP wk_hasbrouck_information_share_reset(SEXP e) { struct HasbrouckInformationShare *h = (struct HasbrouckInformationShare *)R_ExternalPtrAddr(e); wickra_hasbrouck_information_share_reset(h); @@ -5572,6 +6948,14 @@ SEXP wk_head_and_shoulders_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_head_and_shoulders_warmup_period(SEXP e) { + struct HeadAndShoulders *h = (struct HeadAndShoulders *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_head_and_shoulders_warmup_period(h)); +} +SEXP wk_head_and_shoulders_is_ready(SEXP e) { + struct HeadAndShoulders *h = (struct HeadAndShoulders *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_head_and_shoulders_is_ready(h)); +} SEXP wk_head_and_shoulders_reset(SEXP e) { struct HeadAndShoulders *h = (struct HeadAndShoulders *)R_ExternalPtrAddr(e); wickra_head_and_shoulders_reset(h); @@ -5609,6 +6993,14 @@ SEXP wk_heikin_ashi_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(2); return r; } +SEXP wk_heikin_ashi_warmup_period(SEXP e) { + struct HeikinAshi *h = (struct HeikinAshi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_heikin_ashi_warmup_period(h)); +} +SEXP wk_heikin_ashi_is_ready(SEXP e) { + struct HeikinAshi *h = (struct HeikinAshi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_heikin_ashi_is_ready(h)); +} SEXP wk_heikin_ashi_reset(SEXP e) { struct HeikinAshi *h = (struct HeikinAshi *)R_ExternalPtrAddr(e); wickra_heikin_ashi_reset(h); @@ -5642,6 +7034,14 @@ SEXP wk_heikin_ashi_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_heikin_ashi_oscillator_warmup_period(SEXP e) { + struct HeikinAshiOscillator *h = (struct HeikinAshiOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_heikin_ashi_oscillator_warmup_period(h)); +} +SEXP wk_heikin_ashi_oscillator_is_ready(SEXP e) { + struct HeikinAshiOscillator *h = (struct HeikinAshiOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_heikin_ashi_oscillator_is_ready(h)); +} SEXP wk_heikin_ashi_oscillator_reset(SEXP e) { struct HeikinAshiOscillator *h = (struct HeikinAshiOscillator *)R_ExternalPtrAddr(e); wickra_heikin_ashi_oscillator_reset(h); @@ -5675,6 +7075,14 @@ SEXP wk_hi_lo_activator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_hi_lo_activator_warmup_period(SEXP e) { + struct HiLoActivator *h = (struct HiLoActivator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hi_lo_activator_warmup_period(h)); +} +SEXP wk_hi_lo_activator_is_ready(SEXP e) { + struct HiLoActivator *h = (struct HiLoActivator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hi_lo_activator_is_ready(h)); +} SEXP wk_hi_lo_activator_reset(SEXP e) { struct HiLoActivator *h = (struct HiLoActivator *)R_ExternalPtrAddr(e); wickra_hi_lo_activator_reset(h); @@ -5698,6 +7106,14 @@ SEXP wk_high_low_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a struct HighLowIndex *h = (struct HighLowIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_high_low_index_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_high_low_index_warmup_period(SEXP e) { + struct HighLowIndex *h = (struct HighLowIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_high_low_index_warmup_period(h)); +} +SEXP wk_high_low_index_is_ready(SEXP e) { + struct HighLowIndex *h = (struct HighLowIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_high_low_index_is_ready(h)); +} SEXP wk_high_low_index_reset(SEXP e) { struct HighLowIndex *h = (struct HighLowIndex *)R_ExternalPtrAddr(e); wickra_high_low_index_reset(h); @@ -5731,6 +7147,14 @@ SEXP wk_high_low_range_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_high_low_range_warmup_period(SEXP e) { + struct HighLowRange *h = (struct HighLowRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_high_low_range_warmup_period(h)); +} +SEXP wk_high_low_range_is_ready(SEXP e) { + struct HighLowRange *h = (struct HighLowRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_high_low_range_is_ready(h)); +} SEXP wk_high_low_range_reset(SEXP e) { struct HighLowRange *h = (struct HighLowRange *)R_ExternalPtrAddr(e); wickra_high_low_range_reset(h); @@ -5764,6 +7188,14 @@ SEXP wk_high_low_volume_nodes_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(2); return r; } +SEXP wk_high_low_volume_nodes_warmup_period(SEXP e) { + struct HighLowVolumeNodes *h = (struct HighLowVolumeNodes *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_high_low_volume_nodes_warmup_period(h)); +} +SEXP wk_high_low_volume_nodes_is_ready(SEXP e) { + struct HighLowVolumeNodes *h = (struct HighLowVolumeNodes *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_high_low_volume_nodes_is_ready(h)); +} SEXP wk_high_low_volume_nodes_reset(SEXP e) { struct HighLowVolumeNodes *h = (struct HighLowVolumeNodes *)R_ExternalPtrAddr(e); wickra_high_low_volume_nodes_reset(h); @@ -5797,6 +7229,14 @@ SEXP wk_high_wave_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_high_wave_warmup_period(SEXP e) { + struct HighWave *h = (struct HighWave *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_high_wave_warmup_period(h)); +} +SEXP wk_high_wave_is_ready(SEXP e) { + struct HighWave *h = (struct HighWave *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_high_wave_is_ready(h)); +} SEXP wk_high_wave_reset(SEXP e) { struct HighWave *h = (struct HighWave *)R_ExternalPtrAddr(e); wickra_high_wave_reset(h); @@ -5828,6 +7268,14 @@ SEXP wk_highpass_filter_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_highpass_filter_warmup_period(SEXP e) { + struct HighpassFilter *h = (struct HighpassFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_highpass_filter_warmup_period(h)); +} +SEXP wk_highpass_filter_is_ready(SEXP e) { + struct HighpassFilter *h = (struct HighpassFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_highpass_filter_is_ready(h)); +} SEXP wk_highpass_filter_reset(SEXP e) { struct HighpassFilter *h = (struct HighpassFilter *)R_ExternalPtrAddr(e); wickra_highpass_filter_reset(h); @@ -5861,6 +7309,14 @@ SEXP wk_hikkake_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_hikkake_warmup_period(SEXP e) { + struct Hikkake *h = (struct Hikkake *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hikkake_warmup_period(h)); +} +SEXP wk_hikkake_is_ready(SEXP e) { + struct Hikkake *h = (struct Hikkake *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hikkake_is_ready(h)); +} SEXP wk_hikkake_reset(SEXP e) { struct Hikkake *h = (struct Hikkake *)R_ExternalPtrAddr(e); wickra_hikkake_reset(h); @@ -5894,6 +7350,14 @@ SEXP wk_hikkake_modified_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_hikkake_modified_warmup_period(SEXP e) { + struct HikkakeModified *h = (struct HikkakeModified *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hikkake_modified_warmup_period(h)); +} +SEXP wk_hikkake_modified_is_ready(SEXP e) { + struct HikkakeModified *h = (struct HikkakeModified *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hikkake_modified_is_ready(h)); +} SEXP wk_hikkake_modified_reset(SEXP e) { struct HikkakeModified *h = (struct HikkakeModified *)R_ExternalPtrAddr(e); wickra_hikkake_modified_reset(h); @@ -5925,6 +7389,14 @@ SEXP wk_hilbert_dominant_cycle_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_hilbert_dominant_cycle_warmup_period(SEXP e) { + struct HilbertDominantCycle *h = (struct HilbertDominantCycle *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hilbert_dominant_cycle_warmup_period(h)); +} +SEXP wk_hilbert_dominant_cycle_is_ready(SEXP e) { + struct HilbertDominantCycle *h = (struct HilbertDominantCycle *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hilbert_dominant_cycle_is_ready(h)); +} SEXP wk_hilbert_dominant_cycle_reset(SEXP e) { struct HilbertDominantCycle *h = (struct HilbertDominantCycle *)R_ExternalPtrAddr(e); wickra_hilbert_dominant_cycle_reset(h); @@ -5956,6 +7428,14 @@ SEXP wk_historical_volatility_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_historical_volatility_warmup_period(SEXP e) { + struct HistoricalVolatility *h = (struct HistoricalVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_historical_volatility_warmup_period(h)); +} +SEXP wk_historical_volatility_is_ready(SEXP e) { + struct HistoricalVolatility *h = (struct HistoricalVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_historical_volatility_is_ready(h)); +} SEXP wk_historical_volatility_reset(SEXP e) { struct HistoricalVolatility *h = (struct HistoricalVolatility *)R_ExternalPtrAddr(e); wickra_historical_volatility_reset(h); @@ -5987,6 +7467,14 @@ SEXP wk_hma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_hma_warmup_period(SEXP e) { + struct Hma *h = (struct Hma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hma_warmup_period(h)); +} +SEXP wk_hma_is_ready(SEXP e) { + struct Hma *h = (struct Hma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hma_is_ready(h)); +} SEXP wk_hma_reset(SEXP e) { struct Hma *h = (struct Hma *)R_ExternalPtrAddr(e); wickra_hma_reset(h); @@ -6018,6 +7506,14 @@ SEXP wk_holt_winters_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_holt_winters_warmup_period(SEXP e) { + struct HoltWinters *h = (struct HoltWinters *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_holt_winters_warmup_period(h)); +} +SEXP wk_holt_winters_is_ready(SEXP e) { + struct HoltWinters *h = (struct HoltWinters *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_holt_winters_is_ready(h)); +} SEXP wk_holt_winters_reset(SEXP e) { struct HoltWinters *h = (struct HoltWinters *)R_ExternalPtrAddr(e); wickra_holt_winters_reset(h); @@ -6051,6 +7547,14 @@ SEXP wk_homing_pigeon_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_homing_pigeon_warmup_period(SEXP e) { + struct HomingPigeon *h = (struct HomingPigeon *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_homing_pigeon_warmup_period(h)); +} +SEXP wk_homing_pigeon_is_ready(SEXP e) { + struct HomingPigeon *h = (struct HomingPigeon *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_homing_pigeon_is_ready(h)); +} SEXP wk_homing_pigeon_reset(SEXP e) { struct HomingPigeon *h = (struct HomingPigeon *)R_ExternalPtrAddr(e); wickra_homing_pigeon_reset(h); @@ -6082,6 +7586,14 @@ SEXP wk_ht_dc_phase_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ht_dc_phase_warmup_period(SEXP e) { + struct HtDcPhase *h = (struct HtDcPhase *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ht_dc_phase_warmup_period(h)); +} +SEXP wk_ht_dc_phase_is_ready(SEXP e) { + struct HtDcPhase *h = (struct HtDcPhase *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ht_dc_phase_is_ready(h)); +} SEXP wk_ht_dc_phase_reset(SEXP e) { struct HtDcPhase *h = (struct HtDcPhase *)R_ExternalPtrAddr(e); wickra_ht_dc_phase_reset(h); @@ -6115,6 +7627,14 @@ SEXP wk_ht_phasor_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_ht_phasor_warmup_period(SEXP e) { + struct HtPhasor *h = (struct HtPhasor *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ht_phasor_warmup_period(h)); +} +SEXP wk_ht_phasor_is_ready(SEXP e) { + struct HtPhasor *h = (struct HtPhasor *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ht_phasor_is_ready(h)); +} SEXP wk_ht_phasor_reset(SEXP e) { struct HtPhasor *h = (struct HtPhasor *)R_ExternalPtrAddr(e); wickra_ht_phasor_reset(h); @@ -6146,6 +7666,14 @@ SEXP wk_ht_trend_mode_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ht_trend_mode_warmup_period(SEXP e) { + struct HtTrendMode *h = (struct HtTrendMode *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ht_trend_mode_warmup_period(h)); +} +SEXP wk_ht_trend_mode_is_ready(SEXP e) { + struct HtTrendMode *h = (struct HtTrendMode *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ht_trend_mode_is_ready(h)); +} SEXP wk_ht_trend_mode_reset(SEXP e) { struct HtTrendMode *h = (struct HtTrendMode *)R_ExternalPtrAddr(e); wickra_ht_trend_mode_reset(h); @@ -6181,6 +7709,14 @@ SEXP wk_hurst_channel_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_hurst_channel_warmup_period(SEXP e) { + struct HurstChannel *h = (struct HurstChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hurst_channel_warmup_period(h)); +} +SEXP wk_hurst_channel_is_ready(SEXP e) { + struct HurstChannel *h = (struct HurstChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hurst_channel_is_ready(h)); +} SEXP wk_hurst_channel_reset(SEXP e) { struct HurstChannel *h = (struct HurstChannel *)R_ExternalPtrAddr(e); wickra_hurst_channel_reset(h); @@ -6212,6 +7748,14 @@ SEXP wk_hurst_exponent_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_hurst_exponent_warmup_period(SEXP e) { + struct HurstExponent *h = (struct HurstExponent *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_hurst_exponent_warmup_period(h)); +} +SEXP wk_hurst_exponent_is_ready(SEXP e) { + struct HurstExponent *h = (struct HurstExponent *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_hurst_exponent_is_ready(h)); +} SEXP wk_hurst_exponent_reset(SEXP e) { struct HurstExponent *h = (struct HurstExponent *)R_ExternalPtrAddr(e); wickra_hurst_exponent_reset(h); @@ -6251,6 +7795,14 @@ SEXP wk_ichimoku_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(2); return r; } +SEXP wk_ichimoku_warmup_period(SEXP e) { + struct Ichimoku *h = (struct Ichimoku *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ichimoku_warmup_period(h)); +} +SEXP wk_ichimoku_is_ready(SEXP e) { + struct Ichimoku *h = (struct Ichimoku *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ichimoku_is_ready(h)); +} SEXP wk_ichimoku_reset(SEXP e) { struct Ichimoku *h = (struct Ichimoku *)R_ExternalPtrAddr(e); wickra_ichimoku_reset(h); @@ -6284,6 +7836,14 @@ SEXP wk_identical_three_crows_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_identical_three_crows_warmup_period(SEXP e) { + struct IdenticalThreeCrows *h = (struct IdenticalThreeCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_identical_three_crows_warmup_period(h)); +} +SEXP wk_identical_three_crows_is_ready(SEXP e) { + struct IdenticalThreeCrows *h = (struct IdenticalThreeCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_identical_three_crows_is_ready(h)); +} SEXP wk_identical_three_crows_reset(SEXP e) { struct IdenticalThreeCrows *h = (struct IdenticalThreeCrows *)R_ExternalPtrAddr(e); wickra_identical_three_crows_reset(h); @@ -6362,6 +7922,14 @@ SEXP wk_in_neck_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_in_neck_warmup_period(SEXP e) { + struct InNeck *h = (struct InNeck *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_in_neck_warmup_period(h)); +} +SEXP wk_in_neck_is_ready(SEXP e) { + struct InNeck *h = (struct InNeck *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_in_neck_is_ready(h)); +} SEXP wk_in_neck_reset(SEXP e) { struct InNeck *h = (struct InNeck *)R_ExternalPtrAddr(e); wickra_in_neck_reset(h); @@ -6395,6 +7963,14 @@ SEXP wk_inertia_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_inertia_warmup_period(SEXP e) { + struct Inertia *h = (struct Inertia *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_inertia_warmup_period(h)); +} +SEXP wk_inertia_is_ready(SEXP e) { + struct Inertia *h = (struct Inertia *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_inertia_is_ready(h)); +} SEXP wk_inertia_reset(SEXP e) { struct Inertia *h = (struct Inertia *)R_ExternalPtrAddr(e); wickra_inertia_reset(h); @@ -6426,6 +8002,14 @@ SEXP wk_information_ratio_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_information_ratio_warmup_period(SEXP e) { + struct InformationRatio *h = (struct InformationRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_information_ratio_warmup_period(h)); +} +SEXP wk_information_ratio_is_ready(SEXP e) { + struct InformationRatio *h = (struct InformationRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_information_ratio_is_ready(h)); +} SEXP wk_information_ratio_reset(SEXP e) { struct InformationRatio *h = (struct InformationRatio *)R_ExternalPtrAddr(e); wickra_information_ratio_reset(h); @@ -6459,6 +8043,14 @@ SEXP wk_initial_balance_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_initial_balance_warmup_period(SEXP e) { + struct InitialBalance *h = (struct InitialBalance *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_initial_balance_warmup_period(h)); +} +SEXP wk_initial_balance_is_ready(SEXP e) { + struct InitialBalance *h = (struct InitialBalance *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_initial_balance_is_ready(h)); +} SEXP wk_initial_balance_reset(SEXP e) { struct InitialBalance *h = (struct InitialBalance *)R_ExternalPtrAddr(e); wickra_initial_balance_reset(h); @@ -6490,6 +8082,14 @@ SEXP wk_instantaneous_trendline_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_instantaneous_trendline_warmup_period(SEXP e) { + struct InstantaneousTrendline *h = (struct InstantaneousTrendline *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_instantaneous_trendline_warmup_period(h)); +} +SEXP wk_instantaneous_trendline_is_ready(SEXP e) { + struct InstantaneousTrendline *h = (struct InstantaneousTrendline *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_instantaneous_trendline_is_ready(h)); +} SEXP wk_instantaneous_trendline_reset(SEXP e) { struct InstantaneousTrendline *h = (struct InstantaneousTrendline *)R_ExternalPtrAddr(e); wickra_instantaneous_trendline_reset(h); @@ -6523,6 +8123,14 @@ SEXP wk_intraday_intensity_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_intraday_intensity_warmup_period(SEXP e) { + struct IntradayIntensity *h = (struct IntradayIntensity *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_intraday_intensity_warmup_period(h)); +} +SEXP wk_intraday_intensity_is_ready(SEXP e) { + struct IntradayIntensity *h = (struct IntradayIntensity *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_intraday_intensity_is_ready(h)); +} SEXP wk_intraday_intensity_reset(SEXP e) { struct IntradayIntensity *h = (struct IntradayIntensity *)R_ExternalPtrAddr(e); wickra_intraday_intensity_reset(h); @@ -6556,6 +8164,14 @@ SEXP wk_intraday_momentum_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 UNPROTECT(1); return out; } +SEXP wk_intraday_momentum_index_warmup_period(SEXP e) { + struct IntradayMomentumIndex *h = (struct IntradayMomentumIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_intraday_momentum_index_warmup_period(h)); +} +SEXP wk_intraday_momentum_index_is_ready(SEXP e) { + struct IntradayMomentumIndex *h = (struct IntradayMomentumIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_intraday_momentum_index_is_ready(h)); +} SEXP wk_intraday_momentum_index_reset(SEXP e) { struct IntradayMomentumIndex *h = (struct IntradayMomentumIndex *)R_ExternalPtrAddr(e); wickra_intraday_momentum_index_reset(h); @@ -6586,6 +8202,14 @@ SEXP wk_intraday_volatility_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SE UNPROTECT(2); return vv; } +SEXP wk_intraday_volatility_profile_warmup_period(SEXP e) { + struct IntradayVolatilityProfile *h = (struct IntradayVolatilityProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_intraday_volatility_profile_warmup_period(h)); +} +SEXP wk_intraday_volatility_profile_is_ready(SEXP e) { + struct IntradayVolatilityProfile *h = (struct IntradayVolatilityProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_intraday_volatility_profile_is_ready(h)); +} SEXP wk_intraday_volatility_profile_reset(SEXP e) { struct IntradayVolatilityProfile *h = (struct IntradayVolatilityProfile *)R_ExternalPtrAddr(e); wickra_intraday_volatility_profile_reset(h); @@ -6617,6 +8241,14 @@ SEXP wk_inverse_fisher_transform_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_inverse_fisher_transform_warmup_period(SEXP e) { + struct InverseFisherTransform *h = (struct InverseFisherTransform *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_inverse_fisher_transform_warmup_period(h)); +} +SEXP wk_inverse_fisher_transform_is_ready(SEXP e) { + struct InverseFisherTransform *h = (struct InverseFisherTransform *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_inverse_fisher_transform_is_ready(h)); +} SEXP wk_inverse_fisher_transform_reset(SEXP e) { struct InverseFisherTransform *h = (struct InverseFisherTransform *)R_ExternalPtrAddr(e); wickra_inverse_fisher_transform_reset(h); @@ -6650,6 +8282,14 @@ SEXP wk_inverted_hammer_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_inverted_hammer_warmup_period(SEXP e) { + struct InvertedHammer *h = (struct InvertedHammer *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_inverted_hammer_warmup_period(h)); +} +SEXP wk_inverted_hammer_is_ready(SEXP e) { + struct InvertedHammer *h = (struct InvertedHammer *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_inverted_hammer_is_ready(h)); +} SEXP wk_inverted_hammer_reset(SEXP e) { struct InvertedHammer *h = (struct InvertedHammer *)R_ExternalPtrAddr(e); wickra_inverted_hammer_reset(h); @@ -6681,6 +8321,14 @@ SEXP wk_jarque_bera_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_jarque_bera_warmup_period(SEXP e) { + struct JarqueBera *h = (struct JarqueBera *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_jarque_bera_warmup_period(h)); +} +SEXP wk_jarque_bera_is_ready(SEXP e) { + struct JarqueBera *h = (struct JarqueBera *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_jarque_bera_is_ready(h)); +} SEXP wk_jarque_bera_reset(SEXP e) { struct JarqueBera *h = (struct JarqueBera *)R_ExternalPtrAddr(e); wickra_jarque_bera_reset(h); @@ -6712,6 +8360,14 @@ SEXP wk_jma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_jma_warmup_period(SEXP e) { + struct Jma *h = (struct Jma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_jma_warmup_period(h)); +} +SEXP wk_jma_is_ready(SEXP e) { + struct Jma *h = (struct Jma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_jma_is_ready(h)); +} SEXP wk_jma_reset(SEXP e) { struct Jma *h = (struct Jma *)R_ExternalPtrAddr(e); wickra_jma_reset(h); @@ -6743,6 +8399,14 @@ SEXP wk_jump_indicator_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_jump_indicator_warmup_period(SEXP e) { + struct JumpIndicator *h = (struct JumpIndicator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_jump_indicator_warmup_period(h)); +} +SEXP wk_jump_indicator_is_ready(SEXP e) { + struct JumpIndicator *h = (struct JumpIndicator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_jump_indicator_is_ready(h)); +} SEXP wk_jump_indicator_reset(SEXP e) { struct JumpIndicator *h = (struct JumpIndicator *)R_ExternalPtrAddr(e); wickra_jump_indicator_reset(h); @@ -6774,6 +8438,14 @@ SEXP wk_k_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_k_ratio_warmup_period(SEXP e) { + struct KRatio *h = (struct KRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_k_ratio_warmup_period(h)); +} +SEXP wk_k_ratio_is_ready(SEXP e) { + struct KRatio *h = (struct KRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_k_ratio_is_ready(h)); +} SEXP wk_k_ratio_reset(SEXP e) { struct KRatio *h = (struct KRatio *)R_ExternalPtrAddr(e); wickra_k_ratio_reset(h); @@ -6848,6 +8520,14 @@ SEXP wk_kalman_hedge_ratio_update(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(2); return r; } +SEXP wk_kalman_hedge_ratio_warmup_period(SEXP e) { + struct KalmanHedgeRatio *h = (struct KalmanHedgeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kalman_hedge_ratio_warmup_period(h)); +} +SEXP wk_kalman_hedge_ratio_is_ready(SEXP e) { + struct KalmanHedgeRatio *h = (struct KalmanHedgeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kalman_hedge_ratio_is_ready(h)); +} SEXP wk_kalman_hedge_ratio_reset(SEXP e) { struct KalmanHedgeRatio *h = (struct KalmanHedgeRatio *)R_ExternalPtrAddr(e); wickra_kalman_hedge_ratio_reset(h); @@ -6879,6 +8559,14 @@ SEXP wk_kama_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_kama_warmup_period(SEXP e) { + struct Kama *h = (struct Kama *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kama_warmup_period(h)); +} +SEXP wk_kama_is_ready(SEXP e) { + struct Kama *h = (struct Kama *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kama_is_ready(h)); +} SEXP wk_kama_reset(SEXP e) { struct Kama *h = (struct Kama *)R_ExternalPtrAddr(e); wickra_kama_reset(h); @@ -6912,6 +8600,14 @@ SEXP wk_kase_dev_stop_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_kase_dev_stop_warmup_period(SEXP e) { + struct KaseDevStop *h = (struct KaseDevStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kase_dev_stop_warmup_period(h)); +} +SEXP wk_kase_dev_stop_is_ready(SEXP e) { + struct KaseDevStop *h = (struct KaseDevStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kase_dev_stop_is_ready(h)); +} SEXP wk_kase_dev_stop_reset(SEXP e) { struct KaseDevStop *h = (struct KaseDevStop *)R_ExternalPtrAddr(e); wickra_kase_dev_stop_reset(h); @@ -6945,6 +8641,14 @@ SEXP wk_kase_permission_stochastic_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEX UNPROTECT(2); return r; } +SEXP wk_kase_permission_stochastic_warmup_period(SEXP e) { + struct KasePermissionStochastic *h = (struct KasePermissionStochastic *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kase_permission_stochastic_warmup_period(h)); +} +SEXP wk_kase_permission_stochastic_is_ready(SEXP e) { + struct KasePermissionStochastic *h = (struct KasePermissionStochastic *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kase_permission_stochastic_is_ready(h)); +} SEXP wk_kase_permission_stochastic_reset(SEXP e) { struct KasePermissionStochastic *h = (struct KasePermissionStochastic *)R_ExternalPtrAddr(e); wickra_kase_permission_stochastic_reset(h); @@ -6976,6 +8680,14 @@ SEXP wk_kelly_criterion_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_kelly_criterion_warmup_period(SEXP e) { + struct KellyCriterion *h = (struct KellyCriterion *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kelly_criterion_warmup_period(h)); +} +SEXP wk_kelly_criterion_is_ready(SEXP e) { + struct KellyCriterion *h = (struct KellyCriterion *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kelly_criterion_is_ready(h)); +} SEXP wk_kelly_criterion_reset(SEXP e) { struct KellyCriterion *h = (struct KellyCriterion *)R_ExternalPtrAddr(e); wickra_kelly_criterion_reset(h); @@ -7011,6 +8723,14 @@ SEXP wk_keltner_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(2); return r; } +SEXP wk_keltner_warmup_period(SEXP e) { + struct Keltner *h = (struct Keltner *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_keltner_warmup_period(h)); +} +SEXP wk_keltner_is_ready(SEXP e) { + struct Keltner *h = (struct Keltner *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_keltner_is_ready(h)); +} SEXP wk_keltner_reset(SEXP e) { struct Keltner *h = (struct Keltner *)R_ExternalPtrAddr(e); wickra_keltner_reset(h); @@ -7042,6 +8762,14 @@ SEXP wk_kendall_tau_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_kendall_tau_warmup_period(SEXP e) { + struct KendallTau *h = (struct KendallTau *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kendall_tau_warmup_period(h)); +} +SEXP wk_kendall_tau_is_ready(SEXP e) { + struct KendallTau *h = (struct KendallTau *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kendall_tau_is_ready(h)); +} SEXP wk_kendall_tau_reset(SEXP e) { struct KendallTau *h = (struct KendallTau *)R_ExternalPtrAddr(e); wickra_kendall_tau_reset(h); @@ -7075,6 +8803,14 @@ SEXP wk_kicking_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_kicking_warmup_period(SEXP e) { + struct Kicking *h = (struct Kicking *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kicking_warmup_period(h)); +} +SEXP wk_kicking_is_ready(SEXP e) { + struct Kicking *h = (struct Kicking *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kicking_is_ready(h)); +} SEXP wk_kicking_reset(SEXP e) { struct Kicking *h = (struct Kicking *)R_ExternalPtrAddr(e); wickra_kicking_reset(h); @@ -7108,6 +8844,14 @@ SEXP wk_kicking_by_length_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_kicking_by_length_warmup_period(SEXP e) { + struct KickingByLength *h = (struct KickingByLength *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kicking_by_length_warmup_period(h)); +} +SEXP wk_kicking_by_length_is_ready(SEXP e) { + struct KickingByLength *h = (struct KickingByLength *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kicking_by_length_is_ready(h)); +} SEXP wk_kicking_by_length_reset(SEXP e) { struct KickingByLength *h = (struct KickingByLength *)R_ExternalPtrAddr(e); wickra_kicking_by_length_reset(h); @@ -7141,6 +8885,14 @@ SEXP wk_kst_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_kst_warmup_period(SEXP e) { + struct Kst *h = (struct Kst *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kst_warmup_period(h)); +} +SEXP wk_kst_is_ready(SEXP e) { + struct Kst *h = (struct Kst *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kst_is_ready(h)); +} SEXP wk_kst_reset(SEXP e) { struct Kst *h = (struct Kst *)R_ExternalPtrAddr(e); wickra_kst_reset(h); @@ -7172,6 +8924,14 @@ SEXP wk_kurtosis_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_kurtosis_warmup_period(SEXP e) { + struct Kurtosis *h = (struct Kurtosis *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kurtosis_warmup_period(h)); +} +SEXP wk_kurtosis_is_ready(SEXP e) { + struct Kurtosis *h = (struct Kurtosis *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kurtosis_is_ready(h)); +} SEXP wk_kurtosis_reset(SEXP e) { struct Kurtosis *h = (struct Kurtosis *)R_ExternalPtrAddr(e); wickra_kurtosis_reset(h); @@ -7205,6 +8965,14 @@ SEXP wk_kvo_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_kvo_warmup_period(SEXP e) { + struct Kvo *h = (struct Kvo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kvo_warmup_period(h)); +} +SEXP wk_kvo_is_ready(SEXP e) { + struct Kvo *h = (struct Kvo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kvo_is_ready(h)); +} SEXP wk_kvo_reset(SEXP e) { struct Kvo *h = (struct Kvo *)R_ExternalPtrAddr(e); wickra_kvo_reset(h); @@ -7228,6 +8996,14 @@ SEXP wk_kyles_lambda_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4) struct KylesLambda *h = (struct KylesLambda *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_kyles_lambda_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3), Rf_asReal(a4))); } +SEXP wk_kyles_lambda_warmup_period(SEXP e) { + struct KylesLambda *h = (struct KylesLambda *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_kyles_lambda_warmup_period(h)); +} +SEXP wk_kyles_lambda_is_ready(SEXP e) { + struct KylesLambda *h = (struct KylesLambda *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_kyles_lambda_is_ready(h)); +} SEXP wk_kyles_lambda_reset(SEXP e) { struct KylesLambda *h = (struct KylesLambda *)R_ExternalPtrAddr(e); wickra_kyles_lambda_reset(h); @@ -7261,6 +9037,14 @@ SEXP wk_ladder_bottom_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_ladder_bottom_warmup_period(SEXP e) { + struct LadderBottom *h = (struct LadderBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ladder_bottom_warmup_period(h)); +} +SEXP wk_ladder_bottom_is_ready(SEXP e) { + struct LadderBottom *h = (struct LadderBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ladder_bottom_is_ready(h)); +} SEXP wk_ladder_bottom_reset(SEXP e) { struct LadderBottom *h = (struct LadderBottom *)R_ExternalPtrAddr(e); wickra_ladder_bottom_reset(h); @@ -7292,6 +9076,14 @@ SEXP wk_laguerre_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_laguerre_rsi_warmup_period(SEXP e) { + struct LaguerreRsi *h = (struct LaguerreRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_laguerre_rsi_warmup_period(h)); +} +SEXP wk_laguerre_rsi_is_ready(SEXP e) { + struct LaguerreRsi *h = (struct LaguerreRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_laguerre_rsi_is_ready(h)); +} SEXP wk_laguerre_rsi_reset(SEXP e) { struct LaguerreRsi *h = (struct LaguerreRsi *)R_ExternalPtrAddr(e); wickra_laguerre_rsi_reset(h); @@ -7325,6 +9117,14 @@ SEXP wk_lead_lag_cross_correlation_update(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(2); return r; } +SEXP wk_lead_lag_cross_correlation_warmup_period(SEXP e) { + struct LeadLagCrossCorrelation *h = (struct LeadLagCrossCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_lead_lag_cross_correlation_warmup_period(h)); +} +SEXP wk_lead_lag_cross_correlation_is_ready(SEXP e) { + struct LeadLagCrossCorrelation *h = (struct LeadLagCrossCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_lead_lag_cross_correlation_is_ready(h)); +} SEXP wk_lead_lag_cross_correlation_reset(SEXP e) { struct LeadLagCrossCorrelation *h = (struct LeadLagCrossCorrelation *)R_ExternalPtrAddr(e); wickra_lead_lag_cross_correlation_reset(h); @@ -7356,6 +9156,14 @@ SEXP wk_lin_reg_angle_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_lin_reg_angle_warmup_period(SEXP e) { + struct LinRegAngle *h = (struct LinRegAngle *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_lin_reg_angle_warmup_period(h)); +} +SEXP wk_lin_reg_angle_is_ready(SEXP e) { + struct LinRegAngle *h = (struct LinRegAngle *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_lin_reg_angle_is_ready(h)); +} SEXP wk_lin_reg_angle_reset(SEXP e) { struct LinRegAngle *h = (struct LinRegAngle *)R_ExternalPtrAddr(e); wickra_lin_reg_angle_reset(h); @@ -7391,6 +9199,14 @@ SEXP wk_lin_reg_channel_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_lin_reg_channel_warmup_period(SEXP e) { + struct LinRegChannel *h = (struct LinRegChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_lin_reg_channel_warmup_period(h)); +} +SEXP wk_lin_reg_channel_is_ready(SEXP e) { + struct LinRegChannel *h = (struct LinRegChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_lin_reg_channel_is_ready(h)); +} SEXP wk_lin_reg_channel_reset(SEXP e) { struct LinRegChannel *h = (struct LinRegChannel *)R_ExternalPtrAddr(e); wickra_lin_reg_channel_reset(h); @@ -7422,6 +9238,14 @@ SEXP wk_lin_reg_intercept_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_lin_reg_intercept_warmup_period(SEXP e) { + struct LinRegIntercept *h = (struct LinRegIntercept *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_lin_reg_intercept_warmup_period(h)); +} +SEXP wk_lin_reg_intercept_is_ready(SEXP e) { + struct LinRegIntercept *h = (struct LinRegIntercept *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_lin_reg_intercept_is_ready(h)); +} SEXP wk_lin_reg_intercept_reset(SEXP e) { struct LinRegIntercept *h = (struct LinRegIntercept *)R_ExternalPtrAddr(e); wickra_lin_reg_intercept_reset(h); @@ -7453,6 +9277,14 @@ SEXP wk_lin_reg_slope_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_lin_reg_slope_warmup_period(SEXP e) { + struct LinRegSlope *h = (struct LinRegSlope *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_lin_reg_slope_warmup_period(h)); +} +SEXP wk_lin_reg_slope_is_ready(SEXP e) { + struct LinRegSlope *h = (struct LinRegSlope *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_lin_reg_slope_is_ready(h)); +} SEXP wk_lin_reg_slope_reset(SEXP e) { struct LinRegSlope *h = (struct LinRegSlope *)R_ExternalPtrAddr(e); wickra_lin_reg_slope_reset(h); @@ -7484,6 +9316,14 @@ SEXP wk_linear_regression_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_linear_regression_warmup_period(SEXP e) { + struct LinearRegression *h = (struct LinearRegression *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_linear_regression_warmup_period(h)); +} +SEXP wk_linear_regression_is_ready(SEXP e) { + struct LinearRegression *h = (struct LinearRegression *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_linear_regression_is_ready(h)); +} SEXP wk_linear_regression_reset(SEXP e) { struct LinearRegression *h = (struct LinearRegression *)R_ExternalPtrAddr(e); wickra_linear_regression_reset(h); @@ -7523,6 +9363,14 @@ SEXP wk_liquidation_features_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(2); return r; } +SEXP wk_liquidation_features_warmup_period(SEXP e) { + struct LiquidationFeatures *h = (struct LiquidationFeatures *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_liquidation_features_warmup_period(h)); +} +SEXP wk_liquidation_features_is_ready(SEXP e) { + struct LiquidationFeatures *h = (struct LiquidationFeatures *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_liquidation_features_is_ready(h)); +} SEXP wk_liquidation_features_reset(SEXP e) { struct LiquidationFeatures *h = (struct LiquidationFeatures *)R_ExternalPtrAddr(e); wickra_liquidation_features_reset(h); @@ -7554,6 +9402,14 @@ SEXP wk_log_return_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_log_return_warmup_period(SEXP e) { + struct LogReturn *h = (struct LogReturn *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_log_return_warmup_period(h)); +} +SEXP wk_log_return_is_ready(SEXP e) { + struct LogReturn *h = (struct LogReturn *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_log_return_is_ready(h)); +} SEXP wk_log_return_reset(SEXP e) { struct LogReturn *h = (struct LogReturn *)R_ExternalPtrAddr(e); wickra_log_return_reset(h); @@ -7587,6 +9443,14 @@ SEXP wk_long_legged_doji_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_long_legged_doji_warmup_period(SEXP e) { + struct LongLeggedDoji *h = (struct LongLeggedDoji *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_long_legged_doji_warmup_period(h)); +} +SEXP wk_long_legged_doji_is_ready(SEXP e) { + struct LongLeggedDoji *h = (struct LongLeggedDoji *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_long_legged_doji_is_ready(h)); +} SEXP wk_long_legged_doji_reset(SEXP e) { struct LongLeggedDoji *h = (struct LongLeggedDoji *)R_ExternalPtrAddr(e); wickra_long_legged_doji_reset(h); @@ -7620,6 +9484,14 @@ SEXP wk_long_line_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_long_line_warmup_period(SEXP e) { + struct LongLine *h = (struct LongLine *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_long_line_warmup_period(h)); +} +SEXP wk_long_line_is_ready(SEXP e) { + struct LongLine *h = (struct LongLine *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_long_line_is_ready(h)); +} SEXP wk_long_line_reset(SEXP e) { struct LongLine *h = (struct LongLine *)R_ExternalPtrAddr(e); wickra_long_line_reset(h); @@ -7643,6 +9515,14 @@ SEXP wk_long_short_ratio_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP struct LongShortRatio *h = (struct LongShortRatio *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_long_short_ratio_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_long_short_ratio_warmup_period(SEXP e) { + struct LongShortRatio *h = (struct LongShortRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_long_short_ratio_warmup_period(h)); +} +SEXP wk_long_short_ratio_is_ready(SEXP e) { + struct LongShortRatio *h = (struct LongShortRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_long_short_ratio_is_ready(h)); +} SEXP wk_long_short_ratio_reset(SEXP e) { struct LongShortRatio *h = (struct LongShortRatio *)R_ExternalPtrAddr(e); wickra_long_short_ratio_reset(h); @@ -7674,6 +9554,14 @@ SEXP wk_m2_measure_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_m2_measure_warmup_period(SEXP e) { + struct M2Measure *h = (struct M2Measure *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_m2_measure_warmup_period(h)); +} +SEXP wk_m2_measure_is_ready(SEXP e) { + struct M2Measure *h = (struct M2Measure *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_m2_measure_is_ready(h)); +} SEXP wk_m2_measure_reset(SEXP e) { struct M2Measure *h = (struct M2Measure *)R_ExternalPtrAddr(e); wickra_m2_measure_reset(h); @@ -7709,6 +9597,14 @@ SEXP wk_ma_envelope_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_ma_envelope_warmup_period(SEXP e) { + struct MaEnvelope *h = (struct MaEnvelope *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ma_envelope_warmup_period(h)); +} +SEXP wk_ma_envelope_is_ready(SEXP e) { + struct MaEnvelope *h = (struct MaEnvelope *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ma_envelope_is_ready(h)); +} SEXP wk_ma_envelope_reset(SEXP e) { struct MaEnvelope *h = (struct MaEnvelope *)R_ExternalPtrAddr(e); wickra_ma_envelope_reset(h); @@ -7744,6 +9640,14 @@ SEXP wk_macd_ext_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_macd_ext_warmup_period(SEXP e) { + struct MacdExt *h = (struct MacdExt *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_macd_ext_warmup_period(h)); +} +SEXP wk_macd_ext_is_ready(SEXP e) { + struct MacdExt *h = (struct MacdExt *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_macd_ext_is_ready(h)); +} SEXP wk_macd_ext_reset(SEXP e) { struct MacdExt *h = (struct MacdExt *)R_ExternalPtrAddr(e); wickra_macd_ext_reset(h); @@ -7779,6 +9683,14 @@ SEXP wk_macd_fix_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_macd_fix_warmup_period(SEXP e) { + struct MacdFix *h = (struct MacdFix *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_macd_fix_warmup_period(h)); +} +SEXP wk_macd_fix_is_ready(SEXP e) { + struct MacdFix *h = (struct MacdFix *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_macd_fix_is_ready(h)); +} SEXP wk_macd_fix_reset(SEXP e) { struct MacdFix *h = (struct MacdFix *)R_ExternalPtrAddr(e); wickra_macd_fix_reset(h); @@ -7810,6 +9722,14 @@ SEXP wk_macd_histogram_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_macd_histogram_warmup_period(SEXP e) { + struct MacdHistogram *h = (struct MacdHistogram *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_macd_histogram_warmup_period(h)); +} +SEXP wk_macd_histogram_is_ready(SEXP e) { + struct MacdHistogram *h = (struct MacdHistogram *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_macd_histogram_is_ready(h)); +} SEXP wk_macd_histogram_reset(SEXP e) { struct MacdHistogram *h = (struct MacdHistogram *)R_ExternalPtrAddr(e); wickra_macd_histogram_reset(h); @@ -7845,6 +9765,14 @@ SEXP wk_macd_indicator_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_macd_indicator_warmup_period(SEXP e) { + struct MacdIndicator *h = (struct MacdIndicator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_macd_indicator_warmup_period(h)); +} +SEXP wk_macd_indicator_is_ready(SEXP e) { + struct MacdIndicator *h = (struct MacdIndicator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_macd_indicator_is_ready(h)); +} SEXP wk_macd_indicator_reset(SEXP e) { struct MacdIndicator *h = (struct MacdIndicator *)R_ExternalPtrAddr(e); wickra_macd_indicator_reset(h); @@ -7878,6 +9806,14 @@ SEXP wk_mama_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_mama_warmup_period(SEXP e) { + struct Mama *h = (struct Mama *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mama_warmup_period(h)); +} +SEXP wk_mama_is_ready(SEXP e) { + struct Mama *h = (struct Mama *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mama_is_ready(h)); +} SEXP wk_mama_reset(SEXP e) { struct Mama *h = (struct Mama *)R_ExternalPtrAddr(e); wickra_mama_reset(h); @@ -7911,6 +9847,14 @@ SEXP wk_market_facilitation_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP UNPROTECT(1); return out; } +SEXP wk_market_facilitation_index_warmup_period(SEXP e) { + struct MarketFacilitationIndex *h = (struct MarketFacilitationIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_market_facilitation_index_warmup_period(h)); +} +SEXP wk_market_facilitation_index_is_ready(SEXP e) { + struct MarketFacilitationIndex *h = (struct MarketFacilitationIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_market_facilitation_index_is_ready(h)); +} SEXP wk_market_facilitation_index_reset(SEXP e) { struct MarketFacilitationIndex *h = (struct MarketFacilitationIndex *)R_ExternalPtrAddr(e); wickra_market_facilitation_index_reset(h); @@ -7942,6 +9886,14 @@ SEXP wk_martin_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_martin_ratio_warmup_period(SEXP e) { + struct MartinRatio *h = (struct MartinRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_martin_ratio_warmup_period(h)); +} +SEXP wk_martin_ratio_is_ready(SEXP e) { + struct MartinRatio *h = (struct MartinRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_martin_ratio_is_ready(h)); +} SEXP wk_martin_ratio_reset(SEXP e) { struct MartinRatio *h = (struct MartinRatio *)R_ExternalPtrAddr(e); wickra_martin_ratio_reset(h); @@ -7975,6 +9927,14 @@ SEXP wk_marubozu_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_marubozu_warmup_period(SEXP e) { + struct Marubozu *h = (struct Marubozu *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_marubozu_warmup_period(h)); +} +SEXP wk_marubozu_is_ready(SEXP e) { + struct Marubozu *h = (struct Marubozu *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_marubozu_is_ready(h)); +} SEXP wk_marubozu_reset(SEXP e) { struct Marubozu *h = (struct Marubozu *)R_ExternalPtrAddr(e); wickra_marubozu_reset(h); @@ -8008,6 +9968,14 @@ SEXP wk_mass_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_mass_index_warmup_period(SEXP e) { + struct MassIndex *h = (struct MassIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mass_index_warmup_period(h)); +} +SEXP wk_mass_index_is_ready(SEXP e) { + struct MassIndex *h = (struct MassIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mass_index_is_ready(h)); +} SEXP wk_mass_index_reset(SEXP e) { struct MassIndex *h = (struct MassIndex *)R_ExternalPtrAddr(e); wickra_mass_index_reset(h); @@ -8041,6 +10009,14 @@ SEXP wk_mat_hold_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_mat_hold_warmup_period(SEXP e) { + struct MatHold *h = (struct MatHold *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mat_hold_warmup_period(h)); +} +SEXP wk_mat_hold_is_ready(SEXP e) { + struct MatHold *h = (struct MatHold *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mat_hold_is_ready(h)); +} SEXP wk_mat_hold_reset(SEXP e) { struct MatHold *h = (struct MatHold *)R_ExternalPtrAddr(e); wickra_mat_hold_reset(h); @@ -8074,6 +10050,14 @@ SEXP wk_matching_low_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_matching_low_warmup_period(SEXP e) { + struct MatchingLow *h = (struct MatchingLow *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_matching_low_warmup_period(h)); +} +SEXP wk_matching_low_is_ready(SEXP e) { + struct MatchingLow *h = (struct MatchingLow *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_matching_low_is_ready(h)); +} SEXP wk_matching_low_reset(SEXP e) { struct MatchingLow *h = (struct MatchingLow *)R_ExternalPtrAddr(e); wickra_matching_low_reset(h); @@ -8105,6 +10089,14 @@ SEXP wk_max_drawdown_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_max_drawdown_warmup_period(SEXP e) { + struct MaxDrawdown *h = (struct MaxDrawdown *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_max_drawdown_warmup_period(h)); +} +SEXP wk_max_drawdown_is_ready(SEXP e) { + struct MaxDrawdown *h = (struct MaxDrawdown *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_max_drawdown_is_ready(h)); +} SEXP wk_max_drawdown_reset(SEXP e) { struct MaxDrawdown *h = (struct MaxDrawdown *)R_ExternalPtrAddr(e); wickra_max_drawdown_reset(h); @@ -8128,6 +10120,14 @@ SEXP wk_mc_clellan_oscillator_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct McClellanOscillator *h = (struct McClellanOscillator *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_mc_clellan_oscillator_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_mc_clellan_oscillator_warmup_period(SEXP e) { + struct McClellanOscillator *h = (struct McClellanOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mc_clellan_oscillator_warmup_period(h)); +} +SEXP wk_mc_clellan_oscillator_is_ready(SEXP e) { + struct McClellanOscillator *h = (struct McClellanOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mc_clellan_oscillator_is_ready(h)); +} SEXP wk_mc_clellan_oscillator_reset(SEXP e) { struct McClellanOscillator *h = (struct McClellanOscillator *)R_ExternalPtrAddr(e); wickra_mc_clellan_oscillator_reset(h); @@ -8151,6 +10151,14 @@ SEXP wk_mc_clellan_summation_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEX struct McClellanSummationIndex *h = (struct McClellanSummationIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_mc_clellan_summation_index_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_mc_clellan_summation_index_warmup_period(SEXP e) { + struct McClellanSummationIndex *h = (struct McClellanSummationIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mc_clellan_summation_index_warmup_period(h)); +} +SEXP wk_mc_clellan_summation_index_is_ready(SEXP e) { + struct McClellanSummationIndex *h = (struct McClellanSummationIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mc_clellan_summation_index_is_ready(h)); +} SEXP wk_mc_clellan_summation_index_reset(SEXP e) { struct McClellanSummationIndex *h = (struct McClellanSummationIndex *)R_ExternalPtrAddr(e); wickra_mc_clellan_summation_index_reset(h); @@ -8182,6 +10190,14 @@ SEXP wk_mc_ginley_dynamic_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_mc_ginley_dynamic_warmup_period(SEXP e) { + struct McGinleyDynamic *h = (struct McGinleyDynamic *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mc_ginley_dynamic_warmup_period(h)); +} +SEXP wk_mc_ginley_dynamic_is_ready(SEXP e) { + struct McGinleyDynamic *h = (struct McGinleyDynamic *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mc_ginley_dynamic_is_ready(h)); +} SEXP wk_mc_ginley_dynamic_reset(SEXP e) { struct McGinleyDynamic *h = (struct McGinleyDynamic *)R_ExternalPtrAddr(e); wickra_mc_ginley_dynamic_reset(h); @@ -8213,6 +10229,14 @@ SEXP wk_median_absolute_deviation_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_median_absolute_deviation_warmup_period(SEXP e) { + struct MedianAbsoluteDeviation *h = (struct MedianAbsoluteDeviation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_median_absolute_deviation_warmup_period(h)); +} +SEXP wk_median_absolute_deviation_is_ready(SEXP e) { + struct MedianAbsoluteDeviation *h = (struct MedianAbsoluteDeviation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_median_absolute_deviation_is_ready(h)); +} SEXP wk_median_absolute_deviation_reset(SEXP e) { struct MedianAbsoluteDeviation *h = (struct MedianAbsoluteDeviation *)R_ExternalPtrAddr(e); wickra_median_absolute_deviation_reset(h); @@ -8248,6 +10272,14 @@ SEXP wk_median_channel_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_median_channel_warmup_period(SEXP e) { + struct MedianChannel *h = (struct MedianChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_median_channel_warmup_period(h)); +} +SEXP wk_median_channel_is_ready(SEXP e) { + struct MedianChannel *h = (struct MedianChannel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_median_channel_is_ready(h)); +} SEXP wk_median_channel_reset(SEXP e) { struct MedianChannel *h = (struct MedianChannel *)R_ExternalPtrAddr(e); wickra_median_channel_reset(h); @@ -8279,6 +10311,14 @@ SEXP wk_median_ma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_median_ma_warmup_period(SEXP e) { + struct MedianMa *h = (struct MedianMa *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_median_ma_warmup_period(h)); +} +SEXP wk_median_ma_is_ready(SEXP e) { + struct MedianMa *h = (struct MedianMa *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_median_ma_is_ready(h)); +} SEXP wk_median_ma_reset(SEXP e) { struct MedianMa *h = (struct MedianMa *)R_ExternalPtrAddr(e); wickra_median_ma_reset(h); @@ -8312,6 +10352,14 @@ SEXP wk_median_price_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_median_price_warmup_period(SEXP e) { + struct MedianPrice *h = (struct MedianPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_median_price_warmup_period(h)); +} +SEXP wk_median_price_is_ready(SEXP e) { + struct MedianPrice *h = (struct MedianPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_median_price_is_ready(h)); +} SEXP wk_median_price_reset(SEXP e) { struct MedianPrice *h = (struct MedianPrice *)R_ExternalPtrAddr(e); wickra_median_price_reset(h); @@ -8345,6 +10393,14 @@ SEXP wk_mfi_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_mfi_warmup_period(SEXP e) { + struct Mfi *h = (struct Mfi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mfi_warmup_period(h)); +} +SEXP wk_mfi_is_ready(SEXP e) { + struct Mfi *h = (struct Mfi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mfi_is_ready(h)); +} SEXP wk_mfi_reset(SEXP e) { struct Mfi *h = (struct Mfi *)R_ExternalPtrAddr(e); wickra_mfi_reset(h); @@ -8368,6 +10424,14 @@ SEXP wk_microprice_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct Microprice *h = (struct Microprice *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_microprice_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_microprice_warmup_period(SEXP e) { + struct Microprice *h = (struct Microprice *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_microprice_warmup_period(h)); +} +SEXP wk_microprice_is_ready(SEXP e) { + struct Microprice *h = (struct Microprice *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_microprice_is_ready(h)); +} SEXP wk_microprice_reset(SEXP e) { struct Microprice *h = (struct Microprice *)R_ExternalPtrAddr(e); wickra_microprice_reset(h); @@ -8399,6 +10463,14 @@ SEXP wk_mid_point_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_mid_point_warmup_period(SEXP e) { + struct MidPoint *h = (struct MidPoint *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mid_point_warmup_period(h)); +} +SEXP wk_mid_point_is_ready(SEXP e) { + struct MidPoint *h = (struct MidPoint *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mid_point_is_ready(h)); +} SEXP wk_mid_point_reset(SEXP e) { struct MidPoint *h = (struct MidPoint *)R_ExternalPtrAddr(e); wickra_mid_point_reset(h); @@ -8432,6 +10504,14 @@ SEXP wk_mid_price_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_mid_price_warmup_period(SEXP e) { + struct MidPrice *h = (struct MidPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mid_price_warmup_period(h)); +} +SEXP wk_mid_price_is_ready(SEXP e) { + struct MidPrice *h = (struct MidPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mid_price_is_ready(h)); +} SEXP wk_mid_price_reset(SEXP e) { struct MidPrice *h = (struct MidPrice *)R_ExternalPtrAddr(e); wickra_mid_price_reset(h); @@ -8465,6 +10545,14 @@ SEXP wk_minus_di_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_minus_di_warmup_period(SEXP e) { + struct MinusDi *h = (struct MinusDi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_minus_di_warmup_period(h)); +} +SEXP wk_minus_di_is_ready(SEXP e) { + struct MinusDi *h = (struct MinusDi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_minus_di_is_ready(h)); +} SEXP wk_minus_di_reset(SEXP e) { struct MinusDi *h = (struct MinusDi *)R_ExternalPtrAddr(e); wickra_minus_di_reset(h); @@ -8498,6 +10586,14 @@ SEXP wk_minus_dm_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_minus_dm_warmup_period(SEXP e) { + struct MinusDm *h = (struct MinusDm *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_minus_dm_warmup_period(h)); +} +SEXP wk_minus_dm_is_ready(SEXP e) { + struct MinusDm *h = (struct MinusDm *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_minus_dm_is_ready(h)); +} SEXP wk_minus_dm_reset(SEXP e) { struct MinusDm *h = (struct MinusDm *)R_ExternalPtrAddr(e); wickra_minus_dm_reset(h); @@ -8531,6 +10627,14 @@ SEXP wk_modified_ma_stop_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_modified_ma_stop_warmup_period(SEXP e) { + struct ModifiedMaStop *h = (struct ModifiedMaStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_modified_ma_stop_warmup_period(h)); +} +SEXP wk_modified_ma_stop_is_ready(SEXP e) { + struct ModifiedMaStop *h = (struct ModifiedMaStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_modified_ma_stop_is_ready(h)); +} SEXP wk_modified_ma_stop_reset(SEXP e) { struct ModifiedMaStop *h = (struct ModifiedMaStop *)R_ExternalPtrAddr(e); wickra_modified_ma_stop_reset(h); @@ -8562,6 +10666,14 @@ SEXP wk_mom_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_mom_warmup_period(SEXP e) { + struct Mom *h = (struct Mom *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_mom_warmup_period(h)); +} +SEXP wk_mom_is_ready(SEXP e) { + struct Mom *h = (struct Mom *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_mom_is_ready(h)); +} SEXP wk_mom_reset(SEXP e) { struct Mom *h = (struct Mom *)R_ExternalPtrAddr(e); wickra_mom_reset(h); @@ -8595,6 +10707,14 @@ SEXP wk_morning_doji_star_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_morning_doji_star_warmup_period(SEXP e) { + struct MorningDojiStar *h = (struct MorningDojiStar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_morning_doji_star_warmup_period(h)); +} +SEXP wk_morning_doji_star_is_ready(SEXP e) { + struct MorningDojiStar *h = (struct MorningDojiStar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_morning_doji_star_is_ready(h)); +} SEXP wk_morning_doji_star_reset(SEXP e) { struct MorningDojiStar *h = (struct MorningDojiStar *)R_ExternalPtrAddr(e); wickra_morning_doji_star_reset(h); @@ -8628,6 +10748,14 @@ SEXP wk_morning_evening_star_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(1); return out; } +SEXP wk_morning_evening_star_warmup_period(SEXP e) { + struct MorningEveningStar *h = (struct MorningEveningStar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_morning_evening_star_warmup_period(h)); +} +SEXP wk_morning_evening_star_is_ready(SEXP e) { + struct MorningEveningStar *h = (struct MorningEveningStar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_morning_evening_star_is_ready(h)); +} SEXP wk_morning_evening_star_reset(SEXP e) { struct MorningEveningStar *h = (struct MorningEveningStar *)R_ExternalPtrAddr(e); wickra_morning_evening_star_reset(h); @@ -8675,6 +10803,14 @@ SEXP wk_murrey_math_lines_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(2); return r; } +SEXP wk_murrey_math_lines_warmup_period(SEXP e) { + struct MurreyMathLines *h = (struct MurreyMathLines *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_murrey_math_lines_warmup_period(h)); +} +SEXP wk_murrey_math_lines_is_ready(SEXP e) { + struct MurreyMathLines *h = (struct MurreyMathLines *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_murrey_math_lines_is_ready(h)); +} SEXP wk_murrey_math_lines_reset(SEXP e) { struct MurreyMathLines *h = (struct MurreyMathLines *)R_ExternalPtrAddr(e); wickra_murrey_math_lines_reset(h); @@ -8708,6 +10844,14 @@ SEXP wk_naked_poc_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_naked_poc_warmup_period(SEXP e) { + struct NakedPoc *h = (struct NakedPoc *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_naked_poc_warmup_period(h)); +} +SEXP wk_naked_poc_is_ready(SEXP e) { + struct NakedPoc *h = (struct NakedPoc *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_naked_poc_is_ready(h)); +} SEXP wk_naked_poc_reset(SEXP e) { struct NakedPoc *h = (struct NakedPoc *)R_ExternalPtrAddr(e); wickra_naked_poc_reset(h); @@ -8741,6 +10885,14 @@ SEXP wk_natr_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_natr_warmup_period(SEXP e) { + struct Natr *h = (struct Natr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_natr_warmup_period(h)); +} +SEXP wk_natr_is_ready(SEXP e) { + struct Natr *h = (struct Natr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_natr_is_ready(h)); +} SEXP wk_natr_reset(SEXP e) { struct Natr *h = (struct Natr *)R_ExternalPtrAddr(e); wickra_natr_reset(h); @@ -8764,6 +10916,14 @@ SEXP wk_new_highs_new_lows_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE struct NewHighsNewLows *h = (struct NewHighsNewLows *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_new_highs_new_lows_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_new_highs_new_lows_warmup_period(SEXP e) { + struct NewHighsNewLows *h = (struct NewHighsNewLows *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_new_highs_new_lows_warmup_period(h)); +} +SEXP wk_new_highs_new_lows_is_ready(SEXP e) { + struct NewHighsNewLows *h = (struct NewHighsNewLows *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_new_highs_new_lows_is_ready(h)); +} SEXP wk_new_highs_new_lows_reset(SEXP e) { struct NewHighsNewLows *h = (struct NewHighsNewLows *)R_ExternalPtrAddr(e); wickra_new_highs_new_lows_reset(h); @@ -8797,6 +10957,14 @@ SEXP wk_new_price_lines_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_new_price_lines_warmup_period(SEXP e) { + struct NewPriceLines *h = (struct NewPriceLines *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_new_price_lines_warmup_period(h)); +} +SEXP wk_new_price_lines_is_ready(SEXP e) { + struct NewPriceLines *h = (struct NewPriceLines *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_new_price_lines_is_ready(h)); +} SEXP wk_new_price_lines_reset(SEXP e) { struct NewPriceLines *h = (struct NewPriceLines *)R_ExternalPtrAddr(e); wickra_new_price_lines_reset(h); @@ -8830,6 +10998,14 @@ SEXP wk_nrtr_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5 UNPROTECT(2); return r; } +SEXP wk_nrtr_warmup_period(SEXP e) { + struct Nrtr *h = (struct Nrtr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_nrtr_warmup_period(h)); +} +SEXP wk_nrtr_is_ready(SEXP e) { + struct Nrtr *h = (struct Nrtr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_nrtr_is_ready(h)); +} SEXP wk_nrtr_reset(SEXP e) { struct Nrtr *h = (struct Nrtr *)R_ExternalPtrAddr(e); wickra_nrtr_reset(h); @@ -8863,6 +11039,14 @@ SEXP wk_nvi_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_nvi_warmup_period(SEXP e) { + struct Nvi *h = (struct Nvi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_nvi_warmup_period(h)); +} +SEXP wk_nvi_is_ready(SEXP e) { + struct Nvi *h = (struct Nvi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_nvi_is_ready(h)); +} SEXP wk_nvi_reset(SEXP e) { struct Nvi *h = (struct Nvi *)R_ExternalPtrAddr(e); wickra_nvi_reset(h); @@ -8896,6 +11080,14 @@ SEXP wk_obv_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_obv_warmup_period(SEXP e) { + struct Obv *h = (struct Obv *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_obv_warmup_period(h)); +} +SEXP wk_obv_is_ready(SEXP e) { + struct Obv *h = (struct Obv *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_obv_is_ready(h)); +} SEXP wk_obv_reset(SEXP e) { struct Obv *h = (struct Obv *)R_ExternalPtrAddr(e); wickra_obv_reset(h); @@ -8919,6 +11111,14 @@ SEXP wk_oi_price_divergence_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S struct OIPriceDivergence *h = (struct OIPriceDivergence *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_oi_price_divergence_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_oi_price_divergence_warmup_period(SEXP e) { + struct OIPriceDivergence *h = (struct OIPriceDivergence *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_oi_price_divergence_warmup_period(h)); +} +SEXP wk_oi_price_divergence_is_ready(SEXP e) { + struct OIPriceDivergence *h = (struct OIPriceDivergence *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_oi_price_divergence_is_ready(h)); +} SEXP wk_oi_price_divergence_reset(SEXP e) { struct OIPriceDivergence *h = (struct OIPriceDivergence *)R_ExternalPtrAddr(e); wickra_oi_price_divergence_reset(h); @@ -8942,6 +11142,14 @@ SEXP wk_oi_to_volume_ratio_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE struct OiToVolumeRatio *h = (struct OiToVolumeRatio *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_oi_to_volume_ratio_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_oi_to_volume_ratio_warmup_period(SEXP e) { + struct OiToVolumeRatio *h = (struct OiToVolumeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_oi_to_volume_ratio_warmup_period(h)); +} +SEXP wk_oi_to_volume_ratio_is_ready(SEXP e) { + struct OiToVolumeRatio *h = (struct OiToVolumeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_oi_to_volume_ratio_is_ready(h)); +} SEXP wk_oi_to_volume_ratio_reset(SEXP e) { struct OiToVolumeRatio *h = (struct OiToVolumeRatio *)R_ExternalPtrAddr(e); wickra_oi_to_volume_ratio_reset(h); @@ -8965,6 +11173,14 @@ SEXP wk_oi_weighted_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, struct OIWeighted *h = (struct OIWeighted *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_oi_weighted_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_oi_weighted_warmup_period(SEXP e) { + struct OIWeighted *h = (struct OIWeighted *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_oi_weighted_warmup_period(h)); +} +SEXP wk_oi_weighted_is_ready(SEXP e) { + struct OIWeighted *h = (struct OIWeighted *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_oi_weighted_is_ready(h)); +} SEXP wk_oi_weighted_reset(SEXP e) { struct OIWeighted *h = (struct OIWeighted *)R_ExternalPtrAddr(e); wickra_oi_weighted_reset(h); @@ -8996,6 +11212,14 @@ SEXP wk_omega_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_omega_ratio_warmup_period(SEXP e) { + struct OmegaRatio *h = (struct OmegaRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_omega_ratio_warmup_period(h)); +} +SEXP wk_omega_ratio_is_ready(SEXP e) { + struct OmegaRatio *h = (struct OmegaRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_omega_ratio_is_ready(h)); +} SEXP wk_omega_ratio_reset(SEXP e) { struct OmegaRatio *h = (struct OmegaRatio *)R_ExternalPtrAddr(e); wickra_omega_ratio_reset(h); @@ -9029,6 +11253,14 @@ SEXP wk_on_neck_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_on_neck_warmup_period(SEXP e) { + struct OnNeck *h = (struct OnNeck *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_on_neck_warmup_period(h)); +} +SEXP wk_on_neck_is_ready(SEXP e) { + struct OnNeck *h = (struct OnNeck *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_on_neck_is_ready(h)); +} SEXP wk_on_neck_reset(SEXP e) { struct OnNeck *h = (struct OnNeck *)R_ExternalPtrAddr(e); wickra_on_neck_reset(h); @@ -9052,6 +11284,14 @@ SEXP wk_open_interest_delta_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S struct OpenInterestDelta *h = (struct OpenInterestDelta *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_open_interest_delta_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_open_interest_delta_warmup_period(SEXP e) { + struct OpenInterestDelta *h = (struct OpenInterestDelta *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_open_interest_delta_warmup_period(h)); +} +SEXP wk_open_interest_delta_is_ready(SEXP e) { + struct OpenInterestDelta *h = (struct OpenInterestDelta *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_open_interest_delta_is_ready(h)); +} SEXP wk_open_interest_delta_reset(SEXP e) { struct OpenInterestDelta *h = (struct OpenInterestDelta *)R_ExternalPtrAddr(e); wickra_open_interest_delta_reset(h); @@ -9075,6 +11315,14 @@ SEXP wk_open_interest_momentum_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 struct OpenInterestMomentum *h = (struct OpenInterestMomentum *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_open_interest_momentum_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_open_interest_momentum_warmup_period(SEXP e) { + struct OpenInterestMomentum *h = (struct OpenInterestMomentum *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_open_interest_momentum_warmup_period(h)); +} +SEXP wk_open_interest_momentum_is_ready(SEXP e) { + struct OpenInterestMomentum *h = (struct OpenInterestMomentum *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_open_interest_momentum_is_ready(h)); +} SEXP wk_open_interest_momentum_reset(SEXP e) { struct OpenInterestMomentum *h = (struct OpenInterestMomentum *)R_ExternalPtrAddr(e); wickra_open_interest_momentum_reset(h); @@ -9108,6 +11356,14 @@ SEXP wk_opening_marubozu_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_opening_marubozu_warmup_period(SEXP e) { + struct OpeningMarubozu *h = (struct OpeningMarubozu *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_opening_marubozu_warmup_period(h)); +} +SEXP wk_opening_marubozu_is_ready(SEXP e) { + struct OpeningMarubozu *h = (struct OpeningMarubozu *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_opening_marubozu_is_ready(h)); +} SEXP wk_opening_marubozu_reset(SEXP e) { struct OpeningMarubozu *h = (struct OpeningMarubozu *)R_ExternalPtrAddr(e); wickra_opening_marubozu_reset(h); @@ -9143,6 +11399,14 @@ SEXP wk_opening_range_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_opening_range_warmup_period(SEXP e) { + struct OpeningRange *h = (struct OpeningRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_opening_range_warmup_period(h)); +} +SEXP wk_opening_range_is_ready(SEXP e) { + struct OpeningRange *h = (struct OpeningRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_opening_range_is_ready(h)); +} SEXP wk_opening_range_reset(SEXP e) { struct OpeningRange *h = (struct OpeningRange *)R_ExternalPtrAddr(e); wickra_opening_range_reset(h); @@ -9166,6 +11430,14 @@ SEXP wk_order_book_imbalance_full_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP struct OrderBookImbalanceFull *h = (struct OrderBookImbalanceFull *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_order_book_imbalance_full_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_order_book_imbalance_full_warmup_period(SEXP e) { + struct OrderBookImbalanceFull *h = (struct OrderBookImbalanceFull *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_order_book_imbalance_full_warmup_period(h)); +} +SEXP wk_order_book_imbalance_full_is_ready(SEXP e) { + struct OrderBookImbalanceFull *h = (struct OrderBookImbalanceFull *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_order_book_imbalance_full_is_ready(h)); +} SEXP wk_order_book_imbalance_full_reset(SEXP e) { struct OrderBookImbalanceFull *h = (struct OrderBookImbalanceFull *)R_ExternalPtrAddr(e); wickra_order_book_imbalance_full_reset(h); @@ -9189,6 +11461,14 @@ SEXP wk_order_book_imbalance_top1_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP struct OrderBookImbalanceTop1 *h = (struct OrderBookImbalanceTop1 *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_order_book_imbalance_top1_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_order_book_imbalance_top1_warmup_period(SEXP e) { + struct OrderBookImbalanceTop1 *h = (struct OrderBookImbalanceTop1 *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_order_book_imbalance_top1_warmup_period(h)); +} +SEXP wk_order_book_imbalance_top1_is_ready(SEXP e) { + struct OrderBookImbalanceTop1 *h = (struct OrderBookImbalanceTop1 *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_order_book_imbalance_top1_is_ready(h)); +} SEXP wk_order_book_imbalance_top1_reset(SEXP e) { struct OrderBookImbalanceTop1 *h = (struct OrderBookImbalanceTop1 *)R_ExternalPtrAddr(e); wickra_order_book_imbalance_top1_reset(h); @@ -9212,6 +11492,14 @@ SEXP wk_order_book_imbalance_top_n_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEX struct OrderBookImbalanceTopN *h = (struct OrderBookImbalanceTopN *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_order_book_imbalance_top_n_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_order_book_imbalance_top_n_warmup_period(SEXP e) { + struct OrderBookImbalanceTopN *h = (struct OrderBookImbalanceTopN *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_order_book_imbalance_top_n_warmup_period(h)); +} +SEXP wk_order_book_imbalance_top_n_is_ready(SEXP e) { + struct OrderBookImbalanceTopN *h = (struct OrderBookImbalanceTopN *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_order_book_imbalance_top_n_is_ready(h)); +} SEXP wk_order_book_imbalance_top_n_reset(SEXP e) { struct OrderBookImbalanceTopN *h = (struct OrderBookImbalanceTopN *)R_ExternalPtrAddr(e); wickra_order_book_imbalance_top_n_reset(h); @@ -9235,6 +11523,14 @@ SEXP wk_order_flow_imbalance_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) struct OrderFlowImbalance *h = (struct OrderFlowImbalance *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_order_flow_imbalance_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_order_flow_imbalance_warmup_period(SEXP e) { + struct OrderFlowImbalance *h = (struct OrderFlowImbalance *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_order_flow_imbalance_warmup_period(h)); +} +SEXP wk_order_flow_imbalance_is_ready(SEXP e) { + struct OrderFlowImbalance *h = (struct OrderFlowImbalance *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_order_flow_imbalance_is_ready(h)); +} SEXP wk_order_flow_imbalance_reset(SEXP e) { struct OrderFlowImbalance *h = (struct OrderFlowImbalance *)R_ExternalPtrAddr(e); wickra_order_flow_imbalance_reset(h); @@ -9266,6 +11562,14 @@ SEXP wk_ou_half_life_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_ou_half_life_warmup_period(SEXP e) { + struct OuHalfLife *h = (struct OuHalfLife *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ou_half_life_warmup_period(h)); +} +SEXP wk_ou_half_life_is_ready(SEXP e) { + struct OuHalfLife *h = (struct OuHalfLife *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ou_half_life_is_ready(h)); +} SEXP wk_ou_half_life_reset(SEXP e) { struct OuHalfLife *h = (struct OuHalfLife *)R_ExternalPtrAddr(e); wickra_ou_half_life_reset(h); @@ -9299,6 +11603,14 @@ SEXP wk_overnight_gap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_overnight_gap_warmup_period(SEXP e) { + struct OvernightGap *h = (struct OvernightGap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_overnight_gap_warmup_period(h)); +} +SEXP wk_overnight_gap_is_ready(SEXP e) { + struct OvernightGap *h = (struct OvernightGap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_overnight_gap_is_ready(h)); +} SEXP wk_overnight_gap_reset(SEXP e) { struct OvernightGap *h = (struct OvernightGap *)R_ExternalPtrAddr(e); wickra_overnight_gap_reset(h); @@ -9332,6 +11644,14 @@ SEXP wk_overnight_intraday_return_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP UNPROTECT(2); return r; } +SEXP wk_overnight_intraday_return_warmup_period(SEXP e) { + struct OvernightIntradayReturn *h = (struct OvernightIntradayReturn *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_overnight_intraday_return_warmup_period(h)); +} +SEXP wk_overnight_intraday_return_is_ready(SEXP e) { + struct OvernightIntradayReturn *h = (struct OvernightIntradayReturn *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_overnight_intraday_return_is_ready(h)); +} SEXP wk_overnight_intraday_return_reset(SEXP e) { struct OvernightIntradayReturn *h = (struct OvernightIntradayReturn *)R_ExternalPtrAddr(e); wickra_overnight_intraday_return_reset(h); @@ -9363,6 +11683,14 @@ SEXP wk_pain_index_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_pain_index_warmup_period(SEXP e) { + struct PainIndex *h = (struct PainIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pain_index_warmup_period(h)); +} +SEXP wk_pain_index_is_ready(SEXP e) { + struct PainIndex *h = (struct PainIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pain_index_is_ready(h)); +} SEXP wk_pain_index_reset(SEXP e) { struct PainIndex *h = (struct PainIndex *)R_ExternalPtrAddr(e); wickra_pain_index_reset(h); @@ -9394,6 +11722,14 @@ SEXP wk_pair_spread_z_score_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_pair_spread_z_score_warmup_period(SEXP e) { + struct PairSpreadZScore *h = (struct PairSpreadZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pair_spread_z_score_warmup_period(h)); +} +SEXP wk_pair_spread_z_score_is_ready(SEXP e) { + struct PairSpreadZScore *h = (struct PairSpreadZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pair_spread_z_score_is_ready(h)); +} SEXP wk_pair_spread_z_score_reset(SEXP e) { struct PairSpreadZScore *h = (struct PairSpreadZScore *)R_ExternalPtrAddr(e); wickra_pair_spread_z_score_reset(h); @@ -9425,6 +11761,14 @@ SEXP wk_pairwise_beta_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_pairwise_beta_warmup_period(SEXP e) { + struct PairwiseBeta *h = (struct PairwiseBeta *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pairwise_beta_warmup_period(h)); +} +SEXP wk_pairwise_beta_is_ready(SEXP e) { + struct PairwiseBeta *h = (struct PairwiseBeta *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pairwise_beta_is_ready(h)); +} SEXP wk_pairwise_beta_reset(SEXP e) { struct PairwiseBeta *h = (struct PairwiseBeta *)R_ExternalPtrAddr(e); wickra_pairwise_beta_reset(h); @@ -9458,6 +11802,14 @@ SEXP wk_parkinson_volatility_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(1); return out; } +SEXP wk_parkinson_volatility_warmup_period(SEXP e) { + struct ParkinsonVolatility *h = (struct ParkinsonVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_parkinson_volatility_warmup_period(h)); +} +SEXP wk_parkinson_volatility_is_ready(SEXP e) { + struct ParkinsonVolatility *h = (struct ParkinsonVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_parkinson_volatility_is_ready(h)); +} SEXP wk_parkinson_volatility_reset(SEXP e) { struct ParkinsonVolatility *h = (struct ParkinsonVolatility *)R_ExternalPtrAddr(e); wickra_parkinson_volatility_reset(h); @@ -9489,6 +11841,14 @@ SEXP wk_pearson_correlation_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_pearson_correlation_warmup_period(SEXP e) { + struct PearsonCorrelation *h = (struct PearsonCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pearson_correlation_warmup_period(h)); +} +SEXP wk_pearson_correlation_is_ready(SEXP e) { + struct PearsonCorrelation *h = (struct PearsonCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pearson_correlation_is_ready(h)); +} SEXP wk_pearson_correlation_reset(SEXP e) { struct PearsonCorrelation *h = (struct PearsonCorrelation *)R_ExternalPtrAddr(e); wickra_pearson_correlation_reset(h); @@ -9512,6 +11872,14 @@ SEXP wk_percent_above_ma_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP struct PercentAboveMa *h = (struct PercentAboveMa *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_percent_above_ma_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_percent_above_ma_warmup_period(SEXP e) { + struct PercentAboveMa *h = (struct PercentAboveMa *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_percent_above_ma_warmup_period(h)); +} +SEXP wk_percent_above_ma_is_ready(SEXP e) { + struct PercentAboveMa *h = (struct PercentAboveMa *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_percent_above_ma_is_ready(h)); +} SEXP wk_percent_above_ma_reset(SEXP e) { struct PercentAboveMa *h = (struct PercentAboveMa *)R_ExternalPtrAddr(e); wickra_percent_above_ma_reset(h); @@ -9543,6 +11911,14 @@ SEXP wk_percent_b_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_percent_b_warmup_period(SEXP e) { + struct PercentB *h = (struct PercentB *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_percent_b_warmup_period(h)); +} +SEXP wk_percent_b_is_ready(SEXP e) { + struct PercentB *h = (struct PercentB *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_percent_b_is_ready(h)); +} SEXP wk_percent_b_reset(SEXP e) { struct PercentB *h = (struct PercentB *)R_ExternalPtrAddr(e); wickra_percent_b_reset(h); @@ -9574,6 +11950,14 @@ SEXP wk_percentage_trailing_stop_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_percentage_trailing_stop_warmup_period(SEXP e) { + struct PercentageTrailingStop *h = (struct PercentageTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_percentage_trailing_stop_warmup_period(h)); +} +SEXP wk_percentage_trailing_stop_is_ready(SEXP e) { + struct PercentageTrailingStop *h = (struct PercentageTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_percentage_trailing_stop_is_ready(h)); +} SEXP wk_percentage_trailing_stop_reset(SEXP e) { struct PercentageTrailingStop *h = (struct PercentageTrailingStop *)R_ExternalPtrAddr(e); wickra_percentage_trailing_stop_reset(h); @@ -9597,6 +11981,14 @@ SEXP wk_perpetual_premium_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a struct PerpetualPremiumIndex *h = (struct PerpetualPremiumIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_perpetual_premium_index_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_perpetual_premium_index_warmup_period(SEXP e) { + struct PerpetualPremiumIndex *h = (struct PerpetualPremiumIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_perpetual_premium_index_warmup_period(h)); +} +SEXP wk_perpetual_premium_index_is_ready(SEXP e) { + struct PerpetualPremiumIndex *h = (struct PerpetualPremiumIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_perpetual_premium_index_is_ready(h)); +} SEXP wk_perpetual_premium_index_reset(SEXP e) { struct PerpetualPremiumIndex *h = (struct PerpetualPremiumIndex *)R_ExternalPtrAddr(e); wickra_perpetual_premium_index_reset(h); @@ -9630,6 +12022,14 @@ SEXP wk_pgo_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_pgo_warmup_period(SEXP e) { + struct Pgo *h = (struct Pgo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pgo_warmup_period(h)); +} +SEXP wk_pgo_is_ready(SEXP e) { + struct Pgo *h = (struct Pgo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pgo_is_ready(h)); +} SEXP wk_pgo_reset(SEXP e) { struct Pgo *h = (struct Pgo *)R_ExternalPtrAddr(e); wickra_pgo_reset(h); @@ -9663,6 +12063,14 @@ SEXP wk_piercing_dark_cloud_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE UNPROTECT(1); return out; } +SEXP wk_piercing_dark_cloud_warmup_period(SEXP e) { + struct PiercingDarkCloud *h = (struct PiercingDarkCloud *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_piercing_dark_cloud_warmup_period(h)); +} +SEXP wk_piercing_dark_cloud_is_ready(SEXP e) { + struct PiercingDarkCloud *h = (struct PiercingDarkCloud *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_piercing_dark_cloud_is_ready(h)); +} SEXP wk_piercing_dark_cloud_reset(SEXP e) { struct PiercingDarkCloud *h = (struct PiercingDarkCloud *)R_ExternalPtrAddr(e); wickra_piercing_dark_cloud_reset(h); @@ -9686,6 +12094,14 @@ SEXP wk_pin_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct Pin *h = (struct Pin *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_pin_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_pin_warmup_period(SEXP e) { + struct Pin *h = (struct Pin *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pin_warmup_period(h)); +} +SEXP wk_pin_is_ready(SEXP e) { + struct Pin *h = (struct Pin *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pin_is_ready(h)); +} SEXP wk_pin_reset(SEXP e) { struct Pin *h = (struct Pin *)R_ExternalPtrAddr(e); wickra_pin_reset(h); @@ -9719,6 +12135,14 @@ SEXP wk_pivot_reversal_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_pivot_reversal_warmup_period(SEXP e) { + struct PivotReversal *h = (struct PivotReversal *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pivot_reversal_warmup_period(h)); +} +SEXP wk_pivot_reversal_is_ready(SEXP e) { + struct PivotReversal *h = (struct PivotReversal *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pivot_reversal_is_ready(h)); +} SEXP wk_pivot_reversal_reset(SEXP e) { struct PivotReversal *h = (struct PivotReversal *)R_ExternalPtrAddr(e); wickra_pivot_reversal_reset(h); @@ -9752,6 +12176,14 @@ SEXP wk_plus_di_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_plus_di_warmup_period(SEXP e) { + struct PlusDi *h = (struct PlusDi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_plus_di_warmup_period(h)); +} +SEXP wk_plus_di_is_ready(SEXP e) { + struct PlusDi *h = (struct PlusDi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_plus_di_is_ready(h)); +} SEXP wk_plus_di_reset(SEXP e) { struct PlusDi *h = (struct PlusDi *)R_ExternalPtrAddr(e); wickra_plus_di_reset(h); @@ -9785,6 +12217,14 @@ SEXP wk_plus_dm_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_plus_dm_warmup_period(SEXP e) { + struct PlusDm *h = (struct PlusDm *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_plus_dm_warmup_period(h)); +} +SEXP wk_plus_dm_is_ready(SEXP e) { + struct PlusDm *h = (struct PlusDm *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_plus_dm_is_ready(h)); +} SEXP wk_plus_dm_reset(SEXP e) { struct PlusDm *h = (struct PlusDm *)R_ExternalPtrAddr(e); wickra_plus_dm_reset(h); @@ -9816,6 +12256,14 @@ SEXP wk_pmo_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_pmo_warmup_period(SEXP e) { + struct Pmo *h = (struct Pmo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pmo_warmup_period(h)); +} +SEXP wk_pmo_is_ready(SEXP e) { + struct Pmo *h = (struct Pmo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pmo_is_ready(h)); +} SEXP wk_pmo_reset(SEXP e) { struct Pmo *h = (struct Pmo *)R_ExternalPtrAddr(e); wickra_pmo_reset(h); @@ -9886,6 +12334,14 @@ SEXP wk_polarized_fractal_efficiency_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_polarized_fractal_efficiency_warmup_period(SEXP e) { + struct PolarizedFractalEfficiency *h = (struct PolarizedFractalEfficiency *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_polarized_fractal_efficiency_warmup_period(h)); +} +SEXP wk_polarized_fractal_efficiency_is_ready(SEXP e) { + struct PolarizedFractalEfficiency *h = (struct PolarizedFractalEfficiency *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_polarized_fractal_efficiency_is_ready(h)); +} SEXP wk_polarized_fractal_efficiency_reset(SEXP e) { struct PolarizedFractalEfficiency *h = (struct PolarizedFractalEfficiency *)R_ExternalPtrAddr(e); wickra_polarized_fractal_efficiency_reset(h); @@ -9917,6 +12373,14 @@ SEXP wk_ppo_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ppo_warmup_period(SEXP e) { + struct Ppo *h = (struct Ppo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ppo_warmup_period(h)); +} +SEXP wk_ppo_is_ready(SEXP e) { + struct Ppo *h = (struct Ppo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ppo_is_ready(h)); +} SEXP wk_ppo_reset(SEXP e) { struct Ppo *h = (struct Ppo *)R_ExternalPtrAddr(e); wickra_ppo_reset(h); @@ -9948,6 +12412,14 @@ SEXP wk_ppo_histogram_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ppo_histogram_warmup_period(SEXP e) { + struct PpoHistogram *h = (struct PpoHistogram *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ppo_histogram_warmup_period(h)); +} +SEXP wk_ppo_histogram_is_ready(SEXP e) { + struct PpoHistogram *h = (struct PpoHistogram *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ppo_histogram_is_ready(h)); +} SEXP wk_ppo_histogram_reset(SEXP e) { struct PpoHistogram *h = (struct PpoHistogram *)R_ExternalPtrAddr(e); wickra_ppo_histogram_reset(h); @@ -9981,6 +12453,14 @@ SEXP wk_profile_shape_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_profile_shape_warmup_period(SEXP e) { + struct ProfileShape *h = (struct ProfileShape *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_profile_shape_warmup_period(h)); +} +SEXP wk_profile_shape_is_ready(SEXP e) { + struct ProfileShape *h = (struct ProfileShape *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_profile_shape_is_ready(h)); +} SEXP wk_profile_shape_reset(SEXP e) { struct ProfileShape *h = (struct ProfileShape *)R_ExternalPtrAddr(e); wickra_profile_shape_reset(h); @@ -10012,6 +12492,14 @@ SEXP wk_profit_factor_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_profit_factor_warmup_period(SEXP e) { + struct ProfitFactor *h = (struct ProfitFactor *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_profit_factor_warmup_period(h)); +} +SEXP wk_profit_factor_is_ready(SEXP e) { + struct ProfitFactor *h = (struct ProfitFactor *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_profit_factor_is_ready(h)); +} SEXP wk_profit_factor_reset(SEXP e) { struct ProfitFactor *h = (struct ProfitFactor *)R_ExternalPtrAddr(e); wickra_profit_factor_reset(h); @@ -10047,6 +12535,14 @@ SEXP wk_projection_bands_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_projection_bands_warmup_period(SEXP e) { + struct ProjectionBands *h = (struct ProjectionBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_projection_bands_warmup_period(h)); +} +SEXP wk_projection_bands_is_ready(SEXP e) { + struct ProjectionBands *h = (struct ProjectionBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_projection_bands_is_ready(h)); +} SEXP wk_projection_bands_reset(SEXP e) { struct ProjectionBands *h = (struct ProjectionBands *)R_ExternalPtrAddr(e); wickra_projection_bands_reset(h); @@ -10080,6 +12576,14 @@ SEXP wk_projection_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_projection_oscillator_warmup_period(SEXP e) { + struct ProjectionOscillator *h = (struct ProjectionOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_projection_oscillator_warmup_period(h)); +} +SEXP wk_projection_oscillator_is_ready(SEXP e) { + struct ProjectionOscillator *h = (struct ProjectionOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_projection_oscillator_is_ready(h)); +} SEXP wk_projection_oscillator_reset(SEXP e) { struct ProjectionOscillator *h = (struct ProjectionOscillator *)R_ExternalPtrAddr(e); wickra_projection_oscillator_reset(h); @@ -10113,6 +12617,14 @@ SEXP wk_psar_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_psar_warmup_period(SEXP e) { + struct Psar *h = (struct Psar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_psar_warmup_period(h)); +} +SEXP wk_psar_is_ready(SEXP e) { + struct Psar *h = (struct Psar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_psar_is_ready(h)); +} SEXP wk_psar_reset(SEXP e) { struct Psar *h = (struct Psar *)R_ExternalPtrAddr(e); wickra_psar_reset(h); @@ -10146,6 +12658,14 @@ SEXP wk_pvi_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_pvi_warmup_period(SEXP e) { + struct Pvi *h = (struct Pvi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_pvi_warmup_period(h)); +} +SEXP wk_pvi_is_ready(SEXP e) { + struct Pvi *h = (struct Pvi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_pvi_is_ready(h)); +} SEXP wk_pvi_reset(SEXP e) { struct Pvi *h = (struct Pvi *)R_ExternalPtrAddr(e); wickra_pvi_reset(h); @@ -10179,6 +12699,14 @@ SEXP wk_qqe_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_qqe_warmup_period(SEXP e) { + struct Qqe *h = (struct Qqe *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_qqe_warmup_period(h)); +} +SEXP wk_qqe_is_ready(SEXP e) { + struct Qqe *h = (struct Qqe *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_qqe_is_ready(h)); +} SEXP wk_qqe_reset(SEXP e) { struct Qqe *h = (struct Qqe *)R_ExternalPtrAddr(e); wickra_qqe_reset(h); @@ -10212,6 +12740,14 @@ SEXP wk_qstick_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(1); return out; } +SEXP wk_qstick_warmup_period(SEXP e) { + struct Qstick *h = (struct Qstick *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_qstick_warmup_period(h)); +} +SEXP wk_qstick_is_ready(SEXP e) { + struct Qstick *h = (struct Qstick *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_qstick_is_ready(h)); +} SEXP wk_qstick_reset(SEXP e) { struct Qstick *h = (struct Qstick *)R_ExternalPtrAddr(e); wickra_qstick_reset(h); @@ -10247,6 +12783,14 @@ SEXP wk_quartile_bands_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_quartile_bands_warmup_period(SEXP e) { + struct QuartileBands *h = (struct QuartileBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_quartile_bands_warmup_period(h)); +} +SEXP wk_quartile_bands_is_ready(SEXP e) { + struct QuartileBands *h = (struct QuartileBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_quartile_bands_is_ready(h)); +} SEXP wk_quartile_bands_reset(SEXP e) { struct QuartileBands *h = (struct QuartileBands *)R_ExternalPtrAddr(e); wickra_quartile_bands_reset(h); @@ -10270,6 +12814,14 @@ SEXP wk_quoted_spread_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct QuotedSpread *h = (struct QuotedSpread *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_quoted_spread_update(h, (double *)REAL(a0), (double *)REAL(a1), (uintptr_t)Rf_xlength(a0), (double *)REAL(a2), (double *)REAL(a3), (uintptr_t)Rf_xlength(a2))); } +SEXP wk_quoted_spread_warmup_period(SEXP e) { + struct QuotedSpread *h = (struct QuotedSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_quoted_spread_warmup_period(h)); +} +SEXP wk_quoted_spread_is_ready(SEXP e) { + struct QuotedSpread *h = (struct QuotedSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_quoted_spread_is_ready(h)); +} SEXP wk_quoted_spread_reset(SEXP e) { struct QuotedSpread *h = (struct QuotedSpread *)R_ExternalPtrAddr(e); wickra_quoted_spread_reset(h); @@ -10301,6 +12853,14 @@ SEXP wk_r_squared_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_r_squared_warmup_period(SEXP e) { + struct RSquared *h = (struct RSquared *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_r_squared_warmup_period(h)); +} +SEXP wk_r_squared_is_ready(SEXP e) { + struct RSquared *h = (struct RSquared *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_r_squared_is_ready(h)); +} SEXP wk_r_squared_reset(SEXP e) { struct RSquared *h = (struct RSquared *)R_ExternalPtrAddr(e); wickra_r_squared_reset(h); @@ -10363,6 +12923,14 @@ SEXP wk_realized_spread_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP struct RealizedSpread *h = (struct RealizedSpread *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_realized_spread_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3), Rf_asReal(a4))); } +SEXP wk_realized_spread_warmup_period(SEXP e) { + struct RealizedSpread *h = (struct RealizedSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_realized_spread_warmup_period(h)); +} +SEXP wk_realized_spread_is_ready(SEXP e) { + struct RealizedSpread *h = (struct RealizedSpread *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_realized_spread_is_ready(h)); +} SEXP wk_realized_spread_reset(SEXP e) { struct RealizedSpread *h = (struct RealizedSpread *)R_ExternalPtrAddr(e); wickra_realized_spread_reset(h); @@ -10394,6 +12962,14 @@ SEXP wk_realized_volatility_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_realized_volatility_warmup_period(SEXP e) { + struct RealizedVolatility *h = (struct RealizedVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_realized_volatility_warmup_period(h)); +} +SEXP wk_realized_volatility_is_ready(SEXP e) { + struct RealizedVolatility *h = (struct RealizedVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_realized_volatility_is_ready(h)); +} SEXP wk_realized_volatility_reset(SEXP e) { struct RealizedVolatility *h = (struct RealizedVolatility *)R_ExternalPtrAddr(e); wickra_realized_volatility_reset(h); @@ -10425,6 +13001,14 @@ SEXP wk_recovery_factor_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_recovery_factor_warmup_period(SEXP e) { + struct RecoveryFactor *h = (struct RecoveryFactor *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_recovery_factor_warmup_period(h)); +} +SEXP wk_recovery_factor_is_ready(SEXP e) { + struct RecoveryFactor *h = (struct RecoveryFactor *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_recovery_factor_is_ready(h)); +} SEXP wk_recovery_factor_reset(SEXP e) { struct RecoveryFactor *h = (struct RecoveryFactor *)R_ExternalPtrAddr(e); wickra_recovery_factor_reset(h); @@ -10458,6 +13042,14 @@ SEXP wk_rectangle_range_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_rectangle_range_warmup_period(SEXP e) { + struct RectangleRange *h = (struct RectangleRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rectangle_range_warmup_period(h)); +} +SEXP wk_rectangle_range_is_ready(SEXP e) { + struct RectangleRange *h = (struct RectangleRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rectangle_range_is_ready(h)); +} SEXP wk_rectangle_range_reset(SEXP e) { struct RectangleRange *h = (struct RectangleRange *)R_ExternalPtrAddr(e); wickra_rectangle_range_reset(h); @@ -10489,6 +13081,14 @@ SEXP wk_reflex_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_reflex_warmup_period(SEXP e) { + struct Reflex *h = (struct Reflex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_reflex_warmup_period(h)); +} +SEXP wk_reflex_is_ready(SEXP e) { + struct Reflex *h = (struct Reflex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_reflex_is_ready(h)); +} SEXP wk_reflex_reset(SEXP e) { struct Reflex *h = (struct Reflex *)R_ExternalPtrAddr(e); wickra_reflex_reset(h); @@ -10520,6 +13120,14 @@ SEXP wk_regime_label_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_regime_label_warmup_period(SEXP e) { + struct RegimeLabel *h = (struct RegimeLabel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_regime_label_warmup_period(h)); +} +SEXP wk_regime_label_is_ready(SEXP e) { + struct RegimeLabel *h = (struct RegimeLabel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_regime_label_is_ready(h)); +} SEXP wk_regime_label_reset(SEXP e) { struct RegimeLabel *h = (struct RegimeLabel *)R_ExternalPtrAddr(e); wickra_regime_label_reset(h); @@ -10555,6 +13163,14 @@ SEXP wk_relative_strength_ab_update(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(2); return r; } +SEXP wk_relative_strength_ab_warmup_period(SEXP e) { + struct RelativeStrengthAB *h = (struct RelativeStrengthAB *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_relative_strength_ab_warmup_period(h)); +} +SEXP wk_relative_strength_ab_is_ready(SEXP e) { + struct RelativeStrengthAB *h = (struct RelativeStrengthAB *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_relative_strength_ab_is_ready(h)); +} SEXP wk_relative_strength_ab_reset(SEXP e) { struct RelativeStrengthAB *h = (struct RelativeStrengthAB *)R_ExternalPtrAddr(e); wickra_relative_strength_ab_reset(h); @@ -10625,6 +13241,14 @@ SEXP wk_renko_trailing_stop_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_renko_trailing_stop_warmup_period(SEXP e) { + struct RenkoTrailingStop *h = (struct RenkoTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_renko_trailing_stop_warmup_period(h)); +} +SEXP wk_renko_trailing_stop_is_ready(SEXP e) { + struct RenkoTrailingStop *h = (struct RenkoTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_renko_trailing_stop_is_ready(h)); +} SEXP wk_renko_trailing_stop_reset(SEXP e) { struct RenkoTrailingStop *h = (struct RenkoTrailingStop *)R_ExternalPtrAddr(e); wickra_renko_trailing_stop_reset(h); @@ -10658,6 +13282,14 @@ SEXP wk_rickshaw_man_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_rickshaw_man_warmup_period(SEXP e) { + struct RickshawMan *h = (struct RickshawMan *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rickshaw_man_warmup_period(h)); +} +SEXP wk_rickshaw_man_is_ready(SEXP e) { + struct RickshawMan *h = (struct RickshawMan *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rickshaw_man_is_ready(h)); +} SEXP wk_rickshaw_man_reset(SEXP e) { struct RickshawMan *h = (struct RickshawMan *)R_ExternalPtrAddr(e); wickra_rickshaw_man_reset(h); @@ -10691,6 +13323,14 @@ SEXP wk_rising_three_methods_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(1); return out; } +SEXP wk_rising_three_methods_warmup_period(SEXP e) { + struct RisingThreeMethods *h = (struct RisingThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rising_three_methods_warmup_period(h)); +} +SEXP wk_rising_three_methods_is_ready(SEXP e) { + struct RisingThreeMethods *h = (struct RisingThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rising_three_methods_is_ready(h)); +} SEXP wk_rising_three_methods_reset(SEXP e) { struct RisingThreeMethods *h = (struct RisingThreeMethods *)R_ExternalPtrAddr(e); wickra_rising_three_methods_reset(h); @@ -10722,6 +13362,14 @@ SEXP wk_rmi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rmi_warmup_period(SEXP e) { + struct Rmi *h = (struct Rmi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rmi_warmup_period(h)); +} +SEXP wk_rmi_is_ready(SEXP e) { + struct Rmi *h = (struct Rmi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rmi_is_ready(h)); +} SEXP wk_rmi_reset(SEXP e) { struct Rmi *h = (struct Rmi *)R_ExternalPtrAddr(e); wickra_rmi_reset(h); @@ -10753,6 +13401,14 @@ SEXP wk_roc_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_roc_warmup_period(SEXP e) { + struct Roc *h = (struct Roc *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_roc_warmup_period(h)); +} +SEXP wk_roc_is_ready(SEXP e) { + struct Roc *h = (struct Roc *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_roc_is_ready(h)); +} SEXP wk_roc_reset(SEXP e) { struct Roc *h = (struct Roc *)R_ExternalPtrAddr(e); wickra_roc_reset(h); @@ -10784,6 +13440,14 @@ SEXP wk_rocp_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rocp_warmup_period(SEXP e) { + struct Rocp *h = (struct Rocp *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rocp_warmup_period(h)); +} +SEXP wk_rocp_is_ready(SEXP e) { + struct Rocp *h = (struct Rocp *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rocp_is_ready(h)); +} SEXP wk_rocp_reset(SEXP e) { struct Rocp *h = (struct Rocp *)R_ExternalPtrAddr(e); wickra_rocp_reset(h); @@ -10815,6 +13479,14 @@ SEXP wk_rocr_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rocr_warmup_period(SEXP e) { + struct Rocr *h = (struct Rocr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rocr_warmup_period(h)); +} +SEXP wk_rocr_is_ready(SEXP e) { + struct Rocr *h = (struct Rocr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rocr_is_ready(h)); +} SEXP wk_rocr_reset(SEXP e) { struct Rocr *h = (struct Rocr *)R_ExternalPtrAddr(e); wickra_rocr_reset(h); @@ -10846,6 +13518,14 @@ SEXP wk_rocr100_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rocr100_warmup_period(SEXP e) { + struct Rocr100 *h = (struct Rocr100 *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rocr100_warmup_period(h)); +} +SEXP wk_rocr100_is_ready(SEXP e) { + struct Rocr100 *h = (struct Rocr100 *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rocr100_is_ready(h)); +} SEXP wk_rocr100_reset(SEXP e) { struct Rocr100 *h = (struct Rocr100 *)R_ExternalPtrAddr(e); wickra_rocr100_reset(h); @@ -10879,6 +13559,14 @@ SEXP wk_rogers_satchell_volatility_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP UNPROTECT(1); return out; } +SEXP wk_rogers_satchell_volatility_warmup_period(SEXP e) { + struct RogersSatchellVolatility *h = (struct RogersSatchellVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rogers_satchell_volatility_warmup_period(h)); +} +SEXP wk_rogers_satchell_volatility_is_ready(SEXP e) { + struct RogersSatchellVolatility *h = (struct RogersSatchellVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rogers_satchell_volatility_is_ready(h)); +} SEXP wk_rogers_satchell_volatility_reset(SEXP e) { struct RogersSatchellVolatility *h = (struct RogersSatchellVolatility *)R_ExternalPtrAddr(e); wickra_rogers_satchell_volatility_reset(h); @@ -10902,6 +13590,14 @@ SEXP wk_roll_measure_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct RollMeasure *h = (struct RollMeasure *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_roll_measure_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_roll_measure_warmup_period(SEXP e) { + struct RollMeasure *h = (struct RollMeasure *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_roll_measure_warmup_period(h)); +} +SEXP wk_roll_measure_is_ready(SEXP e) { + struct RollMeasure *h = (struct RollMeasure *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_roll_measure_is_ready(h)); +} SEXP wk_roll_measure_reset(SEXP e) { struct RollMeasure *h = (struct RollMeasure *)R_ExternalPtrAddr(e); wickra_roll_measure_reset(h); @@ -10933,6 +13629,14 @@ SEXP wk_rolling_correlation_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_rolling_correlation_warmup_period(SEXP e) { + struct RollingCorrelation *h = (struct RollingCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_correlation_warmup_period(h)); +} +SEXP wk_rolling_correlation_is_ready(SEXP e) { + struct RollingCorrelation *h = (struct RollingCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_correlation_is_ready(h)); +} SEXP wk_rolling_correlation_reset(SEXP e) { struct RollingCorrelation *h = (struct RollingCorrelation *)R_ExternalPtrAddr(e); wickra_rolling_correlation_reset(h); @@ -10964,6 +13668,14 @@ SEXP wk_rolling_covariance_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_rolling_covariance_warmup_period(SEXP e) { + struct RollingCovariance *h = (struct RollingCovariance *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_covariance_warmup_period(h)); +} +SEXP wk_rolling_covariance_is_ready(SEXP e) { + struct RollingCovariance *h = (struct RollingCovariance *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_covariance_is_ready(h)); +} SEXP wk_rolling_covariance_reset(SEXP e) { struct RollingCovariance *h = (struct RollingCovariance *)R_ExternalPtrAddr(e); wickra_rolling_covariance_reset(h); @@ -10995,6 +13707,14 @@ SEXP wk_rolling_iqr_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rolling_iqr_warmup_period(SEXP e) { + struct RollingIqr *h = (struct RollingIqr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_iqr_warmup_period(h)); +} +SEXP wk_rolling_iqr_is_ready(SEXP e) { + struct RollingIqr *h = (struct RollingIqr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_iqr_is_ready(h)); +} SEXP wk_rolling_iqr_reset(SEXP e) { struct RollingIqr *h = (struct RollingIqr *)R_ExternalPtrAddr(e); wickra_rolling_iqr_reset(h); @@ -11026,6 +13746,14 @@ SEXP wk_rolling_min_max_scaler_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rolling_min_max_scaler_warmup_period(SEXP e) { + struct RollingMinMaxScaler *h = (struct RollingMinMaxScaler *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_min_max_scaler_warmup_period(h)); +} +SEXP wk_rolling_min_max_scaler_is_ready(SEXP e) { + struct RollingMinMaxScaler *h = (struct RollingMinMaxScaler *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_min_max_scaler_is_ready(h)); +} SEXP wk_rolling_min_max_scaler_reset(SEXP e) { struct RollingMinMaxScaler *h = (struct RollingMinMaxScaler *)R_ExternalPtrAddr(e); wickra_rolling_min_max_scaler_reset(h); @@ -11057,6 +13785,14 @@ SEXP wk_rolling_percentile_rank_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rolling_percentile_rank_warmup_period(SEXP e) { + struct RollingPercentileRank *h = (struct RollingPercentileRank *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_percentile_rank_warmup_period(h)); +} +SEXP wk_rolling_percentile_rank_is_ready(SEXP e) { + struct RollingPercentileRank *h = (struct RollingPercentileRank *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_percentile_rank_is_ready(h)); +} SEXP wk_rolling_percentile_rank_reset(SEXP e) { struct RollingPercentileRank *h = (struct RollingPercentileRank *)R_ExternalPtrAddr(e); wickra_rolling_percentile_rank_reset(h); @@ -11088,6 +13824,14 @@ SEXP wk_rolling_quantile_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rolling_quantile_warmup_period(SEXP e) { + struct RollingQuantile *h = (struct RollingQuantile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_quantile_warmup_period(h)); +} +SEXP wk_rolling_quantile_is_ready(SEXP e) { + struct RollingQuantile *h = (struct RollingQuantile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_quantile_is_ready(h)); +} SEXP wk_rolling_quantile_reset(SEXP e) { struct RollingQuantile *h = (struct RollingQuantile *)R_ExternalPtrAddr(e); wickra_rolling_quantile_reset(h); @@ -11121,6 +13865,14 @@ SEXP wk_rolling_vwap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_rolling_vwap_warmup_period(SEXP e) { + struct RollingVwap *h = (struct RollingVwap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rolling_vwap_warmup_period(h)); +} +SEXP wk_rolling_vwap_is_ready(SEXP e) { + struct RollingVwap *h = (struct RollingVwap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rolling_vwap_is_ready(h)); +} SEXP wk_rolling_vwap_reset(SEXP e) { struct RollingVwap *h = (struct RollingVwap *)R_ExternalPtrAddr(e); wickra_rolling_vwap_reset(h); @@ -11152,6 +13904,14 @@ SEXP wk_roofing_filter_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_roofing_filter_warmup_period(SEXP e) { + struct RoofingFilter *h = (struct RoofingFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_roofing_filter_warmup_period(h)); +} +SEXP wk_roofing_filter_is_ready(SEXP e) { + struct RoofingFilter *h = (struct RoofingFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_roofing_filter_is_ready(h)); +} SEXP wk_roofing_filter_reset(SEXP e) { struct RoofingFilter *h = (struct RoofingFilter *)R_ExternalPtrAddr(e); wickra_roofing_filter_reset(h); @@ -11183,6 +13943,14 @@ SEXP wk_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rsi_warmup_period(SEXP e) { + struct Rsi *h = (struct Rsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rsi_warmup_period(h)); +} +SEXP wk_rsi_is_ready(SEXP e) { + struct Rsi *h = (struct Rsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rsi_is_ready(h)); +} SEXP wk_rsi_reset(SEXP e) { struct Rsi *h = (struct Rsi *)R_ExternalPtrAddr(e); wickra_rsi_reset(h); @@ -11214,6 +13982,14 @@ SEXP wk_rsx_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rsx_warmup_period(SEXP e) { + struct Rsx *h = (struct Rsx *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rsx_warmup_period(h)); +} +SEXP wk_rsx_is_ready(SEXP e) { + struct Rsx *h = (struct Rsx *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rsx_is_ready(h)); +} SEXP wk_rsx_reset(SEXP e) { struct Rsx *h = (struct Rsx *)R_ExternalPtrAddr(e); wickra_rsx_reset(h); @@ -11292,6 +14068,14 @@ SEXP wk_rvi_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_rvi_warmup_period(SEXP e) { + struct Rvi *h = (struct Rvi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rvi_warmup_period(h)); +} +SEXP wk_rvi_is_ready(SEXP e) { + struct Rvi *h = (struct Rvi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rvi_is_ready(h)); +} SEXP wk_rvi_reset(SEXP e) { struct Rvi *h = (struct Rvi *)R_ExternalPtrAddr(e); wickra_rvi_reset(h); @@ -11323,6 +14107,14 @@ SEXP wk_rvi_volatility_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_rvi_volatility_warmup_period(SEXP e) { + struct RviVolatility *h = (struct RviVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rvi_volatility_warmup_period(h)); +} +SEXP wk_rvi_volatility_is_ready(SEXP e) { + struct RviVolatility *h = (struct RviVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rvi_volatility_is_ready(h)); +} SEXP wk_rvi_volatility_reset(SEXP e) { struct RviVolatility *h = (struct RviVolatility *)R_ExternalPtrAddr(e); wickra_rvi_volatility_reset(h); @@ -11356,6 +14148,14 @@ SEXP wk_rwi_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(2); return r; } +SEXP wk_rwi_warmup_period(SEXP e) { + struct Rwi *h = (struct Rwi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_rwi_warmup_period(h)); +} +SEXP wk_rwi_is_ready(SEXP e) { + struct Rwi *h = (struct Rwi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_rwi_is_ready(h)); +} SEXP wk_rwi_reset(SEXP e) { struct Rwi *h = (struct Rwi *)R_ExternalPtrAddr(e); wickra_rwi_reset(h); @@ -11387,6 +14187,14 @@ SEXP wk_sample_entropy_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sample_entropy_warmup_period(SEXP e) { + struct SampleEntropy *h = (struct SampleEntropy *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sample_entropy_warmup_period(h)); +} +SEXP wk_sample_entropy_is_ready(SEXP e) { + struct SampleEntropy *h = (struct SampleEntropy *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sample_entropy_is_ready(h)); +} SEXP wk_sample_entropy_reset(SEXP e) { struct SampleEntropy *h = (struct SampleEntropy *)R_ExternalPtrAddr(e); wickra_sample_entropy_reset(h); @@ -11420,6 +14228,14 @@ SEXP wk_sar_ext_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_sar_ext_warmup_period(SEXP e) { + struct SarExt *h = (struct SarExt *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sar_ext_warmup_period(h)); +} +SEXP wk_sar_ext_is_ready(SEXP e) { + struct SarExt *h = (struct SarExt *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sar_ext_is_ready(h)); +} SEXP wk_sar_ext_reset(SEXP e) { struct SarExt *h = (struct SarExt *)R_ExternalPtrAddr(e); wickra_sar_ext_reset(h); @@ -11453,6 +14269,14 @@ SEXP wk_seasonal_z_score_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_seasonal_z_score_warmup_period(SEXP e) { + struct SeasonalZScore *h = (struct SeasonalZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_seasonal_z_score_warmup_period(h)); +} +SEXP wk_seasonal_z_score_is_ready(SEXP e) { + struct SeasonalZScore *h = (struct SeasonalZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_seasonal_z_score_is_ready(h)); +} SEXP wk_seasonal_z_score_reset(SEXP e) { struct SeasonalZScore *h = (struct SeasonalZScore *)R_ExternalPtrAddr(e); wickra_seasonal_z_score_reset(h); @@ -11486,6 +14310,14 @@ SEXP wk_separating_lines_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_separating_lines_warmup_period(SEXP e) { + struct SeparatingLines *h = (struct SeparatingLines *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_separating_lines_warmup_period(h)); +} +SEXP wk_separating_lines_is_ready(SEXP e) { + struct SeparatingLines *h = (struct SeparatingLines *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_separating_lines_is_ready(h)); +} SEXP wk_separating_lines_reset(SEXP e) { struct SeparatingLines *h = (struct SeparatingLines *)R_ExternalPtrAddr(e); wickra_separating_lines_reset(h); @@ -11519,6 +14351,14 @@ SEXP wk_session_high_low_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_session_high_low_warmup_period(SEXP e) { + struct SessionHighLow *h = (struct SessionHighLow *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_session_high_low_warmup_period(h)); +} +SEXP wk_session_high_low_is_ready(SEXP e) { + struct SessionHighLow *h = (struct SessionHighLow *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_session_high_low_is_ready(h)); +} SEXP wk_session_high_low_reset(SEXP e) { struct SessionHighLow *h = (struct SessionHighLow *)R_ExternalPtrAddr(e); wickra_session_high_low_reset(h); @@ -11554,6 +14394,14 @@ SEXP wk_session_range_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_session_range_warmup_period(SEXP e) { + struct SessionRange *h = (struct SessionRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_session_range_warmup_period(h)); +} +SEXP wk_session_range_is_ready(SEXP e) { + struct SessionRange *h = (struct SessionRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_session_range_is_ready(h)); +} SEXP wk_session_range_reset(SEXP e) { struct SessionRange *h = (struct SessionRange *)R_ExternalPtrAddr(e); wickra_session_range_reset(h); @@ -11587,6 +14435,14 @@ SEXP wk_session_vwap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_session_vwap_warmup_period(SEXP e) { + struct SessionVwap *h = (struct SessionVwap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_session_vwap_warmup_period(h)); +} +SEXP wk_session_vwap_is_ready(SEXP e) { + struct SessionVwap *h = (struct SessionVwap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_session_vwap_is_ready(h)); +} SEXP wk_session_vwap_reset(SEXP e) { struct SessionVwap *h = (struct SessionVwap *)R_ExternalPtrAddr(e); wickra_session_vwap_reset(h); @@ -11618,6 +14474,14 @@ SEXP wk_shannon_entropy_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_shannon_entropy_warmup_period(SEXP e) { + struct ShannonEntropy *h = (struct ShannonEntropy *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_shannon_entropy_warmup_period(h)); +} +SEXP wk_shannon_entropy_is_ready(SEXP e) { + struct ShannonEntropy *h = (struct ShannonEntropy *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_shannon_entropy_is_ready(h)); +} SEXP wk_shannon_entropy_reset(SEXP e) { struct ShannonEntropy *h = (struct ShannonEntropy *)R_ExternalPtrAddr(e); wickra_shannon_entropy_reset(h); @@ -11651,6 +14515,14 @@ SEXP wk_shark_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5 UNPROTECT(1); return out; } +SEXP wk_shark_warmup_period(SEXP e) { + struct Shark *h = (struct Shark *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_shark_warmup_period(h)); +} +SEXP wk_shark_is_ready(SEXP e) { + struct Shark *h = (struct Shark *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_shark_is_ready(h)); +} SEXP wk_shark_reset(SEXP e) { struct Shark *h = (struct Shark *)R_ExternalPtrAddr(e); wickra_shark_reset(h); @@ -11682,6 +14554,14 @@ SEXP wk_sharpe_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sharpe_ratio_warmup_period(SEXP e) { + struct SharpeRatio *h = (struct SharpeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sharpe_ratio_warmup_period(h)); +} +SEXP wk_sharpe_ratio_is_ready(SEXP e) { + struct SharpeRatio *h = (struct SharpeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sharpe_ratio_is_ready(h)); +} SEXP wk_sharpe_ratio_reset(SEXP e) { struct SharpeRatio *h = (struct SharpeRatio *)R_ExternalPtrAddr(e); wickra_sharpe_ratio_reset(h); @@ -11715,6 +14595,14 @@ SEXP wk_shooting_star_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_shooting_star_warmup_period(SEXP e) { + struct ShootingStar *h = (struct ShootingStar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_shooting_star_warmup_period(h)); +} +SEXP wk_shooting_star_is_ready(SEXP e) { + struct ShootingStar *h = (struct ShootingStar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_shooting_star_is_ready(h)); +} SEXP wk_shooting_star_reset(SEXP e) { struct ShootingStar *h = (struct ShootingStar *)R_ExternalPtrAddr(e); wickra_shooting_star_reset(h); @@ -11748,6 +14636,14 @@ SEXP wk_short_line_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_short_line_warmup_period(SEXP e) { + struct ShortLine *h = (struct ShortLine *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_short_line_warmup_period(h)); +} +SEXP wk_short_line_is_ready(SEXP e) { + struct ShortLine *h = (struct ShortLine *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_short_line_is_ready(h)); +} SEXP wk_short_line_reset(SEXP e) { struct ShortLine *h = (struct ShortLine *)R_ExternalPtrAddr(e); wickra_short_line_reset(h); @@ -11771,6 +14667,14 @@ SEXP wk_signed_volume_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct SignedVolume *h = (struct SignedVolume *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_signed_volume_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_signed_volume_warmup_period(SEXP e) { + struct SignedVolume *h = (struct SignedVolume *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_signed_volume_warmup_period(h)); +} +SEXP wk_signed_volume_is_ready(SEXP e) { + struct SignedVolume *h = (struct SignedVolume *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_signed_volume_is_ready(h)); +} SEXP wk_signed_volume_reset(SEXP e) { struct SignedVolume *h = (struct SignedVolume *)R_ExternalPtrAddr(e); wickra_signed_volume_reset(h); @@ -11802,6 +14706,14 @@ SEXP wk_sine_wave_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sine_wave_warmup_period(SEXP e) { + struct SineWave *h = (struct SineWave *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sine_wave_warmup_period(h)); +} +SEXP wk_sine_wave_is_ready(SEXP e) { + struct SineWave *h = (struct SineWave *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sine_wave_is_ready(h)); +} SEXP wk_sine_wave_reset(SEXP e) { struct SineWave *h = (struct SineWave *)R_ExternalPtrAddr(e); wickra_sine_wave_reset(h); @@ -11833,6 +14745,14 @@ SEXP wk_sine_weighted_ma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sine_weighted_ma_warmup_period(SEXP e) { + struct SineWeightedMa *h = (struct SineWeightedMa *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sine_weighted_ma_warmup_period(h)); +} +SEXP wk_sine_weighted_ma_is_ready(SEXP e) { + struct SineWeightedMa *h = (struct SineWeightedMa *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sine_weighted_ma_is_ready(h)); +} SEXP wk_sine_weighted_ma_reset(SEXP e) { struct SineWeightedMa *h = (struct SineWeightedMa *)R_ExternalPtrAddr(e); wickra_sine_weighted_ma_reset(h); @@ -11866,6 +14786,14 @@ SEXP wk_single_prints_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_single_prints_warmup_period(SEXP e) { + struct SinglePrints *h = (struct SinglePrints *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_single_prints_warmup_period(h)); +} +SEXP wk_single_prints_is_ready(SEXP e) { + struct SinglePrints *h = (struct SinglePrints *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_single_prints_is_ready(h)); +} SEXP wk_single_prints_reset(SEXP e) { struct SinglePrints *h = (struct SinglePrints *)R_ExternalPtrAddr(e); wickra_single_prints_reset(h); @@ -11897,6 +14825,14 @@ SEXP wk_skewness_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_skewness_warmup_period(SEXP e) { + struct Skewness *h = (struct Skewness *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_skewness_warmup_period(h)); +} +SEXP wk_skewness_is_ready(SEXP e) { + struct Skewness *h = (struct Skewness *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_skewness_is_ready(h)); +} SEXP wk_skewness_reset(SEXP e) { struct Skewness *h = (struct Skewness *)R_ExternalPtrAddr(e); wickra_skewness_reset(h); @@ -11928,6 +14864,14 @@ SEXP wk_sma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sma_warmup_period(SEXP e) { + struct Sma *h = (struct Sma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sma_warmup_period(h)); +} +SEXP wk_sma_is_ready(SEXP e) { + struct Sma *h = (struct Sma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sma_is_ready(h)); +} SEXP wk_sma_reset(SEXP e) { struct Sma *h = (struct Sma *)R_ExternalPtrAddr(e); wickra_sma_reset(h); @@ -11961,6 +14905,14 @@ SEXP wk_smi_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_smi_warmup_period(SEXP e) { + struct Smi *h = (struct Smi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_smi_warmup_period(h)); +} +SEXP wk_smi_is_ready(SEXP e) { + struct Smi *h = (struct Smi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_smi_is_ready(h)); +} SEXP wk_smi_reset(SEXP e) { struct Smi *h = (struct Smi *)R_ExternalPtrAddr(e); wickra_smi_reset(h); @@ -11992,6 +14944,14 @@ SEXP wk_smma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_smma_warmup_period(SEXP e) { + struct Smma *h = (struct Smma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_smma_warmup_period(h)); +} +SEXP wk_smma_is_ready(SEXP e) { + struct Smma *h = (struct Smma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_smma_is_ready(h)); +} SEXP wk_smma_reset(SEXP e) { struct Smma *h = (struct Smma *)R_ExternalPtrAddr(e); wickra_smma_reset(h); @@ -12029,6 +14989,14 @@ SEXP wk_smoothed_heikin_ashi_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(2); return r; } +SEXP wk_smoothed_heikin_ashi_warmup_period(SEXP e) { + struct SmoothedHeikinAshi *h = (struct SmoothedHeikinAshi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_smoothed_heikin_ashi_warmup_period(h)); +} +SEXP wk_smoothed_heikin_ashi_is_ready(SEXP e) { + struct SmoothedHeikinAshi *h = (struct SmoothedHeikinAshi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_smoothed_heikin_ashi_is_ready(h)); +} SEXP wk_smoothed_heikin_ashi_reset(SEXP e) { struct SmoothedHeikinAshi *h = (struct SmoothedHeikinAshi *)R_ExternalPtrAddr(e); wickra_smoothed_heikin_ashi_reset(h); @@ -12060,6 +15028,14 @@ SEXP wk_sortino_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sortino_ratio_warmup_period(SEXP e) { + struct SortinoRatio *h = (struct SortinoRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sortino_ratio_warmup_period(h)); +} +SEXP wk_sortino_ratio_is_ready(SEXP e) { + struct SortinoRatio *h = (struct SortinoRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sortino_ratio_is_ready(h)); +} SEXP wk_sortino_ratio_reset(SEXP e) { struct SortinoRatio *h = (struct SortinoRatio *)R_ExternalPtrAddr(e); wickra_sortino_ratio_reset(h); @@ -12091,6 +15067,14 @@ SEXP wk_spearman_correlation_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_spearman_correlation_warmup_period(SEXP e) { + struct SpearmanCorrelation *h = (struct SpearmanCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_spearman_correlation_warmup_period(h)); +} +SEXP wk_spearman_correlation_is_ready(SEXP e) { + struct SpearmanCorrelation *h = (struct SpearmanCorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_spearman_correlation_is_ready(h)); +} SEXP wk_spearman_correlation_reset(SEXP e) { struct SpearmanCorrelation *h = (struct SpearmanCorrelation *)R_ExternalPtrAddr(e); wickra_spearman_correlation_reset(h); @@ -12124,6 +15108,14 @@ SEXP wk_spinning_top_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_spinning_top_warmup_period(SEXP e) { + struct SpinningTop *h = (struct SpinningTop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_spinning_top_warmup_period(h)); +} +SEXP wk_spinning_top_is_ready(SEXP e) { + struct SpinningTop *h = (struct SpinningTop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_spinning_top_is_ready(h)); +} SEXP wk_spinning_top_reset(SEXP e) { struct SpinningTop *h = (struct SpinningTop *)R_ExternalPtrAddr(e); wickra_spinning_top_reset(h); @@ -12155,6 +15147,14 @@ SEXP wk_spread_ar1_coefficient_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_spread_ar1_coefficient_warmup_period(SEXP e) { + struct SpreadAr1Coefficient *h = (struct SpreadAr1Coefficient *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_spread_ar1_coefficient_warmup_period(h)); +} +SEXP wk_spread_ar1_coefficient_is_ready(SEXP e) { + struct SpreadAr1Coefficient *h = (struct SpreadAr1Coefficient *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_spread_ar1_coefficient_is_ready(h)); +} SEXP wk_spread_ar1_coefficient_reset(SEXP e) { struct SpreadAr1Coefficient *h = (struct SpreadAr1Coefficient *)R_ExternalPtrAddr(e); wickra_spread_ar1_coefficient_reset(h); @@ -12192,6 +15192,14 @@ SEXP wk_spread_bollinger_bands_update(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(2); return r; } +SEXP wk_spread_bollinger_bands_warmup_period(SEXP e) { + struct SpreadBollingerBands *h = (struct SpreadBollingerBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_spread_bollinger_bands_warmup_period(h)); +} +SEXP wk_spread_bollinger_bands_is_ready(SEXP e) { + struct SpreadBollingerBands *h = (struct SpreadBollingerBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_spread_bollinger_bands_is_ready(h)); +} SEXP wk_spread_bollinger_bands_reset(SEXP e) { struct SpreadBollingerBands *h = (struct SpreadBollingerBands *)R_ExternalPtrAddr(e); wickra_spread_bollinger_bands_reset(h); @@ -12223,6 +15231,14 @@ SEXP wk_spread_hurst_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_spread_hurst_warmup_period(SEXP e) { + struct SpreadHurst *h = (struct SpreadHurst *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_spread_hurst_warmup_period(h)); +} +SEXP wk_spread_hurst_is_ready(SEXP e) { + struct SpreadHurst *h = (struct SpreadHurst *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_spread_hurst_is_ready(h)); +} SEXP wk_spread_hurst_reset(SEXP e) { struct SpreadHurst *h = (struct SpreadHurst *)R_ExternalPtrAddr(e); wickra_spread_hurst_reset(h); @@ -12256,6 +15272,14 @@ SEXP wk_stalled_pattern_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_stalled_pattern_warmup_period(SEXP e) { + struct StalledPattern *h = (struct StalledPattern *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_stalled_pattern_warmup_period(h)); +} +SEXP wk_stalled_pattern_is_ready(SEXP e) { + struct StalledPattern *h = (struct StalledPattern *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_stalled_pattern_is_ready(h)); +} SEXP wk_stalled_pattern_reset(SEXP e) { struct StalledPattern *h = (struct StalledPattern *)R_ExternalPtrAddr(e); wickra_stalled_pattern_reset(h); @@ -12287,6 +15311,14 @@ SEXP wk_standard_error_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_standard_error_warmup_period(SEXP e) { + struct StandardError *h = (struct StandardError *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_standard_error_warmup_period(h)); +} +SEXP wk_standard_error_is_ready(SEXP e) { + struct StandardError *h = (struct StandardError *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_standard_error_is_ready(h)); +} SEXP wk_standard_error_reset(SEXP e) { struct StandardError *h = (struct StandardError *)R_ExternalPtrAddr(e); wickra_standard_error_reset(h); @@ -12322,6 +15354,14 @@ SEXP wk_standard_error_bands_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_standard_error_bands_warmup_period(SEXP e) { + struct StandardErrorBands *h = (struct StandardErrorBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_standard_error_bands_warmup_period(h)); +} +SEXP wk_standard_error_bands_is_ready(SEXP e) { + struct StandardErrorBands *h = (struct StandardErrorBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_standard_error_bands_is_ready(h)); +} SEXP wk_standard_error_bands_reset(SEXP e) { struct StandardErrorBands *h = (struct StandardErrorBands *)R_ExternalPtrAddr(e); wickra_standard_error_bands_reset(h); @@ -12357,6 +15397,14 @@ SEXP wk_starc_bands_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(2); return r; } +SEXP wk_starc_bands_warmup_period(SEXP e) { + struct StarcBands *h = (struct StarcBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_starc_bands_warmup_period(h)); +} +SEXP wk_starc_bands_is_ready(SEXP e) { + struct StarcBands *h = (struct StarcBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_starc_bands_is_ready(h)); +} SEXP wk_starc_bands_reset(SEXP e) { struct StarcBands *h = (struct StarcBands *)R_ExternalPtrAddr(e); wickra_starc_bands_reset(h); @@ -12388,6 +15436,14 @@ SEXP wk_stc_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_stc_warmup_period(SEXP e) { + struct Stc *h = (struct Stc *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_stc_warmup_period(h)); +} +SEXP wk_stc_is_ready(SEXP e) { + struct Stc *h = (struct Stc *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_stc_is_ready(h)); +} SEXP wk_stc_reset(SEXP e) { struct Stc *h = (struct Stc *)R_ExternalPtrAddr(e); wickra_stc_reset(h); @@ -12419,6 +15475,14 @@ SEXP wk_std_dev_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_std_dev_warmup_period(SEXP e) { + struct StdDev *h = (struct StdDev *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_std_dev_warmup_period(h)); +} +SEXP wk_std_dev_is_ready(SEXP e) { + struct StdDev *h = (struct StdDev *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_std_dev_is_ready(h)); +} SEXP wk_std_dev_reset(SEXP e) { struct StdDev *h = (struct StdDev *)R_ExternalPtrAddr(e); wickra_std_dev_reset(h); @@ -12450,6 +15514,14 @@ SEXP wk_step_trailing_stop_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_step_trailing_stop_warmup_period(SEXP e) { + struct StepTrailingStop *h = (struct StepTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_step_trailing_stop_warmup_period(h)); +} +SEXP wk_step_trailing_stop_is_ready(SEXP e) { + struct StepTrailingStop *h = (struct StepTrailingStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_step_trailing_stop_is_ready(h)); +} SEXP wk_step_trailing_stop_reset(SEXP e) { struct StepTrailingStop *h = (struct StepTrailingStop *)R_ExternalPtrAddr(e); wickra_step_trailing_stop_reset(h); @@ -12481,6 +15553,14 @@ SEXP wk_sterling_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_sterling_ratio_warmup_period(SEXP e) { + struct SterlingRatio *h = (struct SterlingRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_sterling_ratio_warmup_period(h)); +} +SEXP wk_sterling_ratio_is_ready(SEXP e) { + struct SterlingRatio *h = (struct SterlingRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_sterling_ratio_is_ready(h)); +} SEXP wk_sterling_ratio_reset(SEXP e) { struct SterlingRatio *h = (struct SterlingRatio *)R_ExternalPtrAddr(e); wickra_sterling_ratio_reset(h); @@ -12514,6 +15594,14 @@ SEXP wk_stick_sandwich_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_stick_sandwich_warmup_period(SEXP e) { + struct StickSandwich *h = (struct StickSandwich *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_stick_sandwich_warmup_period(h)); +} +SEXP wk_stick_sandwich_is_ready(SEXP e) { + struct StickSandwich *h = (struct StickSandwich *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_stick_sandwich_is_ready(h)); +} SEXP wk_stick_sandwich_reset(SEXP e) { struct StickSandwich *h = (struct StickSandwich *)R_ExternalPtrAddr(e); wickra_stick_sandwich_reset(h); @@ -12545,6 +15633,14 @@ SEXP wk_stoch_rsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_stoch_rsi_warmup_period(SEXP e) { + struct StochRsi *h = (struct StochRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_stoch_rsi_warmup_period(h)); +} +SEXP wk_stoch_rsi_is_ready(SEXP e) { + struct StochRsi *h = (struct StochRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_stoch_rsi_is_ready(h)); +} SEXP wk_stoch_rsi_reset(SEXP e) { struct StochRsi *h = (struct StochRsi *)R_ExternalPtrAddr(e); wickra_stoch_rsi_reset(h); @@ -12578,6 +15674,14 @@ SEXP wk_stochastic_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(2); return r; } +SEXP wk_stochastic_warmup_period(SEXP e) { + struct Stochastic *h = (struct Stochastic *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_stochastic_warmup_period(h)); +} +SEXP wk_stochastic_is_ready(SEXP e) { + struct Stochastic *h = (struct Stochastic *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_stochastic_is_ready(h)); +} SEXP wk_stochastic_reset(SEXP e) { struct Stochastic *h = (struct Stochastic *)R_ExternalPtrAddr(e); wickra_stochastic_reset(h); @@ -12611,6 +15715,14 @@ SEXP wk_stochastic_cci_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_stochastic_cci_warmup_period(SEXP e) { + struct StochasticCci *h = (struct StochasticCci *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_stochastic_cci_warmup_period(h)); +} +SEXP wk_stochastic_cci_is_ready(SEXP e) { + struct StochasticCci *h = (struct StochasticCci *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_stochastic_cci_is_ready(h)); +} SEXP wk_stochastic_cci_reset(SEXP e) { struct StochasticCci *h = (struct StochasticCci *)R_ExternalPtrAddr(e); wickra_stochastic_cci_reset(h); @@ -12642,6 +15754,14 @@ SEXP wk_super_smoother_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_super_smoother_warmup_period(SEXP e) { + struct SuperSmoother *h = (struct SuperSmoother *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_super_smoother_warmup_period(h)); +} +SEXP wk_super_smoother_is_ready(SEXP e) { + struct SuperSmoother *h = (struct SuperSmoother *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_super_smoother_is_ready(h)); +} SEXP wk_super_smoother_reset(SEXP e) { struct SuperSmoother *h = (struct SuperSmoother *)R_ExternalPtrAddr(e); wickra_super_smoother_reset(h); @@ -12675,6 +15795,14 @@ SEXP wk_super_trend_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(2); return r; } +SEXP wk_super_trend_warmup_period(SEXP e) { + struct SuperTrend *h = (struct SuperTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_super_trend_warmup_period(h)); +} +SEXP wk_super_trend_is_ready(SEXP e) { + struct SuperTrend *h = (struct SuperTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_super_trend_is_ready(h)); +} SEXP wk_super_trend_reset(SEXP e) { struct SuperTrend *h = (struct SuperTrend *)R_ExternalPtrAddr(e); wickra_super_trend_reset(h); @@ -12706,6 +15834,14 @@ SEXP wk_t3_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_t3_warmup_period(SEXP e) { + struct T3 *h = (struct T3 *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_t3_warmup_period(h)); +} +SEXP wk_t3_is_ready(SEXP e) { + struct T3 *h = (struct T3 *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_t3_is_ready(h)); +} SEXP wk_t3_reset(SEXP e) { struct T3 *h = (struct T3 *)R_ExternalPtrAddr(e); wickra_t3_reset(h); @@ -12737,6 +15873,14 @@ SEXP wk_tail_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_tail_ratio_warmup_period(SEXP e) { + struct TailRatio *h = (struct TailRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tail_ratio_warmup_period(h)); +} +SEXP wk_tail_ratio_is_ready(SEXP e) { + struct TailRatio *h = (struct TailRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tail_ratio_is_ready(h)); +} SEXP wk_tail_ratio_reset(SEXP e) { struct TailRatio *h = (struct TailRatio *)R_ExternalPtrAddr(e); wickra_tail_ratio_reset(h); @@ -12760,6 +15904,14 @@ SEXP wk_taker_buy_sell_ratio_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct TakerBuySellRatio *h = (struct TakerBuySellRatio *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_taker_buy_sell_ratio_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_taker_buy_sell_ratio_warmup_period(SEXP e) { + struct TakerBuySellRatio *h = (struct TakerBuySellRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_taker_buy_sell_ratio_warmup_period(h)); +} +SEXP wk_taker_buy_sell_ratio_is_ready(SEXP e) { + struct TakerBuySellRatio *h = (struct TakerBuySellRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_taker_buy_sell_ratio_is_ready(h)); +} SEXP wk_taker_buy_sell_ratio_reset(SEXP e) { struct TakerBuySellRatio *h = (struct TakerBuySellRatio *)R_ExternalPtrAddr(e); wickra_taker_buy_sell_ratio_reset(h); @@ -12793,6 +15945,14 @@ SEXP wk_takuri_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(1); return out; } +SEXP wk_takuri_warmup_period(SEXP e) { + struct Takuri *h = (struct Takuri *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_takuri_warmup_period(h)); +} +SEXP wk_takuri_is_ready(SEXP e) { + struct Takuri *h = (struct Takuri *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_takuri_is_ready(h)); +} SEXP wk_takuri_reset(SEXP e) { struct Takuri *h = (struct Takuri *)R_ExternalPtrAddr(e); wickra_takuri_reset(h); @@ -12826,6 +15986,14 @@ SEXP wk_tasuki_gap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_tasuki_gap_warmup_period(SEXP e) { + struct TasukiGap *h = (struct TasukiGap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tasuki_gap_warmup_period(h)); +} +SEXP wk_tasuki_gap_is_ready(SEXP e) { + struct TasukiGap *h = (struct TasukiGap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tasuki_gap_is_ready(h)); +} SEXP wk_tasuki_gap_reset(SEXP e) { struct TasukiGap *h = (struct TasukiGap *)R_ExternalPtrAddr(e); wickra_tasuki_gap_reset(h); @@ -12859,6 +16027,14 @@ SEXP wk_td_camouflage_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_td_camouflage_warmup_period(SEXP e) { + struct TdCamouflage *h = (struct TdCamouflage *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_camouflage_warmup_period(h)); +} +SEXP wk_td_camouflage_is_ready(SEXP e) { + struct TdCamouflage *h = (struct TdCamouflage *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_camouflage_is_ready(h)); +} SEXP wk_td_camouflage_reset(SEXP e) { struct TdCamouflage *h = (struct TdCamouflage *)R_ExternalPtrAddr(e); wickra_td_camouflage_reset(h); @@ -12892,6 +16068,14 @@ SEXP wk_td_clop_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_td_clop_warmup_period(SEXP e) { + struct TdClop *h = (struct TdClop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_clop_warmup_period(h)); +} +SEXP wk_td_clop_is_ready(SEXP e) { + struct TdClop *h = (struct TdClop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_clop_is_ready(h)); +} SEXP wk_td_clop_reset(SEXP e) { struct TdClop *h = (struct TdClop *)R_ExternalPtrAddr(e); wickra_td_clop_reset(h); @@ -12925,6 +16109,14 @@ SEXP wk_td_clopwin_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_td_clopwin_warmup_period(SEXP e) { + struct TdClopwin *h = (struct TdClopwin *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_clopwin_warmup_period(h)); +} +SEXP wk_td_clopwin_is_ready(SEXP e) { + struct TdClopwin *h = (struct TdClopwin *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_clopwin_is_ready(h)); +} SEXP wk_td_clopwin_reset(SEXP e) { struct TdClopwin *h = (struct TdClopwin *)R_ExternalPtrAddr(e); wickra_td_clopwin_reset(h); @@ -12958,6 +16150,14 @@ SEXP wk_td_combo_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_td_combo_warmup_period(SEXP e) { + struct TdCombo *h = (struct TdCombo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_combo_warmup_period(h)); +} +SEXP wk_td_combo_is_ready(SEXP e) { + struct TdCombo *h = (struct TdCombo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_combo_is_ready(h)); +} SEXP wk_td_combo_reset(SEXP e) { struct TdCombo *h = (struct TdCombo *)R_ExternalPtrAddr(e); wickra_td_combo_reset(h); @@ -12991,6 +16191,14 @@ SEXP wk_td_countdown_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_td_countdown_warmup_period(SEXP e) { + struct TdCountdown *h = (struct TdCountdown *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_countdown_warmup_period(h)); +} +SEXP wk_td_countdown_is_ready(SEXP e) { + struct TdCountdown *h = (struct TdCountdown *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_countdown_is_ready(h)); +} SEXP wk_td_countdown_reset(SEXP e) { struct TdCountdown *h = (struct TdCountdown *)R_ExternalPtrAddr(e); wickra_td_countdown_reset(h); @@ -13024,6 +16232,14 @@ SEXP wk_td_d_wave_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_td_d_wave_warmup_period(SEXP e) { + struct TdDWave *h = (struct TdDWave *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_d_wave_warmup_period(h)); +} +SEXP wk_td_d_wave_is_ready(SEXP e) { + struct TdDWave *h = (struct TdDWave *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_d_wave_is_ready(h)); +} SEXP wk_td_d_wave_reset(SEXP e) { struct TdDWave *h = (struct TdDWave *)R_ExternalPtrAddr(e); wickra_td_d_wave_reset(h); @@ -13057,6 +16273,14 @@ SEXP wk_td_de_marker_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_td_de_marker_warmup_period(SEXP e) { + struct TdDeMarker *h = (struct TdDeMarker *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_de_marker_warmup_period(h)); +} +SEXP wk_td_de_marker_is_ready(SEXP e) { + struct TdDeMarker *h = (struct TdDeMarker *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_de_marker_is_ready(h)); +} SEXP wk_td_de_marker_reset(SEXP e) { struct TdDeMarker *h = (struct TdDeMarker *)R_ExternalPtrAddr(e); wickra_td_de_marker_reset(h); @@ -13090,6 +16314,14 @@ SEXP wk_td_differential_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_td_differential_warmup_period(SEXP e) { + struct TdDifferential *h = (struct TdDifferential *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_differential_warmup_period(h)); +} +SEXP wk_td_differential_is_ready(SEXP e) { + struct TdDifferential *h = (struct TdDifferential *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_differential_is_ready(h)); +} SEXP wk_td_differential_reset(SEXP e) { struct TdDifferential *h = (struct TdDifferential *)R_ExternalPtrAddr(e); wickra_td_differential_reset(h); @@ -13123,6 +16355,14 @@ SEXP wk_td_lines_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(2); return r; } +SEXP wk_td_lines_warmup_period(SEXP e) { + struct TdLines *h = (struct TdLines *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_lines_warmup_period(h)); +} +SEXP wk_td_lines_is_ready(SEXP e) { + struct TdLines *h = (struct TdLines *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_lines_is_ready(h)); +} SEXP wk_td_lines_reset(SEXP e) { struct TdLines *h = (struct TdLines *)R_ExternalPtrAddr(e); wickra_td_lines_reset(h); @@ -13156,6 +16396,14 @@ SEXP wk_td_moving_average_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(2); return r; } +SEXP wk_td_moving_average_warmup_period(SEXP e) { + struct TdMovingAverage *h = (struct TdMovingAverage *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_moving_average_warmup_period(h)); +} +SEXP wk_td_moving_average_is_ready(SEXP e) { + struct TdMovingAverage *h = (struct TdMovingAverage *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_moving_average_is_ready(h)); +} SEXP wk_td_moving_average_reset(SEXP e) { struct TdMovingAverage *h = (struct TdMovingAverage *)R_ExternalPtrAddr(e); wickra_td_moving_average_reset(h); @@ -13189,6 +16437,14 @@ SEXP wk_td_open_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_td_open_warmup_period(SEXP e) { + struct TdOpen *h = (struct TdOpen *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_open_warmup_period(h)); +} +SEXP wk_td_open_is_ready(SEXP e) { + struct TdOpen *h = (struct TdOpen *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_open_is_ready(h)); +} SEXP wk_td_open_reset(SEXP e) { struct TdOpen *h = (struct TdOpen *)R_ExternalPtrAddr(e); wickra_td_open_reset(h); @@ -13222,6 +16478,14 @@ SEXP wk_td_pressure_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(1); return out; } +SEXP wk_td_pressure_warmup_period(SEXP e) { + struct TdPressure *h = (struct TdPressure *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_pressure_warmup_period(h)); +} +SEXP wk_td_pressure_is_ready(SEXP e) { + struct TdPressure *h = (struct TdPressure *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_pressure_is_ready(h)); +} SEXP wk_td_pressure_reset(SEXP e) { struct TdPressure *h = (struct TdPressure *)R_ExternalPtrAddr(e); wickra_td_pressure_reset(h); @@ -13255,6 +16519,14 @@ SEXP wk_td_propulsion_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_td_propulsion_warmup_period(SEXP e) { + struct TdPropulsion *h = (struct TdPropulsion *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_propulsion_warmup_period(h)); +} +SEXP wk_td_propulsion_is_ready(SEXP e) { + struct TdPropulsion *h = (struct TdPropulsion *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_propulsion_is_ready(h)); +} SEXP wk_td_propulsion_reset(SEXP e) { struct TdPropulsion *h = (struct TdPropulsion *)R_ExternalPtrAddr(e); wickra_td_propulsion_reset(h); @@ -13288,6 +16560,14 @@ SEXP wk_td_range_projection_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(2); return r; } +SEXP wk_td_range_projection_warmup_period(SEXP e) { + struct TdRangeProjection *h = (struct TdRangeProjection *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_range_projection_warmup_period(h)); +} +SEXP wk_td_range_projection_is_ready(SEXP e) { + struct TdRangeProjection *h = (struct TdRangeProjection *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_range_projection_is_ready(h)); +} SEXP wk_td_range_projection_reset(SEXP e) { struct TdRangeProjection *h = (struct TdRangeProjection *)R_ExternalPtrAddr(e); wickra_td_range_projection_reset(h); @@ -13321,6 +16601,14 @@ SEXP wk_td_rei_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a UNPROTECT(1); return out; } +SEXP wk_td_rei_warmup_period(SEXP e) { + struct TdRei *h = (struct TdRei *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_rei_warmup_period(h)); +} +SEXP wk_td_rei_is_ready(SEXP e) { + struct TdRei *h = (struct TdRei *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_rei_is_ready(h)); +} SEXP wk_td_rei_reset(SEXP e) { struct TdRei *h = (struct TdRei *)R_ExternalPtrAddr(e); wickra_td_rei_reset(h); @@ -13354,6 +16642,14 @@ SEXP wk_td_risk_level_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_td_risk_level_warmup_period(SEXP e) { + struct TdRiskLevel *h = (struct TdRiskLevel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_risk_level_warmup_period(h)); +} +SEXP wk_td_risk_level_is_ready(SEXP e) { + struct TdRiskLevel *h = (struct TdRiskLevel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_risk_level_is_ready(h)); +} SEXP wk_td_risk_level_reset(SEXP e) { struct TdRiskLevel *h = (struct TdRiskLevel *)R_ExternalPtrAddr(e); wickra_td_risk_level_reset(h); @@ -13389,6 +16685,14 @@ SEXP wk_td_sequential_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_td_sequential_warmup_period(SEXP e) { + struct TdSequential *h = (struct TdSequential *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_sequential_warmup_period(h)); +} +SEXP wk_td_sequential_is_ready(SEXP e) { + struct TdSequential *h = (struct TdSequential *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_sequential_is_ready(h)); +} SEXP wk_td_sequential_reset(SEXP e) { struct TdSequential *h = (struct TdSequential *)R_ExternalPtrAddr(e); wickra_td_sequential_reset(h); @@ -13422,6 +16726,14 @@ SEXP wk_td_setup_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_td_setup_warmup_period(SEXP e) { + struct TdSetup *h = (struct TdSetup *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_setup_warmup_period(h)); +} +SEXP wk_td_setup_is_ready(SEXP e) { + struct TdSetup *h = (struct TdSetup *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_setup_is_ready(h)); +} SEXP wk_td_setup_reset(SEXP e) { struct TdSetup *h = (struct TdSetup *)R_ExternalPtrAddr(e); wickra_td_setup_reset(h); @@ -13455,6 +16767,14 @@ SEXP wk_td_trap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_td_trap_warmup_period(SEXP e) { + struct TdTrap *h = (struct TdTrap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_td_trap_warmup_period(h)); +} +SEXP wk_td_trap_is_ready(SEXP e) { + struct TdTrap *h = (struct TdTrap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_td_trap_is_ready(h)); +} SEXP wk_td_trap_reset(SEXP e) { struct TdTrap *h = (struct TdTrap *)R_ExternalPtrAddr(e); wickra_td_trap_reset(h); @@ -13486,6 +16806,14 @@ SEXP wk_tema_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_tema_warmup_period(SEXP e) { + struct Tema *h = (struct Tema *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tema_warmup_period(h)); +} +SEXP wk_tema_is_ready(SEXP e) { + struct Tema *h = (struct Tema *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tema_is_ready(h)); +} SEXP wk_tema_reset(SEXP e) { struct Tema *h = (struct Tema *)R_ExternalPtrAddr(e); wickra_tema_reset(h); @@ -13509,6 +16837,14 @@ SEXP wk_term_structure_basis_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct TermStructureBasis *h = (struct TermStructureBasis *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_term_structure_basis_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), Rf_asReal(a5), Rf_asReal(a6), Rf_asReal(a7), Rf_asReal(a8), Rf_asReal(a9), Rf_asReal(a10), (int64_t)Rf_asReal(a11))); } +SEXP wk_term_structure_basis_warmup_period(SEXP e) { + struct TermStructureBasis *h = (struct TermStructureBasis *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_term_structure_basis_warmup_period(h)); +} +SEXP wk_term_structure_basis_is_ready(SEXP e) { + struct TermStructureBasis *h = (struct TermStructureBasis *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_term_structure_basis_is_ready(h)); +} SEXP wk_term_structure_basis_reset(SEXP e) { struct TermStructureBasis *h = (struct TermStructureBasis *)R_ExternalPtrAddr(e); wickra_term_structure_basis_reset(h); @@ -13542,6 +16878,14 @@ SEXP wk_three_drives_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_three_drives_warmup_period(SEXP e) { + struct ThreeDrives *h = (struct ThreeDrives *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_drives_warmup_period(h)); +} +SEXP wk_three_drives_is_ready(SEXP e) { + struct ThreeDrives *h = (struct ThreeDrives *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_drives_is_ready(h)); +} SEXP wk_three_drives_reset(SEXP e) { struct ThreeDrives *h = (struct ThreeDrives *)R_ExternalPtrAddr(e); wickra_three_drives_reset(h); @@ -13575,6 +16919,14 @@ SEXP wk_three_inside_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_three_inside_warmup_period(SEXP e) { + struct ThreeInside *h = (struct ThreeInside *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_inside_warmup_period(h)); +} +SEXP wk_three_inside_is_ready(SEXP e) { + struct ThreeInside *h = (struct ThreeInside *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_inside_is_ready(h)); +} SEXP wk_three_inside_reset(SEXP e) { struct ThreeInside *h = (struct ThreeInside *)R_ExternalPtrAddr(e); wickra_three_inside_reset(h); @@ -13608,6 +16960,14 @@ SEXP wk_three_line_break_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_three_line_break_warmup_period(SEXP e) { + struct ThreeLineBreak *h = (struct ThreeLineBreak *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_line_break_warmup_period(h)); +} +SEXP wk_three_line_break_is_ready(SEXP e) { + struct ThreeLineBreak *h = (struct ThreeLineBreak *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_line_break_is_ready(h)); +} SEXP wk_three_line_break_reset(SEXP e) { struct ThreeLineBreak *h = (struct ThreeLineBreak *)R_ExternalPtrAddr(e); wickra_three_line_break_reset(h); @@ -13680,6 +17040,14 @@ SEXP wk_three_line_strike_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_three_line_strike_warmup_period(SEXP e) { + struct ThreeLineStrike *h = (struct ThreeLineStrike *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_line_strike_warmup_period(h)); +} +SEXP wk_three_line_strike_is_ready(SEXP e) { + struct ThreeLineStrike *h = (struct ThreeLineStrike *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_line_strike_is_ready(h)); +} SEXP wk_three_line_strike_reset(SEXP e) { struct ThreeLineStrike *h = (struct ThreeLineStrike *)R_ExternalPtrAddr(e); wickra_three_line_strike_reset(h); @@ -13713,6 +17081,14 @@ SEXP wk_three_outside_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_three_outside_warmup_period(SEXP e) { + struct ThreeOutside *h = (struct ThreeOutside *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_outside_warmup_period(h)); +} +SEXP wk_three_outside_is_ready(SEXP e) { + struct ThreeOutside *h = (struct ThreeOutside *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_outside_is_ready(h)); +} SEXP wk_three_outside_reset(SEXP e) { struct ThreeOutside *h = (struct ThreeOutside *)R_ExternalPtrAddr(e); wickra_three_outside_reset(h); @@ -13746,6 +17122,14 @@ SEXP wk_three_soldiers_or_crows_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 UNPROTECT(1); return out; } +SEXP wk_three_soldiers_or_crows_warmup_period(SEXP e) { + struct ThreeSoldiersOrCrows *h = (struct ThreeSoldiersOrCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_soldiers_or_crows_warmup_period(h)); +} +SEXP wk_three_soldiers_or_crows_is_ready(SEXP e) { + struct ThreeSoldiersOrCrows *h = (struct ThreeSoldiersOrCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_soldiers_or_crows_is_ready(h)); +} SEXP wk_three_soldiers_or_crows_reset(SEXP e) { struct ThreeSoldiersOrCrows *h = (struct ThreeSoldiersOrCrows *)R_ExternalPtrAddr(e); wickra_three_soldiers_or_crows_reset(h); @@ -13779,6 +17163,14 @@ SEXP wk_three_stars_in_south_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(1); return out; } +SEXP wk_three_stars_in_south_warmup_period(SEXP e) { + struct ThreeStarsInSouth *h = (struct ThreeStarsInSouth *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_three_stars_in_south_warmup_period(h)); +} +SEXP wk_three_stars_in_south_is_ready(SEXP e) { + struct ThreeStarsInSouth *h = (struct ThreeStarsInSouth *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_three_stars_in_south_is_ready(h)); +} SEXP wk_three_stars_in_south_reset(SEXP e) { struct ThreeStarsInSouth *h = (struct ThreeStarsInSouth *)R_ExternalPtrAddr(e); wickra_three_stars_in_south_reset(h); @@ -13812,6 +17204,14 @@ SEXP wk_thrusting_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_thrusting_warmup_period(SEXP e) { + struct Thrusting *h = (struct Thrusting *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_thrusting_warmup_period(h)); +} +SEXP wk_thrusting_is_ready(SEXP e) { + struct Thrusting *h = (struct Thrusting *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_thrusting_is_ready(h)); +} SEXP wk_thrusting_reset(SEXP e) { struct Thrusting *h = (struct Thrusting *)R_ExternalPtrAddr(e); wickra_thrusting_reset(h); @@ -13878,6 +17278,14 @@ SEXP wk_tick_index_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S struct TickIndex *h = (struct TickIndex *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_tick_index_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_tick_index_warmup_period(SEXP e) { + struct TickIndex *h = (struct TickIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tick_index_warmup_period(h)); +} +SEXP wk_tick_index_is_ready(SEXP e) { + struct TickIndex *h = (struct TickIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tick_index_is_ready(h)); +} SEXP wk_tick_index_reset(SEXP e) { struct TickIndex *h = (struct TickIndex *)R_ExternalPtrAddr(e); wickra_tick_index_reset(h); @@ -13909,6 +17317,14 @@ SEXP wk_tii_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_tii_warmup_period(SEXP e) { + struct Tii *h = (struct Tii *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tii_warmup_period(h)); +} +SEXP wk_tii_is_ready(SEXP e) { + struct Tii *h = (struct Tii *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tii_is_ready(h)); +} SEXP wk_tii_reset(SEXP e) { struct Tii *h = (struct Tii *)R_ExternalPtrAddr(e); wickra_tii_reset(h); @@ -13942,6 +17358,14 @@ SEXP wk_time_based_stop_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(1); return out; } +SEXP wk_time_based_stop_warmup_period(SEXP e) { + struct TimeBasedStop *h = (struct TimeBasedStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_time_based_stop_warmup_period(h)); +} +SEXP wk_time_based_stop_is_ready(SEXP e) { + struct TimeBasedStop *h = (struct TimeBasedStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_time_based_stop_is_ready(h)); +} SEXP wk_time_based_stop_reset(SEXP e) { struct TimeBasedStop *h = (struct TimeBasedStop *)R_ExternalPtrAddr(e); wickra_time_based_stop_reset(h); @@ -13972,6 +17396,14 @@ SEXP wk_time_of_day_return_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEX UNPROTECT(2); return vv; } +SEXP wk_time_of_day_return_profile_warmup_period(SEXP e) { + struct TimeOfDayReturnProfile *h = (struct TimeOfDayReturnProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_time_of_day_return_profile_warmup_period(h)); +} +SEXP wk_time_of_day_return_profile_is_ready(SEXP e) { + struct TimeOfDayReturnProfile *h = (struct TimeOfDayReturnProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_time_of_day_return_profile_is_ready(h)); +} SEXP wk_time_of_day_return_profile_reset(SEXP e) { struct TimeOfDayReturnProfile *h = (struct TimeOfDayReturnProfile *)R_ExternalPtrAddr(e); wickra_time_of_day_return_profile_reset(h); @@ -14005,6 +17437,14 @@ SEXP wk_tower_top_bottom_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_tower_top_bottom_warmup_period(SEXP e) { + struct TowerTopBottom *h = (struct TowerTopBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tower_top_bottom_warmup_period(h)); +} +SEXP wk_tower_top_bottom_is_ready(SEXP e) { + struct TowerTopBottom *h = (struct TowerTopBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tower_top_bottom_is_ready(h)); +} SEXP wk_tower_top_bottom_reset(SEXP e) { struct TowerTopBottom *h = (struct TowerTopBottom *)R_ExternalPtrAddr(e); wickra_tower_top_bottom_reset(h); @@ -14045,6 +17485,14 @@ SEXP wk_tpo_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(4); return out; } +SEXP wk_tpo_profile_warmup_period(SEXP e) { + struct TpoProfile *h = (struct TpoProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tpo_profile_warmup_period(h)); +} +SEXP wk_tpo_profile_is_ready(SEXP e) { + struct TpoProfile *h = (struct TpoProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tpo_profile_is_ready(h)); +} SEXP wk_tpo_profile_reset(SEXP e) { struct TpoProfile *h = (struct TpoProfile *)R_ExternalPtrAddr(e); wickra_tpo_profile_reset(h); @@ -14068,6 +17516,14 @@ SEXP wk_trade_imbalance_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct TradeImbalance *h = (struct TradeImbalance *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_trade_imbalance_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_trade_imbalance_warmup_period(SEXP e) { + struct TradeImbalance *h = (struct TradeImbalance *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trade_imbalance_warmup_period(h)); +} +SEXP wk_trade_imbalance_is_ready(SEXP e) { + struct TradeImbalance *h = (struct TradeImbalance *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trade_imbalance_is_ready(h)); +} SEXP wk_trade_imbalance_reset(SEXP e) { struct TradeImbalance *h = (struct TradeImbalance *)R_ExternalPtrAddr(e); wickra_trade_imbalance_reset(h); @@ -14091,6 +17547,14 @@ SEXP wk_trade_sign_autocorrelation_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEX struct TradeSignAutocorrelation *h = (struct TradeSignAutocorrelation *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_trade_sign_autocorrelation_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_trade_sign_autocorrelation_warmup_period(SEXP e) { + struct TradeSignAutocorrelation *h = (struct TradeSignAutocorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trade_sign_autocorrelation_warmup_period(h)); +} +SEXP wk_trade_sign_autocorrelation_is_ready(SEXP e) { + struct TradeSignAutocorrelation *h = (struct TradeSignAutocorrelation *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trade_sign_autocorrelation_is_ready(h)); +} SEXP wk_trade_sign_autocorrelation_reset(SEXP e) { struct TradeSignAutocorrelation *h = (struct TradeSignAutocorrelation *)R_ExternalPtrAddr(e); wickra_trade_sign_autocorrelation_reset(h); @@ -14124,6 +17588,14 @@ SEXP wk_trade_volume_index_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_trade_volume_index_warmup_period(SEXP e) { + struct TradeVolumeIndex *h = (struct TradeVolumeIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trade_volume_index_warmup_period(h)); +} +SEXP wk_trade_volume_index_is_ready(SEXP e) { + struct TradeVolumeIndex *h = (struct TradeVolumeIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trade_volume_index_is_ready(h)); +} SEXP wk_trade_volume_index_reset(SEXP e) { struct TradeVolumeIndex *h = (struct TradeVolumeIndex *)R_ExternalPtrAddr(e); wickra_trade_volume_index_reset(h); @@ -14155,6 +17627,14 @@ SEXP wk_trend_label_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_trend_label_warmup_period(SEXP e) { + struct TrendLabel *h = (struct TrendLabel *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trend_label_warmup_period(h)); +} +SEXP wk_trend_label_is_ready(SEXP e) { + struct TrendLabel *h = (struct TrendLabel *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trend_label_is_ready(h)); +} SEXP wk_trend_label_reset(SEXP e) { struct TrendLabel *h = (struct TrendLabel *)R_ExternalPtrAddr(e); wickra_trend_label_reset(h); @@ -14186,6 +17666,14 @@ SEXP wk_trend_strength_index_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_trend_strength_index_warmup_period(SEXP e) { + struct TrendStrengthIndex *h = (struct TrendStrengthIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trend_strength_index_warmup_period(h)); +} +SEXP wk_trend_strength_index_is_ready(SEXP e) { + struct TrendStrengthIndex *h = (struct TrendStrengthIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trend_strength_index_is_ready(h)); +} SEXP wk_trend_strength_index_reset(SEXP e) { struct TrendStrengthIndex *h = (struct TrendStrengthIndex *)R_ExternalPtrAddr(e); wickra_trend_strength_index_reset(h); @@ -14217,6 +17705,14 @@ SEXP wk_trendflex_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_trendflex_warmup_period(SEXP e) { + struct Trendflex *h = (struct Trendflex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trendflex_warmup_period(h)); +} +SEXP wk_trendflex_is_ready(SEXP e) { + struct Trendflex *h = (struct Trendflex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trendflex_is_ready(h)); +} SEXP wk_trendflex_reset(SEXP e) { struct Trendflex *h = (struct Trendflex *)R_ExternalPtrAddr(e); wickra_trendflex_reset(h); @@ -14248,6 +17744,14 @@ SEXP wk_treynor_ratio_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_treynor_ratio_warmup_period(SEXP e) { + struct TreynorRatio *h = (struct TreynorRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_treynor_ratio_warmup_period(h)); +} +SEXP wk_treynor_ratio_is_ready(SEXP e) { + struct TreynorRatio *h = (struct TreynorRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_treynor_ratio_is_ready(h)); +} SEXP wk_treynor_ratio_reset(SEXP e) { struct TreynorRatio *h = (struct TreynorRatio *)R_ExternalPtrAddr(e); wickra_treynor_ratio_reset(h); @@ -14281,6 +17785,14 @@ SEXP wk_triangle_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_triangle_warmup_period(SEXP e) { + struct Triangle *h = (struct Triangle *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_triangle_warmup_period(h)); +} +SEXP wk_triangle_is_ready(SEXP e) { + struct Triangle *h = (struct Triangle *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_triangle_is_ready(h)); +} SEXP wk_triangle_reset(SEXP e) { struct Triangle *h = (struct Triangle *)R_ExternalPtrAddr(e); wickra_triangle_reset(h); @@ -14312,6 +17824,14 @@ SEXP wk_trima_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_trima_warmup_period(SEXP e) { + struct Trima *h = (struct Trima *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trima_warmup_period(h)); +} +SEXP wk_trima_is_ready(SEXP e) { + struct Trima *h = (struct Trima *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trima_is_ready(h)); +} SEXP wk_trima_reset(SEXP e) { struct Trima *h = (struct Trima *)R_ExternalPtrAddr(e); wickra_trima_reset(h); @@ -14335,6 +17855,14 @@ SEXP wk_trin_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5 struct Trin *h = (struct Trin *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_trin_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_trin_warmup_period(SEXP e) { + struct Trin *h = (struct Trin *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trin_warmup_period(h)); +} +SEXP wk_trin_is_ready(SEXP e) { + struct Trin *h = (struct Trin *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trin_is_ready(h)); +} SEXP wk_trin_reset(SEXP e) { struct Trin *h = (struct Trin *)R_ExternalPtrAddr(e); wickra_trin_reset(h); @@ -14368,6 +17896,14 @@ SEXP wk_triple_top_bottom_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_triple_top_bottom_warmup_period(SEXP e) { + struct TripleTopBottom *h = (struct TripleTopBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_triple_top_bottom_warmup_period(h)); +} +SEXP wk_triple_top_bottom_is_ready(SEXP e) { + struct TripleTopBottom *h = (struct TripleTopBottom *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_triple_top_bottom_is_ready(h)); +} SEXP wk_triple_top_bottom_reset(SEXP e) { struct TripleTopBottom *h = (struct TripleTopBottom *)R_ExternalPtrAddr(e); wickra_triple_top_bottom_reset(h); @@ -14401,6 +17937,14 @@ SEXP wk_tristar_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_tristar_warmup_period(SEXP e) { + struct Tristar *h = (struct Tristar *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tristar_warmup_period(h)); +} +SEXP wk_tristar_is_ready(SEXP e) { + struct Tristar *h = (struct Tristar *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tristar_is_ready(h)); +} SEXP wk_tristar_reset(SEXP e) { struct Tristar *h = (struct Tristar *)R_ExternalPtrAddr(e); wickra_tristar_reset(h); @@ -14432,6 +17976,14 @@ SEXP wk_trix_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_trix_warmup_period(SEXP e) { + struct Trix *h = (struct Trix *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_trix_warmup_period(h)); +} +SEXP wk_trix_is_ready(SEXP e) { + struct Trix *h = (struct Trix *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_trix_is_ready(h)); +} SEXP wk_trix_reset(SEXP e) { struct Trix *h = (struct Trix *)R_ExternalPtrAddr(e); wickra_trix_reset(h); @@ -14465,6 +18017,14 @@ SEXP wk_true_range_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_true_range_warmup_period(SEXP e) { + struct TrueRange *h = (struct TrueRange *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_true_range_warmup_period(h)); +} +SEXP wk_true_range_is_ready(SEXP e) { + struct TrueRange *h = (struct TrueRange *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_true_range_is_ready(h)); +} SEXP wk_true_range_reset(SEXP e) { struct TrueRange *h = (struct TrueRange *)R_ExternalPtrAddr(e); wickra_true_range_reset(h); @@ -14496,6 +18056,14 @@ SEXP wk_tsf_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_tsf_warmup_period(SEXP e) { + struct Tsf *h = (struct Tsf *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tsf_warmup_period(h)); +} +SEXP wk_tsf_is_ready(SEXP e) { + struct Tsf *h = (struct Tsf *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tsf_is_ready(h)); +} SEXP wk_tsf_reset(SEXP e) { struct Tsf *h = (struct Tsf *)R_ExternalPtrAddr(e); wickra_tsf_reset(h); @@ -14527,6 +18095,14 @@ SEXP wk_tsf_oscillator_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_tsf_oscillator_warmup_period(SEXP e) { + struct TsfOscillator *h = (struct TsfOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tsf_oscillator_warmup_period(h)); +} +SEXP wk_tsf_oscillator_is_ready(SEXP e) { + struct TsfOscillator *h = (struct TsfOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tsf_oscillator_is_ready(h)); +} SEXP wk_tsf_oscillator_reset(SEXP e) { struct TsfOscillator *h = (struct TsfOscillator *)R_ExternalPtrAddr(e); wickra_tsf_oscillator_reset(h); @@ -14558,6 +18134,14 @@ SEXP wk_tsi_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_tsi_warmup_period(SEXP e) { + struct Tsi *h = (struct Tsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tsi_warmup_period(h)); +} +SEXP wk_tsi_is_ready(SEXP e) { + struct Tsi *h = (struct Tsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tsi_is_ready(h)); +} SEXP wk_tsi_reset(SEXP e) { struct Tsi *h = (struct Tsi *)R_ExternalPtrAddr(e); wickra_tsi_reset(h); @@ -14591,6 +18175,14 @@ SEXP wk_tsv_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_tsv_warmup_period(SEXP e) { + struct Tsv *h = (struct Tsv *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tsv_warmup_period(h)); +} +SEXP wk_tsv_is_ready(SEXP e) { + struct Tsv *h = (struct Tsv *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tsv_is_ready(h)); +} SEXP wk_tsv_reset(SEXP e) { struct Tsv *h = (struct Tsv *)R_ExternalPtrAddr(e); wickra_tsv_reset(h); @@ -14624,6 +18216,14 @@ SEXP wk_ttm_squeeze_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(2); return r; } +SEXP wk_ttm_squeeze_warmup_period(SEXP e) { + struct TtmSqueeze *h = (struct TtmSqueeze *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ttm_squeeze_warmup_period(h)); +} +SEXP wk_ttm_squeeze_is_ready(SEXP e) { + struct TtmSqueeze *h = (struct TtmSqueeze *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ttm_squeeze_is_ready(h)); +} SEXP wk_ttm_squeeze_reset(SEXP e) { struct TtmSqueeze *h = (struct TtmSqueeze *)R_ExternalPtrAddr(e); wickra_ttm_squeeze_reset(h); @@ -14657,6 +18257,14 @@ SEXP wk_ttm_trend_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_ttm_trend_warmup_period(SEXP e) { + struct TtmTrend *h = (struct TtmTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ttm_trend_warmup_period(h)); +} +SEXP wk_ttm_trend_is_ready(SEXP e) { + struct TtmTrend *h = (struct TtmTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ttm_trend_is_ready(h)); +} SEXP wk_ttm_trend_reset(SEXP e) { struct TtmTrend *h = (struct TtmTrend *)R_ExternalPtrAddr(e); wickra_ttm_trend_reset(h); @@ -14690,6 +18298,14 @@ SEXP wk_turn_of_month_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_turn_of_month_warmup_period(SEXP e) { + struct TurnOfMonth *h = (struct TurnOfMonth *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_turn_of_month_warmup_period(h)); +} +SEXP wk_turn_of_month_is_ready(SEXP e) { + struct TurnOfMonth *h = (struct TurnOfMonth *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_turn_of_month_is_ready(h)); +} SEXP wk_turn_of_month_reset(SEXP e) { struct TurnOfMonth *h = (struct TurnOfMonth *)R_ExternalPtrAddr(e); wickra_turn_of_month_reset(h); @@ -14723,6 +18339,14 @@ SEXP wk_tweezer_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(1); return out; } +SEXP wk_tweezer_warmup_period(SEXP e) { + struct Tweezer *h = (struct Tweezer *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_tweezer_warmup_period(h)); +} +SEXP wk_tweezer_is_ready(SEXP e) { + struct Tweezer *h = (struct Tweezer *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_tweezer_is_ready(h)); +} SEXP wk_tweezer_reset(SEXP e) { struct Tweezer *h = (struct Tweezer *)R_ExternalPtrAddr(e); wickra_tweezer_reset(h); @@ -14756,6 +18380,14 @@ SEXP wk_twiggs_money_flow_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_twiggs_money_flow_warmup_period(SEXP e) { + struct TwiggsMoneyFlow *h = (struct TwiggsMoneyFlow *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_twiggs_money_flow_warmup_period(h)); +} +SEXP wk_twiggs_money_flow_is_ready(SEXP e) { + struct TwiggsMoneyFlow *h = (struct TwiggsMoneyFlow *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_twiggs_money_flow_is_ready(h)); +} SEXP wk_twiggs_money_flow_reset(SEXP e) { struct TwiggsMoneyFlow *h = (struct TwiggsMoneyFlow *)R_ExternalPtrAddr(e); wickra_twiggs_money_flow_reset(h); @@ -14789,6 +18421,14 @@ SEXP wk_two_crows_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_two_crows_warmup_period(SEXP e) { + struct TwoCrows *h = (struct TwoCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_two_crows_warmup_period(h)); +} +SEXP wk_two_crows_is_ready(SEXP e) { + struct TwoCrows *h = (struct TwoCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_two_crows_is_ready(h)); +} SEXP wk_two_crows_reset(SEXP e) { struct TwoCrows *h = (struct TwoCrows *)R_ExternalPtrAddr(e); wickra_two_crows_reset(h); @@ -14822,6 +18462,14 @@ SEXP wk_typical_price_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, UNPROTECT(1); return out; } +SEXP wk_typical_price_warmup_period(SEXP e) { + struct TypicalPrice *h = (struct TypicalPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_typical_price_warmup_period(h)); +} +SEXP wk_typical_price_is_ready(SEXP e) { + struct TypicalPrice *h = (struct TypicalPrice *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_typical_price_is_ready(h)); +} SEXP wk_typical_price_reset(SEXP e) { struct TypicalPrice *h = (struct TypicalPrice *)R_ExternalPtrAddr(e); wickra_typical_price_reset(h); @@ -14853,6 +18501,14 @@ SEXP wk_ulcer_index_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_ulcer_index_warmup_period(SEXP e) { + struct UlcerIndex *h = (struct UlcerIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ulcer_index_warmup_period(h)); +} +SEXP wk_ulcer_index_is_ready(SEXP e) { + struct UlcerIndex *h = (struct UlcerIndex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ulcer_index_is_ready(h)); +} SEXP wk_ulcer_index_reset(SEXP e) { struct UlcerIndex *h = (struct UlcerIndex *)R_ExternalPtrAddr(e); wickra_ulcer_index_reset(h); @@ -14886,6 +18542,14 @@ SEXP wk_ultimate_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE UNPROTECT(1); return out; } +SEXP wk_ultimate_oscillator_warmup_period(SEXP e) { + struct UltimateOscillator *h = (struct UltimateOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_ultimate_oscillator_warmup_period(h)); +} +SEXP wk_ultimate_oscillator_is_ready(SEXP e) { + struct UltimateOscillator *h = (struct UltimateOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_ultimate_oscillator_is_ready(h)); +} SEXP wk_ultimate_oscillator_reset(SEXP e) { struct UltimateOscillator *h = (struct UltimateOscillator *)R_ExternalPtrAddr(e); wickra_ultimate_oscillator_reset(h); @@ -14919,6 +18583,14 @@ SEXP wk_unique_three_river_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_unique_three_river_warmup_period(SEXP e) { + struct UniqueThreeRiver *h = (struct UniqueThreeRiver *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_unique_three_river_warmup_period(h)); +} +SEXP wk_unique_three_river_is_ready(SEXP e) { + struct UniqueThreeRiver *h = (struct UniqueThreeRiver *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_unique_three_river_is_ready(h)); +} SEXP wk_unique_three_river_reset(SEXP e) { struct UniqueThreeRiver *h = (struct UniqueThreeRiver *)R_ExternalPtrAddr(e); wickra_unique_three_river_reset(h); @@ -14950,6 +18622,14 @@ SEXP wk_universal_oscillator_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_universal_oscillator_warmup_period(SEXP e) { + struct UniversalOscillator *h = (struct UniversalOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_universal_oscillator_warmup_period(h)); +} +SEXP wk_universal_oscillator_is_ready(SEXP e) { + struct UniversalOscillator *h = (struct UniversalOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_universal_oscillator_is_ready(h)); +} SEXP wk_universal_oscillator_reset(SEXP e) { struct UniversalOscillator *h = (struct UniversalOscillator *)R_ExternalPtrAddr(e); wickra_universal_oscillator_reset(h); @@ -14973,6 +18653,14 @@ SEXP wk_up_down_volume_ratio_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, struct UpDownVolumeRatio *h = (struct UpDownVolumeRatio *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_up_down_volume_ratio_update(h, (double *)REAL(a0), (double *)REAL(a1), (bool *)REAL(a2), (bool *)REAL(a3), (bool *)REAL(a4), (bool *)REAL(a5), (uintptr_t)Rf_xlength(a0), (int64_t)Rf_asReal(a6))); } +SEXP wk_up_down_volume_ratio_warmup_period(SEXP e) { + struct UpDownVolumeRatio *h = (struct UpDownVolumeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_up_down_volume_ratio_warmup_period(h)); +} +SEXP wk_up_down_volume_ratio_is_ready(SEXP e) { + struct UpDownVolumeRatio *h = (struct UpDownVolumeRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_up_down_volume_ratio_is_ready(h)); +} SEXP wk_up_down_volume_ratio_reset(SEXP e) { struct UpDownVolumeRatio *h = (struct UpDownVolumeRatio *)R_ExternalPtrAddr(e); wickra_up_down_volume_ratio_reset(h); @@ -15006,6 +18694,14 @@ SEXP wk_upside_gap_three_methods_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a UNPROTECT(1); return out; } +SEXP wk_upside_gap_three_methods_warmup_period(SEXP e) { + struct UpsideGapThreeMethods *h = (struct UpsideGapThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_upside_gap_three_methods_warmup_period(h)); +} +SEXP wk_upside_gap_three_methods_is_ready(SEXP e) { + struct UpsideGapThreeMethods *h = (struct UpsideGapThreeMethods *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_upside_gap_three_methods_is_ready(h)); +} SEXP wk_upside_gap_three_methods_reset(SEXP e) { struct UpsideGapThreeMethods *h = (struct UpsideGapThreeMethods *)R_ExternalPtrAddr(e); wickra_upside_gap_three_methods_reset(h); @@ -15039,6 +18735,14 @@ SEXP wk_upside_gap_two_crows_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, S UNPROTECT(1); return out; } +SEXP wk_upside_gap_two_crows_warmup_period(SEXP e) { + struct UpsideGapTwoCrows *h = (struct UpsideGapTwoCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_upside_gap_two_crows_warmup_period(h)); +} +SEXP wk_upside_gap_two_crows_is_ready(SEXP e) { + struct UpsideGapTwoCrows *h = (struct UpsideGapTwoCrows *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_upside_gap_two_crows_is_ready(h)); +} SEXP wk_upside_gap_two_crows_reset(SEXP e) { struct UpsideGapTwoCrows *h = (struct UpsideGapTwoCrows *)R_ExternalPtrAddr(e); wickra_upside_gap_two_crows_reset(h); @@ -15070,6 +18774,14 @@ SEXP wk_upside_potential_ratio_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_upside_potential_ratio_warmup_period(SEXP e) { + struct UpsidePotentialRatio *h = (struct UpsidePotentialRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_upside_potential_ratio_warmup_period(h)); +} +SEXP wk_upside_potential_ratio_is_ready(SEXP e) { + struct UpsidePotentialRatio *h = (struct UpsidePotentialRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_upside_potential_ratio_is_ready(h)); +} SEXP wk_upside_potential_ratio_reset(SEXP e) { struct UpsidePotentialRatio *h = (struct UpsidePotentialRatio *)R_ExternalPtrAddr(e); wickra_upside_potential_ratio_reset(h); @@ -15105,6 +18817,14 @@ SEXP wk_value_area_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(2); return r; } +SEXP wk_value_area_warmup_period(SEXP e) { + struct ValueArea *h = (struct ValueArea *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_value_area_warmup_period(h)); +} +SEXP wk_value_area_is_ready(SEXP e) { + struct ValueArea *h = (struct ValueArea *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_value_area_is_ready(h)); +} SEXP wk_value_area_reset(SEXP e) { struct ValueArea *h = (struct ValueArea *)R_ExternalPtrAddr(e); wickra_value_area_reset(h); @@ -15136,6 +18856,14 @@ SEXP wk_value_at_risk_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_value_at_risk_warmup_period(SEXP e) { + struct ValueAtRisk *h = (struct ValueAtRisk *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_value_at_risk_warmup_period(h)); +} +SEXP wk_value_at_risk_is_ready(SEXP e) { + struct ValueAtRisk *h = (struct ValueAtRisk *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_value_at_risk_is_ready(h)); +} SEXP wk_value_at_risk_reset(SEXP e) { struct ValueAtRisk *h = (struct ValueAtRisk *)R_ExternalPtrAddr(e); wickra_value_at_risk_reset(h); @@ -15167,6 +18895,14 @@ SEXP wk_variance_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_variance_warmup_period(SEXP e) { + struct Variance *h = (struct Variance *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_variance_warmup_period(h)); +} +SEXP wk_variance_is_ready(SEXP e) { + struct Variance *h = (struct Variance *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_variance_is_ready(h)); +} SEXP wk_variance_reset(SEXP e) { struct Variance *h = (struct Variance *)R_ExternalPtrAddr(e); wickra_variance_reset(h); @@ -15198,6 +18934,14 @@ SEXP wk_variance_ratio_batch(SEXP e, SEXP a0, SEXP a1) { UNPROTECT(1); return out; } +SEXP wk_variance_ratio_warmup_period(SEXP e) { + struct VarianceRatio *h = (struct VarianceRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_variance_ratio_warmup_period(h)); +} +SEXP wk_variance_ratio_is_ready(SEXP e) { + struct VarianceRatio *h = (struct VarianceRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_variance_ratio_is_ready(h)); +} SEXP wk_variance_ratio_reset(SEXP e) { struct VarianceRatio *h = (struct VarianceRatio *)R_ExternalPtrAddr(e); wickra_variance_ratio_reset(h); @@ -15229,6 +18973,14 @@ SEXP wk_vertical_horizontal_filter_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_vertical_horizontal_filter_warmup_period(SEXP e) { + struct VerticalHorizontalFilter *h = (struct VerticalHorizontalFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vertical_horizontal_filter_warmup_period(h)); +} +SEXP wk_vertical_horizontal_filter_is_ready(SEXP e) { + struct VerticalHorizontalFilter *h = (struct VerticalHorizontalFilter *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vertical_horizontal_filter_is_ready(h)); +} SEXP wk_vertical_horizontal_filter_reset(SEXP e) { struct VerticalHorizontalFilter *h = (struct VerticalHorizontalFilter *)R_ExternalPtrAddr(e); wickra_vertical_horizontal_filter_reset(h); @@ -15260,6 +19012,14 @@ SEXP wk_vidya_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_vidya_warmup_period(SEXP e) { + struct Vidya *h = (struct Vidya *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vidya_warmup_period(h)); +} +SEXP wk_vidya_is_ready(SEXP e) { + struct Vidya *h = (struct Vidya *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vidya_is_ready(h)); +} SEXP wk_vidya_reset(SEXP e) { struct Vidya *h = (struct Vidya *)R_ExternalPtrAddr(e); wickra_vidya_reset(h); @@ -15299,6 +19059,14 @@ SEXP wk_volatility_cone_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(2); return r; } +SEXP wk_volatility_cone_warmup_period(SEXP e) { + struct VolatilityCone *h = (struct VolatilityCone *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volatility_cone_warmup_period(h)); +} +SEXP wk_volatility_cone_is_ready(SEXP e) { + struct VolatilityCone *h = (struct VolatilityCone *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volatility_cone_is_ready(h)); +} SEXP wk_volatility_cone_reset(SEXP e) { struct VolatilityCone *h = (struct VolatilityCone *)R_ExternalPtrAddr(e); wickra_volatility_cone_reset(h); @@ -15330,6 +19098,14 @@ SEXP wk_volatility_of_volatility_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_volatility_of_volatility_warmup_period(SEXP e) { + struct VolatilityOfVolatility *h = (struct VolatilityOfVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volatility_of_volatility_warmup_period(h)); +} +SEXP wk_volatility_of_volatility_is_ready(SEXP e) { + struct VolatilityOfVolatility *h = (struct VolatilityOfVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volatility_of_volatility_is_ready(h)); +} SEXP wk_volatility_of_volatility_reset(SEXP e) { struct VolatilityOfVolatility *h = (struct VolatilityOfVolatility *)R_ExternalPtrAddr(e); wickra_volatility_of_volatility_reset(h); @@ -15363,6 +19139,14 @@ SEXP wk_volatility_ratio_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_volatility_ratio_warmup_period(SEXP e) { + struct VolatilityRatio *h = (struct VolatilityRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volatility_ratio_warmup_period(h)); +} +SEXP wk_volatility_ratio_is_ready(SEXP e) { + struct VolatilityRatio *h = (struct VolatilityRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volatility_ratio_is_ready(h)); +} SEXP wk_volatility_ratio_reset(SEXP e) { struct VolatilityRatio *h = (struct VolatilityRatio *)R_ExternalPtrAddr(e); wickra_volatility_ratio_reset(h); @@ -15396,6 +19180,14 @@ SEXP wk_volty_stop_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_volty_stop_warmup_period(SEXP e) { + struct VoltyStop *h = (struct VoltyStop *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volty_stop_warmup_period(h)); +} +SEXP wk_volty_stop_is_ready(SEXP e) { + struct VoltyStop *h = (struct VoltyStop *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volty_stop_is_ready(h)); +} SEXP wk_volty_stop_reset(SEXP e) { struct VoltyStop *h = (struct VoltyStop *)R_ExternalPtrAddr(e); wickra_volty_stop_reset(h); @@ -15469,6 +19261,14 @@ SEXP wk_volume_by_time_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3 UNPROTECT(2); return vv; } +SEXP wk_volume_by_time_profile_warmup_period(SEXP e) { + struct VolumeByTimeProfile *h = (struct VolumeByTimeProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_by_time_profile_warmup_period(h)); +} +SEXP wk_volume_by_time_profile_is_ready(SEXP e) { + struct VolumeByTimeProfile *h = (struct VolumeByTimeProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_by_time_profile_is_ready(h)); +} SEXP wk_volume_by_time_profile_reset(SEXP e) { struct VolumeByTimeProfile *h = (struct VolumeByTimeProfile *)R_ExternalPtrAddr(e); wickra_volume_by_time_profile_reset(h); @@ -15502,6 +19302,14 @@ SEXP wk_volume_oscillator_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP UNPROTECT(1); return out; } +SEXP wk_volume_oscillator_warmup_period(SEXP e) { + struct VolumeOscillator *h = (struct VolumeOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_oscillator_warmup_period(h)); +} +SEXP wk_volume_oscillator_is_ready(SEXP e) { + struct VolumeOscillator *h = (struct VolumeOscillator *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_oscillator_is_ready(h)); +} SEXP wk_volume_oscillator_reset(SEXP e) { struct VolumeOscillator *h = (struct VolumeOscillator *)R_ExternalPtrAddr(e); wickra_volume_oscillator_reset(h); @@ -15535,6 +19343,14 @@ SEXP wk_volume_price_trend_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(1); return out; } +SEXP wk_volume_price_trend_warmup_period(SEXP e) { + struct VolumePriceTrend *h = (struct VolumePriceTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_price_trend_warmup_period(h)); +} +SEXP wk_volume_price_trend_is_ready(SEXP e) { + struct VolumePriceTrend *h = (struct VolumePriceTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_price_trend_is_ready(h)); +} SEXP wk_volume_price_trend_reset(SEXP e) { struct VolumePriceTrend *h = (struct VolumePriceTrend *)R_ExternalPtrAddr(e); wickra_volume_price_trend_reset(h); @@ -15575,6 +19391,14 @@ SEXP wk_volume_profile_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a UNPROTECT(4); return out; } +SEXP wk_volume_profile_warmup_period(SEXP e) { + struct VolumeProfile *h = (struct VolumeProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_profile_warmup_period(h)); +} +SEXP wk_volume_profile_is_ready(SEXP e) { + struct VolumeProfile *h = (struct VolumeProfile *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_profile_is_ready(h)); +} SEXP wk_volume_profile_reset(SEXP e) { struct VolumeProfile *h = (struct VolumeProfile *)R_ExternalPtrAddr(e); wickra_volume_profile_reset(h); @@ -15608,6 +19432,14 @@ SEXP wk_volume_rsi_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_volume_rsi_warmup_period(SEXP e) { + struct VolumeRsi *h = (struct VolumeRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_rsi_warmup_period(h)); +} +SEXP wk_volume_rsi_is_ready(SEXP e) { + struct VolumeRsi *h = (struct VolumeRsi *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_rsi_is_ready(h)); +} SEXP wk_volume_rsi_reset(SEXP e) { struct VolumeRsi *h = (struct VolumeRsi *)R_ExternalPtrAddr(e); wickra_volume_rsi_reset(h); @@ -15643,6 +19475,14 @@ SEXP wk_volume_weighted_macd_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(2); return r; } +SEXP wk_volume_weighted_macd_warmup_period(SEXP e) { + struct VolumeWeightedMacd *h = (struct VolumeWeightedMacd *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_weighted_macd_warmup_period(h)); +} +SEXP wk_volume_weighted_macd_is_ready(SEXP e) { + struct VolumeWeightedMacd *h = (struct VolumeWeightedMacd *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_weighted_macd_is_ready(h)); +} SEXP wk_volume_weighted_macd_reset(SEXP e) { struct VolumeWeightedMacd *h = (struct VolumeWeightedMacd *)R_ExternalPtrAddr(e); wickra_volume_weighted_macd_reset(h); @@ -15676,6 +19516,14 @@ SEXP wk_volume_weighted_sr_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE UNPROTECT(2); return r; } +SEXP wk_volume_weighted_sr_warmup_period(SEXP e) { + struct VolumeWeightedSr *h = (struct VolumeWeightedSr *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_volume_weighted_sr_warmup_period(h)); +} +SEXP wk_volume_weighted_sr_is_ready(SEXP e) { + struct VolumeWeightedSr *h = (struct VolumeWeightedSr *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_volume_weighted_sr_is_ready(h)); +} SEXP wk_volume_weighted_sr_reset(SEXP e) { struct VolumeWeightedSr *h = (struct VolumeWeightedSr *)R_ExternalPtrAddr(e); wickra_volume_weighted_sr_reset(h); @@ -15709,6 +19557,14 @@ SEXP wk_vortex_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(2); return r; } +SEXP wk_vortex_warmup_period(SEXP e) { + struct Vortex *h = (struct Vortex *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vortex_warmup_period(h)); +} +SEXP wk_vortex_is_ready(SEXP e) { + struct Vortex *h = (struct Vortex *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vortex_is_ready(h)); +} SEXP wk_vortex_reset(SEXP e) { struct Vortex *h = (struct Vortex *)R_ExternalPtrAddr(e); wickra_vortex_reset(h); @@ -15732,6 +19588,14 @@ SEXP wk_vpin_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3) { struct Vpin *h = (struct Vpin *)R_ExternalPtrAddr(e); return Rf_ScalarReal(wickra_vpin_update(h, Rf_asReal(a0), Rf_asReal(a1), (bool)(Rf_asLogical(a2) == TRUE), (int64_t)Rf_asReal(a3))); } +SEXP wk_vpin_warmup_period(SEXP e) { + struct Vpin *h = (struct Vpin *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vpin_warmup_period(h)); +} +SEXP wk_vpin_is_ready(SEXP e) { + struct Vpin *h = (struct Vpin *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vpin_is_ready(h)); +} SEXP wk_vpin_reset(SEXP e) { struct Vpin *h = (struct Vpin *)R_ExternalPtrAddr(e); wickra_vpin_reset(h); @@ -15765,6 +19629,14 @@ SEXP wk_vwap_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_vwap_warmup_period(SEXP e) { + struct Vwap *h = (struct Vwap *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vwap_warmup_period(h)); +} +SEXP wk_vwap_is_ready(SEXP e) { + struct Vwap *h = (struct Vwap *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vwap_is_ready(h)); +} SEXP wk_vwap_reset(SEXP e) { struct Vwap *h = (struct Vwap *)R_ExternalPtrAddr(e); wickra_vwap_reset(h); @@ -15802,6 +19674,14 @@ SEXP wk_vwap_std_dev_bands_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SE UNPROTECT(2); return r; } +SEXP wk_vwap_std_dev_bands_warmup_period(SEXP e) { + struct VwapStdDevBands *h = (struct VwapStdDevBands *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vwap_std_dev_bands_warmup_period(h)); +} +SEXP wk_vwap_std_dev_bands_is_ready(SEXP e) { + struct VwapStdDevBands *h = (struct VwapStdDevBands *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vwap_std_dev_bands_is_ready(h)); +} SEXP wk_vwap_std_dev_bands_reset(SEXP e) { struct VwapStdDevBands *h = (struct VwapStdDevBands *)R_ExternalPtrAddr(e); wickra_vwap_std_dev_bands_reset(h); @@ -15835,6 +19715,14 @@ SEXP wk_vwma_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_vwma_warmup_period(SEXP e) { + struct Vwma *h = (struct Vwma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vwma_warmup_period(h)); +} +SEXP wk_vwma_is_ready(SEXP e) { + struct Vwma *h = (struct Vwma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vwma_is_ready(h)); +} SEXP wk_vwma_reset(SEXP e) { struct Vwma *h = (struct Vwma *)R_ExternalPtrAddr(e); wickra_vwma_reset(h); @@ -15868,6 +19756,14 @@ SEXP wk_vzo_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_vzo_warmup_period(SEXP e) { + struct Vzo *h = (struct Vzo *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_vzo_warmup_period(h)); +} +SEXP wk_vzo_is_ready(SEXP e) { + struct Vzo *h = (struct Vzo *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_vzo_is_ready(h)); +} SEXP wk_vzo_reset(SEXP e) { struct Vzo *h = (struct Vzo *)R_ExternalPtrAddr(e); wickra_vzo_reset(h); @@ -15901,6 +19797,14 @@ SEXP wk_wad_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) UNPROTECT(1); return out; } +SEXP wk_wad_warmup_period(SEXP e) { + struct Wad *h = (struct Wad *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_wad_warmup_period(h)); +} +SEXP wk_wad_is_ready(SEXP e) { + struct Wad *h = (struct Wad *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_wad_is_ready(h)); +} SEXP wk_wad_reset(SEXP e) { struct Wad *h = (struct Wad *)R_ExternalPtrAddr(e); wickra_wad_reset(h); @@ -15932,6 +19836,14 @@ SEXP wk_wave_pm_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_wave_pm_warmup_period(SEXP e) { + struct WavePm *h = (struct WavePm *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_wave_pm_warmup_period(h)); +} +SEXP wk_wave_pm_is_ready(SEXP e) { + struct WavePm *h = (struct WavePm *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_wave_pm_is_ready(h)); +} SEXP wk_wave_pm_reset(SEXP e) { struct WavePm *h = (struct WavePm *)R_ExternalPtrAddr(e); wickra_wave_pm_reset(h); @@ -15965,6 +19877,14 @@ SEXP wk_wave_trend_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, S UNPROTECT(2); return r; } +SEXP wk_wave_trend_warmup_period(SEXP e) { + struct WaveTrend *h = (struct WaveTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_wave_trend_warmup_period(h)); +} +SEXP wk_wave_trend_is_ready(SEXP e) { + struct WaveTrend *h = (struct WaveTrend *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_wave_trend_is_ready(h)); +} SEXP wk_wave_trend_reset(SEXP e) { struct WaveTrend *h = (struct WaveTrend *)R_ExternalPtrAddr(e); wickra_wave_trend_reset(h); @@ -15998,6 +19918,14 @@ SEXP wk_wedge_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5 UNPROTECT(1); return out; } +SEXP wk_wedge_warmup_period(SEXP e) { + struct Wedge *h = (struct Wedge *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_wedge_warmup_period(h)); +} +SEXP wk_wedge_is_ready(SEXP e) { + struct Wedge *h = (struct Wedge *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_wedge_is_ready(h)); +} SEXP wk_wedge_reset(SEXP e) { struct Wedge *h = (struct Wedge *)R_ExternalPtrAddr(e); wickra_wedge_reset(h); @@ -16031,6 +19959,14 @@ SEXP wk_weighted_close_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(1); return out; } +SEXP wk_weighted_close_warmup_period(SEXP e) { + struct WeightedClose *h = (struct WeightedClose *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_weighted_close_warmup_period(h)); +} +SEXP wk_weighted_close_is_ready(SEXP e) { + struct WeightedClose *h = (struct WeightedClose *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_weighted_close_is_ready(h)); +} SEXP wk_weighted_close_reset(SEXP e) { struct WeightedClose *h = (struct WeightedClose *)R_ExternalPtrAddr(e); wickra_weighted_close_reset(h); @@ -16064,6 +20000,14 @@ SEXP wk_wick_ratio_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_wick_ratio_warmup_period(SEXP e) { + struct WickRatio *h = (struct WickRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_wick_ratio_warmup_period(h)); +} +SEXP wk_wick_ratio_is_ready(SEXP e) { + struct WickRatio *h = (struct WickRatio *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_wick_ratio_is_ready(h)); +} SEXP wk_wick_ratio_reset(SEXP e) { struct WickRatio *h = (struct WickRatio *)R_ExternalPtrAddr(e); wickra_wick_ratio_reset(h); @@ -16097,6 +20041,14 @@ SEXP wk_williams_fractals_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEX UNPROTECT(2); return r; } +SEXP wk_williams_fractals_warmup_period(SEXP e) { + struct WilliamsFractals *h = (struct WilliamsFractals *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_williams_fractals_warmup_period(h)); +} +SEXP wk_williams_fractals_is_ready(SEXP e) { + struct WilliamsFractals *h = (struct WilliamsFractals *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_williams_fractals_is_ready(h)); +} SEXP wk_williams_fractals_reset(SEXP e) { struct WilliamsFractals *h = (struct WilliamsFractals *)R_ExternalPtrAddr(e); wickra_williams_fractals_reset(h); @@ -16130,6 +20082,14 @@ SEXP wk_williams_r_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SE UNPROTECT(1); return out; } +SEXP wk_williams_r_warmup_period(SEXP e) { + struct WilliamsR *h = (struct WilliamsR *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_williams_r_warmup_period(h)); +} +SEXP wk_williams_r_is_ready(SEXP e) { + struct WilliamsR *h = (struct WilliamsR *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_williams_r_is_ready(h)); +} SEXP wk_williams_r_reset(SEXP e) { struct WilliamsR *h = (struct WilliamsR *)R_ExternalPtrAddr(e); wickra_williams_r_reset(h); @@ -16161,6 +20121,14 @@ SEXP wk_win_rate_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_win_rate_warmup_period(SEXP e) { + struct WinRate *h = (struct WinRate *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_win_rate_warmup_period(h)); +} +SEXP wk_win_rate_is_ready(SEXP e) { + struct WinRate *h = (struct WinRate *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_win_rate_is_ready(h)); +} SEXP wk_win_rate_reset(SEXP e) { struct WinRate *h = (struct WinRate *)R_ExternalPtrAddr(e); wickra_win_rate_reset(h); @@ -16192,6 +20160,14 @@ SEXP wk_wma_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_wma_warmup_period(SEXP e) { + struct Wma *h = (struct Wma *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_wma_warmup_period(h)); +} +SEXP wk_wma_is_ready(SEXP e) { + struct Wma *h = (struct Wma *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_wma_is_ready(h)); +} SEXP wk_wma_reset(SEXP e) { struct Wma *h = (struct Wma *)R_ExternalPtrAddr(e); wickra_wma_reset(h); @@ -16231,6 +20207,14 @@ SEXP wk_woodie_pivots_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4 UNPROTECT(2); return r; } +SEXP wk_woodie_pivots_warmup_period(SEXP e) { + struct WoodiePivots *h = (struct WoodiePivots *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_woodie_pivots_warmup_period(h)); +} +SEXP wk_woodie_pivots_is_ready(SEXP e) { + struct WoodiePivots *h = (struct WoodiePivots *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_woodie_pivots_is_ready(h)); +} SEXP wk_woodie_pivots_reset(SEXP e) { struct WoodiePivots *h = (struct WoodiePivots *)R_ExternalPtrAddr(e); wickra_woodie_pivots_reset(h); @@ -16264,6 +20248,14 @@ SEXP wk_yang_zhang_volatility_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, UNPROTECT(1); return out; } +SEXP wk_yang_zhang_volatility_warmup_period(SEXP e) { + struct YangZhangVolatility *h = (struct YangZhangVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_yang_zhang_volatility_warmup_period(h)); +} +SEXP wk_yang_zhang_volatility_is_ready(SEXP e) { + struct YangZhangVolatility *h = (struct YangZhangVolatility *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_yang_zhang_volatility_is_ready(h)); +} SEXP wk_yang_zhang_volatility_reset(SEXP e) { struct YangZhangVolatility *h = (struct YangZhangVolatility *)R_ExternalPtrAddr(e); wickra_yang_zhang_volatility_reset(h); @@ -16297,6 +20289,14 @@ SEXP wk_yoyo_exit_batch(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEX UNPROTECT(1); return out; } +SEXP wk_yoyo_exit_warmup_period(SEXP e) { + struct YoyoExit *h = (struct YoyoExit *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_yoyo_exit_warmup_period(h)); +} +SEXP wk_yoyo_exit_is_ready(SEXP e) { + struct YoyoExit *h = (struct YoyoExit *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_yoyo_exit_is_ready(h)); +} SEXP wk_yoyo_exit_reset(SEXP e) { struct YoyoExit *h = (struct YoyoExit *)R_ExternalPtrAddr(e); wickra_yoyo_exit_reset(h); @@ -16328,6 +20328,14 @@ SEXP wk_z_score_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_z_score_warmup_period(SEXP e) { + struct ZScore *h = (struct ZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_z_score_warmup_period(h)); +} +SEXP wk_z_score_is_ready(SEXP e) { + struct ZScore *h = (struct ZScore *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_z_score_is_ready(h)); +} SEXP wk_z_score_reset(SEXP e) { struct ZScore *h = (struct ZScore *)R_ExternalPtrAddr(e); wickra_z_score_reset(h); @@ -16363,6 +20371,14 @@ SEXP wk_zero_lag_macd_update(SEXP e, SEXP a0) { UNPROTECT(2); return r; } +SEXP wk_zero_lag_macd_warmup_period(SEXP e) { + struct ZeroLagMacd *h = (struct ZeroLagMacd *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_zero_lag_macd_warmup_period(h)); +} +SEXP wk_zero_lag_macd_is_ready(SEXP e) { + struct ZeroLagMacd *h = (struct ZeroLagMacd *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_zero_lag_macd_is_ready(h)); +} SEXP wk_zero_lag_macd_reset(SEXP e) { struct ZeroLagMacd *h = (struct ZeroLagMacd *)R_ExternalPtrAddr(e); wickra_zero_lag_macd_reset(h); @@ -16396,6 +20412,14 @@ SEXP wk_zig_zag_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP UNPROTECT(2); return r; } +SEXP wk_zig_zag_warmup_period(SEXP e) { + struct ZigZag *h = (struct ZigZag *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_zig_zag_warmup_period(h)); +} +SEXP wk_zig_zag_is_ready(SEXP e) { + struct ZigZag *h = (struct ZigZag *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_zig_zag_is_ready(h)); +} SEXP wk_zig_zag_reset(SEXP e) { struct ZigZag *h = (struct ZigZag *)R_ExternalPtrAddr(e); wickra_zig_zag_reset(h); @@ -16427,6 +20451,14 @@ SEXP wk_zlema_batch(SEXP e, SEXP a0) { UNPROTECT(1); return out; } +SEXP wk_zlema_warmup_period(SEXP e) { + struct Zlema *h = (struct Zlema *)R_ExternalPtrAddr(e); + return Rf_ScalarInteger((int)wickra_zlema_warmup_period(h)); +} +SEXP wk_zlema_is_ready(SEXP e) { + struct Zlema *h = (struct Zlema *)R_ExternalPtrAddr(e); + return Rf_ScalarLogical(wickra_zlema_is_ready(h)); +} SEXP wk_zlema_reset(SEXP e) { struct Zlema *h = (struct Zlema *)R_ExternalPtrAddr(e); wickra_zlema_reset(h); @@ -16437,722 +20469,1112 @@ static const R_CallMethodDef CallEntries[] = { {"wk_abandoned_baby_new", (DL_FUNC)&wk_abandoned_baby_new, 0}, {"wk_abandoned_baby_update", (DL_FUNC)&wk_abandoned_baby_update, 7}, {"wk_abandoned_baby_batch", (DL_FUNC)&wk_abandoned_baby_batch, 7}, + {"wk_abandoned_baby_warmup_period", (DL_FUNC)&wk_abandoned_baby_warmup_period, 1}, + {"wk_abandoned_baby_is_ready", (DL_FUNC)&wk_abandoned_baby_is_ready, 1}, {"wk_abandoned_baby_reset", (DL_FUNC)&wk_abandoned_baby_reset, 1}, {"wk_abcd_new", (DL_FUNC)&wk_abcd_new, 0}, {"wk_abcd_update", (DL_FUNC)&wk_abcd_update, 7}, {"wk_abcd_batch", (DL_FUNC)&wk_abcd_batch, 7}, + {"wk_abcd_warmup_period", (DL_FUNC)&wk_abcd_warmup_period, 1}, + {"wk_abcd_is_ready", (DL_FUNC)&wk_abcd_is_ready, 1}, {"wk_abcd_reset", (DL_FUNC)&wk_abcd_reset, 1}, {"wk_absolute_breadth_index_new", (DL_FUNC)&wk_absolute_breadth_index_new, 0}, {"wk_absolute_breadth_index_update", (DL_FUNC)&wk_absolute_breadth_index_update, 8}, + {"wk_absolute_breadth_index_warmup_period", (DL_FUNC)&wk_absolute_breadth_index_warmup_period, 1}, + {"wk_absolute_breadth_index_is_ready", (DL_FUNC)&wk_absolute_breadth_index_is_ready, 1}, {"wk_absolute_breadth_index_reset", (DL_FUNC)&wk_absolute_breadth_index_reset, 1}, {"wk_acceleration_bands_new", (DL_FUNC)&wk_acceleration_bands_new, 2}, {"wk_acceleration_bands_update", (DL_FUNC)&wk_acceleration_bands_update, 7}, + {"wk_acceleration_bands_warmup_period", (DL_FUNC)&wk_acceleration_bands_warmup_period, 1}, + {"wk_acceleration_bands_is_ready", (DL_FUNC)&wk_acceleration_bands_is_ready, 1}, {"wk_acceleration_bands_reset", (DL_FUNC)&wk_acceleration_bands_reset, 1}, {"wk_accelerator_oscillator_new", (DL_FUNC)&wk_accelerator_oscillator_new, 3}, {"wk_accelerator_oscillator_update", (DL_FUNC)&wk_accelerator_oscillator_update, 7}, {"wk_accelerator_oscillator_batch", (DL_FUNC)&wk_accelerator_oscillator_batch, 7}, + {"wk_accelerator_oscillator_warmup_period", (DL_FUNC)&wk_accelerator_oscillator_warmup_period, 1}, + {"wk_accelerator_oscillator_is_ready", (DL_FUNC)&wk_accelerator_oscillator_is_ready, 1}, {"wk_accelerator_oscillator_reset", (DL_FUNC)&wk_accelerator_oscillator_reset, 1}, {"wk_ad_oscillator_new", (DL_FUNC)&wk_ad_oscillator_new, 0}, {"wk_ad_oscillator_update", (DL_FUNC)&wk_ad_oscillator_update, 7}, {"wk_ad_oscillator_batch", (DL_FUNC)&wk_ad_oscillator_batch, 7}, + {"wk_ad_oscillator_warmup_period", (DL_FUNC)&wk_ad_oscillator_warmup_period, 1}, + {"wk_ad_oscillator_is_ready", (DL_FUNC)&wk_ad_oscillator_is_ready, 1}, {"wk_ad_oscillator_reset", (DL_FUNC)&wk_ad_oscillator_reset, 1}, {"wk_ad_volume_line_new", (DL_FUNC)&wk_ad_volume_line_new, 0}, {"wk_ad_volume_line_update", (DL_FUNC)&wk_ad_volume_line_update, 8}, + {"wk_ad_volume_line_warmup_period", (DL_FUNC)&wk_ad_volume_line_warmup_period, 1}, + {"wk_ad_volume_line_is_ready", (DL_FUNC)&wk_ad_volume_line_is_ready, 1}, {"wk_ad_volume_line_reset", (DL_FUNC)&wk_ad_volume_line_reset, 1}, {"wk_adaptive_cci_new", (DL_FUNC)&wk_adaptive_cci_new, 1}, {"wk_adaptive_cci_update", (DL_FUNC)&wk_adaptive_cci_update, 7}, {"wk_adaptive_cci_batch", (DL_FUNC)&wk_adaptive_cci_batch, 7}, + {"wk_adaptive_cci_warmup_period", (DL_FUNC)&wk_adaptive_cci_warmup_period, 1}, + {"wk_adaptive_cci_is_ready", (DL_FUNC)&wk_adaptive_cci_is_ready, 1}, {"wk_adaptive_cci_reset", (DL_FUNC)&wk_adaptive_cci_reset, 1}, {"wk_adaptive_cycle_new", (DL_FUNC)&wk_adaptive_cycle_new, 0}, {"wk_adaptive_cycle_update", (DL_FUNC)&wk_adaptive_cycle_update, 2}, {"wk_adaptive_cycle_batch", (DL_FUNC)&wk_adaptive_cycle_batch, 2}, + {"wk_adaptive_cycle_warmup_period", (DL_FUNC)&wk_adaptive_cycle_warmup_period, 1}, + {"wk_adaptive_cycle_is_ready", (DL_FUNC)&wk_adaptive_cycle_is_ready, 1}, {"wk_adaptive_cycle_reset", (DL_FUNC)&wk_adaptive_cycle_reset, 1}, {"wk_adaptive_laguerre_filter_new", (DL_FUNC)&wk_adaptive_laguerre_filter_new, 1}, {"wk_adaptive_laguerre_filter_update", (DL_FUNC)&wk_adaptive_laguerre_filter_update, 2}, {"wk_adaptive_laguerre_filter_batch", (DL_FUNC)&wk_adaptive_laguerre_filter_batch, 2}, + {"wk_adaptive_laguerre_filter_warmup_period", (DL_FUNC)&wk_adaptive_laguerre_filter_warmup_period, 1}, + {"wk_adaptive_laguerre_filter_is_ready", (DL_FUNC)&wk_adaptive_laguerre_filter_is_ready, 1}, {"wk_adaptive_laguerre_filter_reset", (DL_FUNC)&wk_adaptive_laguerre_filter_reset, 1}, {"wk_adaptive_rsi_new", (DL_FUNC)&wk_adaptive_rsi_new, 1}, {"wk_adaptive_rsi_update", (DL_FUNC)&wk_adaptive_rsi_update, 2}, {"wk_adaptive_rsi_batch", (DL_FUNC)&wk_adaptive_rsi_batch, 2}, + {"wk_adaptive_rsi_warmup_period", (DL_FUNC)&wk_adaptive_rsi_warmup_period, 1}, + {"wk_adaptive_rsi_is_ready", (DL_FUNC)&wk_adaptive_rsi_is_ready, 1}, {"wk_adaptive_rsi_reset", (DL_FUNC)&wk_adaptive_rsi_reset, 1}, {"wk_adl_new", (DL_FUNC)&wk_adl_new, 0}, {"wk_adl_update", (DL_FUNC)&wk_adl_update, 7}, {"wk_adl_batch", (DL_FUNC)&wk_adl_batch, 7}, + {"wk_adl_warmup_period", (DL_FUNC)&wk_adl_warmup_period, 1}, + {"wk_adl_is_ready", (DL_FUNC)&wk_adl_is_ready, 1}, {"wk_adl_reset", (DL_FUNC)&wk_adl_reset, 1}, {"wk_advance_block_new", (DL_FUNC)&wk_advance_block_new, 0}, {"wk_advance_block_update", (DL_FUNC)&wk_advance_block_update, 7}, {"wk_advance_block_batch", (DL_FUNC)&wk_advance_block_batch, 7}, + {"wk_advance_block_warmup_period", (DL_FUNC)&wk_advance_block_warmup_period, 1}, + {"wk_advance_block_is_ready", (DL_FUNC)&wk_advance_block_is_ready, 1}, {"wk_advance_block_reset", (DL_FUNC)&wk_advance_block_reset, 1}, {"wk_advance_decline_new", (DL_FUNC)&wk_advance_decline_new, 0}, {"wk_advance_decline_update", (DL_FUNC)&wk_advance_decline_update, 8}, + {"wk_advance_decline_warmup_period", (DL_FUNC)&wk_advance_decline_warmup_period, 1}, + {"wk_advance_decline_is_ready", (DL_FUNC)&wk_advance_decline_is_ready, 1}, {"wk_advance_decline_reset", (DL_FUNC)&wk_advance_decline_reset, 1}, {"wk_advance_decline_ratio_new", (DL_FUNC)&wk_advance_decline_ratio_new, 0}, {"wk_advance_decline_ratio_update", (DL_FUNC)&wk_advance_decline_ratio_update, 8}, + {"wk_advance_decline_ratio_warmup_period", (DL_FUNC)&wk_advance_decline_ratio_warmup_period, 1}, + {"wk_advance_decline_ratio_is_ready", (DL_FUNC)&wk_advance_decline_ratio_is_ready, 1}, {"wk_advance_decline_ratio_reset", (DL_FUNC)&wk_advance_decline_ratio_reset, 1}, {"wk_adx_new", (DL_FUNC)&wk_adx_new, 1}, {"wk_adx_update", (DL_FUNC)&wk_adx_update, 7}, + {"wk_adx_warmup_period", (DL_FUNC)&wk_adx_warmup_period, 1}, + {"wk_adx_is_ready", (DL_FUNC)&wk_adx_is_ready, 1}, {"wk_adx_reset", (DL_FUNC)&wk_adx_reset, 1}, {"wk_adxr_new", (DL_FUNC)&wk_adxr_new, 1}, {"wk_adxr_update", (DL_FUNC)&wk_adxr_update, 7}, {"wk_adxr_batch", (DL_FUNC)&wk_adxr_batch, 7}, + {"wk_adxr_warmup_period", (DL_FUNC)&wk_adxr_warmup_period, 1}, + {"wk_adxr_is_ready", (DL_FUNC)&wk_adxr_is_ready, 1}, {"wk_adxr_reset", (DL_FUNC)&wk_adxr_reset, 1}, {"wk_alligator_new", (DL_FUNC)&wk_alligator_new, 3}, {"wk_alligator_update", (DL_FUNC)&wk_alligator_update, 7}, + {"wk_alligator_warmup_period", (DL_FUNC)&wk_alligator_warmup_period, 1}, + {"wk_alligator_is_ready", (DL_FUNC)&wk_alligator_is_ready, 1}, {"wk_alligator_reset", (DL_FUNC)&wk_alligator_reset, 1}, {"wk_alma_new", (DL_FUNC)&wk_alma_new, 3}, {"wk_alma_update", (DL_FUNC)&wk_alma_update, 2}, {"wk_alma_batch", (DL_FUNC)&wk_alma_batch, 2}, + {"wk_alma_warmup_period", (DL_FUNC)&wk_alma_warmup_period, 1}, + {"wk_alma_is_ready", (DL_FUNC)&wk_alma_is_ready, 1}, {"wk_alma_reset", (DL_FUNC)&wk_alma_reset, 1}, {"wk_alpha_new", (DL_FUNC)&wk_alpha_new, 2}, {"wk_alpha_update", (DL_FUNC)&wk_alpha_update, 3}, {"wk_alpha_batch", (DL_FUNC)&wk_alpha_batch, 3}, + {"wk_alpha_warmup_period", (DL_FUNC)&wk_alpha_warmup_period, 1}, + {"wk_alpha_is_ready", (DL_FUNC)&wk_alpha_is_ready, 1}, {"wk_alpha_reset", (DL_FUNC)&wk_alpha_reset, 1}, {"wk_amihud_illiquidity_new", (DL_FUNC)&wk_amihud_illiquidity_new, 1}, {"wk_amihud_illiquidity_update", (DL_FUNC)&wk_amihud_illiquidity_update, 5}, + {"wk_amihud_illiquidity_warmup_period", (DL_FUNC)&wk_amihud_illiquidity_warmup_period, 1}, + {"wk_amihud_illiquidity_is_ready", (DL_FUNC)&wk_amihud_illiquidity_is_ready, 1}, {"wk_amihud_illiquidity_reset", (DL_FUNC)&wk_amihud_illiquidity_reset, 1}, {"wk_anchored_rsi_new", (DL_FUNC)&wk_anchored_rsi_new, 0}, {"wk_anchored_rsi_update", (DL_FUNC)&wk_anchored_rsi_update, 2}, {"wk_anchored_rsi_batch", (DL_FUNC)&wk_anchored_rsi_batch, 2}, + {"wk_anchored_rsi_warmup_period", (DL_FUNC)&wk_anchored_rsi_warmup_period, 1}, + {"wk_anchored_rsi_is_ready", (DL_FUNC)&wk_anchored_rsi_is_ready, 1}, {"wk_anchored_rsi_reset", (DL_FUNC)&wk_anchored_rsi_reset, 1}, {"wk_anchored_vwap_new", (DL_FUNC)&wk_anchored_vwap_new, 0}, {"wk_anchored_vwap_update", (DL_FUNC)&wk_anchored_vwap_update, 7}, {"wk_anchored_vwap_batch", (DL_FUNC)&wk_anchored_vwap_batch, 7}, + {"wk_anchored_vwap_warmup_period", (DL_FUNC)&wk_anchored_vwap_warmup_period, 1}, + {"wk_anchored_vwap_is_ready", (DL_FUNC)&wk_anchored_vwap_is_ready, 1}, {"wk_anchored_vwap_reset", (DL_FUNC)&wk_anchored_vwap_reset, 1}, {"wk_andrews_pitchfork_new", (DL_FUNC)&wk_andrews_pitchfork_new, 1}, {"wk_andrews_pitchfork_update", (DL_FUNC)&wk_andrews_pitchfork_update, 7}, + {"wk_andrews_pitchfork_warmup_period", (DL_FUNC)&wk_andrews_pitchfork_warmup_period, 1}, + {"wk_andrews_pitchfork_is_ready", (DL_FUNC)&wk_andrews_pitchfork_is_ready, 1}, {"wk_andrews_pitchfork_reset", (DL_FUNC)&wk_andrews_pitchfork_reset, 1}, {"wk_apo_new", (DL_FUNC)&wk_apo_new, 2}, {"wk_apo_update", (DL_FUNC)&wk_apo_update, 2}, {"wk_apo_batch", (DL_FUNC)&wk_apo_batch, 2}, + {"wk_apo_warmup_period", (DL_FUNC)&wk_apo_warmup_period, 1}, + {"wk_apo_is_ready", (DL_FUNC)&wk_apo_is_ready, 1}, {"wk_apo_reset", (DL_FUNC)&wk_apo_reset, 1}, {"wk_aroon_new", (DL_FUNC)&wk_aroon_new, 1}, {"wk_aroon_update", (DL_FUNC)&wk_aroon_update, 7}, + {"wk_aroon_warmup_period", (DL_FUNC)&wk_aroon_warmup_period, 1}, + {"wk_aroon_is_ready", (DL_FUNC)&wk_aroon_is_ready, 1}, {"wk_aroon_reset", (DL_FUNC)&wk_aroon_reset, 1}, {"wk_aroon_oscillator_new", (DL_FUNC)&wk_aroon_oscillator_new, 1}, {"wk_aroon_oscillator_update", (DL_FUNC)&wk_aroon_oscillator_update, 7}, {"wk_aroon_oscillator_batch", (DL_FUNC)&wk_aroon_oscillator_batch, 7}, + {"wk_aroon_oscillator_warmup_period", (DL_FUNC)&wk_aroon_oscillator_warmup_period, 1}, + {"wk_aroon_oscillator_is_ready", (DL_FUNC)&wk_aroon_oscillator_is_ready, 1}, {"wk_aroon_oscillator_reset", (DL_FUNC)&wk_aroon_oscillator_reset, 1}, {"wk_atr_new", (DL_FUNC)&wk_atr_new, 1}, {"wk_atr_update", (DL_FUNC)&wk_atr_update, 7}, {"wk_atr_batch", (DL_FUNC)&wk_atr_batch, 7}, + {"wk_atr_warmup_period", (DL_FUNC)&wk_atr_warmup_period, 1}, + {"wk_atr_is_ready", (DL_FUNC)&wk_atr_is_ready, 1}, {"wk_atr_reset", (DL_FUNC)&wk_atr_reset, 1}, {"wk_atr_bands_new", (DL_FUNC)&wk_atr_bands_new, 2}, {"wk_atr_bands_update", (DL_FUNC)&wk_atr_bands_update, 7}, + {"wk_atr_bands_warmup_period", (DL_FUNC)&wk_atr_bands_warmup_period, 1}, + {"wk_atr_bands_is_ready", (DL_FUNC)&wk_atr_bands_is_ready, 1}, {"wk_atr_bands_reset", (DL_FUNC)&wk_atr_bands_reset, 1}, {"wk_atr_ratchet_new", (DL_FUNC)&wk_atr_ratchet_new, 3}, {"wk_atr_ratchet_update", (DL_FUNC)&wk_atr_ratchet_update, 7}, + {"wk_atr_ratchet_warmup_period", (DL_FUNC)&wk_atr_ratchet_warmup_period, 1}, + {"wk_atr_ratchet_is_ready", (DL_FUNC)&wk_atr_ratchet_is_ready, 1}, {"wk_atr_ratchet_reset", (DL_FUNC)&wk_atr_ratchet_reset, 1}, {"wk_atr_trailing_stop_new", (DL_FUNC)&wk_atr_trailing_stop_new, 2}, {"wk_atr_trailing_stop_update", (DL_FUNC)&wk_atr_trailing_stop_update, 7}, {"wk_atr_trailing_stop_batch", (DL_FUNC)&wk_atr_trailing_stop_batch, 7}, + {"wk_atr_trailing_stop_warmup_period", (DL_FUNC)&wk_atr_trailing_stop_warmup_period, 1}, + {"wk_atr_trailing_stop_is_ready", (DL_FUNC)&wk_atr_trailing_stop_is_ready, 1}, {"wk_atr_trailing_stop_reset", (DL_FUNC)&wk_atr_trailing_stop_reset, 1}, {"wk_auto_fib_new", (DL_FUNC)&wk_auto_fib_new, 0}, {"wk_auto_fib_update", (DL_FUNC)&wk_auto_fib_update, 7}, + {"wk_auto_fib_warmup_period", (DL_FUNC)&wk_auto_fib_warmup_period, 1}, + {"wk_auto_fib_is_ready", (DL_FUNC)&wk_auto_fib_is_ready, 1}, {"wk_auto_fib_reset", (DL_FUNC)&wk_auto_fib_reset, 1}, {"wk_autocorrelation_new", (DL_FUNC)&wk_autocorrelation_new, 2}, {"wk_autocorrelation_update", (DL_FUNC)&wk_autocorrelation_update, 2}, {"wk_autocorrelation_batch", (DL_FUNC)&wk_autocorrelation_batch, 2}, + {"wk_autocorrelation_warmup_period", (DL_FUNC)&wk_autocorrelation_warmup_period, 1}, + {"wk_autocorrelation_is_ready", (DL_FUNC)&wk_autocorrelation_is_ready, 1}, {"wk_autocorrelation_reset", (DL_FUNC)&wk_autocorrelation_reset, 1}, {"wk_autocorrelation_periodogram_new", (DL_FUNC)&wk_autocorrelation_periodogram_new, 2}, {"wk_autocorrelation_periodogram_update", (DL_FUNC)&wk_autocorrelation_periodogram_update, 2}, {"wk_autocorrelation_periodogram_batch", (DL_FUNC)&wk_autocorrelation_periodogram_batch, 2}, + {"wk_autocorrelation_periodogram_warmup_period", (DL_FUNC)&wk_autocorrelation_periodogram_warmup_period, 1}, + {"wk_autocorrelation_periodogram_is_ready", (DL_FUNC)&wk_autocorrelation_periodogram_is_ready, 1}, {"wk_autocorrelation_periodogram_reset", (DL_FUNC)&wk_autocorrelation_periodogram_reset, 1}, {"wk_average_daily_range_new", (DL_FUNC)&wk_average_daily_range_new, 2}, {"wk_average_daily_range_update", (DL_FUNC)&wk_average_daily_range_update, 7}, {"wk_average_daily_range_batch", (DL_FUNC)&wk_average_daily_range_batch, 7}, + {"wk_average_daily_range_warmup_period", (DL_FUNC)&wk_average_daily_range_warmup_period, 1}, + {"wk_average_daily_range_is_ready", (DL_FUNC)&wk_average_daily_range_is_ready, 1}, {"wk_average_daily_range_reset", (DL_FUNC)&wk_average_daily_range_reset, 1}, {"wk_average_drawdown_new", (DL_FUNC)&wk_average_drawdown_new, 1}, {"wk_average_drawdown_update", (DL_FUNC)&wk_average_drawdown_update, 2}, {"wk_average_drawdown_batch", (DL_FUNC)&wk_average_drawdown_batch, 2}, + {"wk_average_drawdown_warmup_period", (DL_FUNC)&wk_average_drawdown_warmup_period, 1}, + {"wk_average_drawdown_is_ready", (DL_FUNC)&wk_average_drawdown_is_ready, 1}, {"wk_average_drawdown_reset", (DL_FUNC)&wk_average_drawdown_reset, 1}, {"wk_avg_price_new", (DL_FUNC)&wk_avg_price_new, 0}, {"wk_avg_price_update", (DL_FUNC)&wk_avg_price_update, 7}, {"wk_avg_price_batch", (DL_FUNC)&wk_avg_price_batch, 7}, + {"wk_avg_price_warmup_period", (DL_FUNC)&wk_avg_price_warmup_period, 1}, + {"wk_avg_price_is_ready", (DL_FUNC)&wk_avg_price_is_ready, 1}, {"wk_avg_price_reset", (DL_FUNC)&wk_avg_price_reset, 1}, {"wk_awesome_oscillator_new", (DL_FUNC)&wk_awesome_oscillator_new, 2}, {"wk_awesome_oscillator_update", (DL_FUNC)&wk_awesome_oscillator_update, 7}, {"wk_awesome_oscillator_batch", (DL_FUNC)&wk_awesome_oscillator_batch, 7}, + {"wk_awesome_oscillator_warmup_period", (DL_FUNC)&wk_awesome_oscillator_warmup_period, 1}, + {"wk_awesome_oscillator_is_ready", (DL_FUNC)&wk_awesome_oscillator_is_ready, 1}, {"wk_awesome_oscillator_reset", (DL_FUNC)&wk_awesome_oscillator_reset, 1}, {"wk_awesome_oscillator_histogram_new", (DL_FUNC)&wk_awesome_oscillator_histogram_new, 3}, {"wk_awesome_oscillator_histogram_update", (DL_FUNC)&wk_awesome_oscillator_histogram_update, 7}, {"wk_awesome_oscillator_histogram_batch", (DL_FUNC)&wk_awesome_oscillator_histogram_batch, 7}, + {"wk_awesome_oscillator_histogram_warmup_period", (DL_FUNC)&wk_awesome_oscillator_histogram_warmup_period, 1}, + {"wk_awesome_oscillator_histogram_is_ready", (DL_FUNC)&wk_awesome_oscillator_histogram_is_ready, 1}, {"wk_awesome_oscillator_histogram_reset", (DL_FUNC)&wk_awesome_oscillator_histogram_reset, 1}, {"wk_balance_of_power_new", (DL_FUNC)&wk_balance_of_power_new, 0}, {"wk_balance_of_power_update", (DL_FUNC)&wk_balance_of_power_update, 7}, {"wk_balance_of_power_batch", (DL_FUNC)&wk_balance_of_power_batch, 7}, + {"wk_balance_of_power_warmup_period", (DL_FUNC)&wk_balance_of_power_warmup_period, 1}, + {"wk_balance_of_power_is_ready", (DL_FUNC)&wk_balance_of_power_is_ready, 1}, {"wk_balance_of_power_reset", (DL_FUNC)&wk_balance_of_power_reset, 1}, {"wk_bandpass_filter_new", (DL_FUNC)&wk_bandpass_filter_new, 2}, {"wk_bandpass_filter_update", (DL_FUNC)&wk_bandpass_filter_update, 2}, {"wk_bandpass_filter_batch", (DL_FUNC)&wk_bandpass_filter_batch, 2}, + {"wk_bandpass_filter_warmup_period", (DL_FUNC)&wk_bandpass_filter_warmup_period, 1}, + {"wk_bandpass_filter_is_ready", (DL_FUNC)&wk_bandpass_filter_is_ready, 1}, {"wk_bandpass_filter_reset", (DL_FUNC)&wk_bandpass_filter_reset, 1}, {"wk_bat_new", (DL_FUNC)&wk_bat_new, 0}, {"wk_bat_update", (DL_FUNC)&wk_bat_update, 7}, {"wk_bat_batch", (DL_FUNC)&wk_bat_batch, 7}, + {"wk_bat_warmup_period", (DL_FUNC)&wk_bat_warmup_period, 1}, + {"wk_bat_is_ready", (DL_FUNC)&wk_bat_is_ready, 1}, {"wk_bat_reset", (DL_FUNC)&wk_bat_reset, 1}, {"wk_belt_hold_new", (DL_FUNC)&wk_belt_hold_new, 0}, {"wk_belt_hold_update", (DL_FUNC)&wk_belt_hold_update, 7}, {"wk_belt_hold_batch", (DL_FUNC)&wk_belt_hold_batch, 7}, + {"wk_belt_hold_warmup_period", (DL_FUNC)&wk_belt_hold_warmup_period, 1}, + {"wk_belt_hold_is_ready", (DL_FUNC)&wk_belt_hold_is_ready, 1}, {"wk_belt_hold_reset", (DL_FUNC)&wk_belt_hold_reset, 1}, {"wk_beta_new", (DL_FUNC)&wk_beta_new, 1}, {"wk_beta_update", (DL_FUNC)&wk_beta_update, 3}, {"wk_beta_batch", (DL_FUNC)&wk_beta_batch, 3}, + {"wk_beta_warmup_period", (DL_FUNC)&wk_beta_warmup_period, 1}, + {"wk_beta_is_ready", (DL_FUNC)&wk_beta_is_ready, 1}, {"wk_beta_reset", (DL_FUNC)&wk_beta_reset, 1}, {"wk_beta_neutral_spread_new", (DL_FUNC)&wk_beta_neutral_spread_new, 1}, {"wk_beta_neutral_spread_update", (DL_FUNC)&wk_beta_neutral_spread_update, 3}, {"wk_beta_neutral_spread_batch", (DL_FUNC)&wk_beta_neutral_spread_batch, 3}, + {"wk_beta_neutral_spread_warmup_period", (DL_FUNC)&wk_beta_neutral_spread_warmup_period, 1}, + {"wk_beta_neutral_spread_is_ready", (DL_FUNC)&wk_beta_neutral_spread_is_ready, 1}, {"wk_beta_neutral_spread_reset", (DL_FUNC)&wk_beta_neutral_spread_reset, 1}, {"wk_better_volume_new", (DL_FUNC)&wk_better_volume_new, 1}, {"wk_better_volume_update", (DL_FUNC)&wk_better_volume_update, 7}, {"wk_better_volume_batch", (DL_FUNC)&wk_better_volume_batch, 7}, + {"wk_better_volume_warmup_period", (DL_FUNC)&wk_better_volume_warmup_period, 1}, + {"wk_better_volume_is_ready", (DL_FUNC)&wk_better_volume_is_ready, 1}, {"wk_better_volume_reset", (DL_FUNC)&wk_better_volume_reset, 1}, {"wk_bipower_variation_new", (DL_FUNC)&wk_bipower_variation_new, 1}, {"wk_bipower_variation_update", (DL_FUNC)&wk_bipower_variation_update, 2}, {"wk_bipower_variation_batch", (DL_FUNC)&wk_bipower_variation_batch, 2}, + {"wk_bipower_variation_warmup_period", (DL_FUNC)&wk_bipower_variation_warmup_period, 1}, + {"wk_bipower_variation_is_ready", (DL_FUNC)&wk_bipower_variation_is_ready, 1}, {"wk_bipower_variation_reset", (DL_FUNC)&wk_bipower_variation_reset, 1}, {"wk_body_size_pct_new", (DL_FUNC)&wk_body_size_pct_new, 0}, {"wk_body_size_pct_update", (DL_FUNC)&wk_body_size_pct_update, 7}, {"wk_body_size_pct_batch", (DL_FUNC)&wk_body_size_pct_batch, 7}, + {"wk_body_size_pct_warmup_period", (DL_FUNC)&wk_body_size_pct_warmup_period, 1}, + {"wk_body_size_pct_is_ready", (DL_FUNC)&wk_body_size_pct_is_ready, 1}, {"wk_body_size_pct_reset", (DL_FUNC)&wk_body_size_pct_reset, 1}, {"wk_bollinger_bands_new", (DL_FUNC)&wk_bollinger_bands_new, 2}, {"wk_bollinger_bands_update", (DL_FUNC)&wk_bollinger_bands_update, 2}, + {"wk_bollinger_bands_warmup_period", (DL_FUNC)&wk_bollinger_bands_warmup_period, 1}, + {"wk_bollinger_bands_is_ready", (DL_FUNC)&wk_bollinger_bands_is_ready, 1}, {"wk_bollinger_bands_reset", (DL_FUNC)&wk_bollinger_bands_reset, 1}, {"wk_bollinger_bandwidth_new", (DL_FUNC)&wk_bollinger_bandwidth_new, 2}, {"wk_bollinger_bandwidth_update", (DL_FUNC)&wk_bollinger_bandwidth_update, 2}, {"wk_bollinger_bandwidth_batch", (DL_FUNC)&wk_bollinger_bandwidth_batch, 2}, + {"wk_bollinger_bandwidth_warmup_period", (DL_FUNC)&wk_bollinger_bandwidth_warmup_period, 1}, + {"wk_bollinger_bandwidth_is_ready", (DL_FUNC)&wk_bollinger_bandwidth_is_ready, 1}, {"wk_bollinger_bandwidth_reset", (DL_FUNC)&wk_bollinger_bandwidth_reset, 1}, {"wk_bomar_bands_new", (DL_FUNC)&wk_bomar_bands_new, 2}, {"wk_bomar_bands_update", (DL_FUNC)&wk_bomar_bands_update, 2}, + {"wk_bomar_bands_warmup_period", (DL_FUNC)&wk_bomar_bands_warmup_period, 1}, + {"wk_bomar_bands_is_ready", (DL_FUNC)&wk_bomar_bands_is_ready, 1}, {"wk_bomar_bands_reset", (DL_FUNC)&wk_bomar_bands_reset, 1}, {"wk_breadth_thrust_new", (DL_FUNC)&wk_breadth_thrust_new, 1}, {"wk_breadth_thrust_update", (DL_FUNC)&wk_breadth_thrust_update, 8}, + {"wk_breadth_thrust_warmup_period", (DL_FUNC)&wk_breadth_thrust_warmup_period, 1}, + {"wk_breadth_thrust_is_ready", (DL_FUNC)&wk_breadth_thrust_is_ready, 1}, {"wk_breadth_thrust_reset", (DL_FUNC)&wk_breadth_thrust_reset, 1}, {"wk_breakaway_new", (DL_FUNC)&wk_breakaway_new, 0}, {"wk_breakaway_update", (DL_FUNC)&wk_breakaway_update, 7}, {"wk_breakaway_batch", (DL_FUNC)&wk_breakaway_batch, 7}, + {"wk_breakaway_warmup_period", (DL_FUNC)&wk_breakaway_warmup_period, 1}, + {"wk_breakaway_is_ready", (DL_FUNC)&wk_breakaway_is_ready, 1}, {"wk_breakaway_reset", (DL_FUNC)&wk_breakaway_reset, 1}, {"wk_bullish_percent_index_new", (DL_FUNC)&wk_bullish_percent_index_new, 0}, {"wk_bullish_percent_index_update", (DL_FUNC)&wk_bullish_percent_index_update, 8}, + {"wk_bullish_percent_index_warmup_period", (DL_FUNC)&wk_bullish_percent_index_warmup_period, 1}, + {"wk_bullish_percent_index_is_ready", (DL_FUNC)&wk_bullish_percent_index_is_ready, 1}, {"wk_bullish_percent_index_reset", (DL_FUNC)&wk_bullish_percent_index_reset, 1}, {"wk_burke_ratio_new", (DL_FUNC)&wk_burke_ratio_new, 1}, {"wk_burke_ratio_update", (DL_FUNC)&wk_burke_ratio_update, 2}, {"wk_burke_ratio_batch", (DL_FUNC)&wk_burke_ratio_batch, 2}, + {"wk_burke_ratio_warmup_period", (DL_FUNC)&wk_burke_ratio_warmup_period, 1}, + {"wk_burke_ratio_is_ready", (DL_FUNC)&wk_burke_ratio_is_ready, 1}, {"wk_burke_ratio_reset", (DL_FUNC)&wk_burke_ratio_reset, 1}, {"wk_butterfly_new", (DL_FUNC)&wk_butterfly_new, 0}, {"wk_butterfly_update", (DL_FUNC)&wk_butterfly_update, 7}, {"wk_butterfly_batch", (DL_FUNC)&wk_butterfly_batch, 7}, + {"wk_butterfly_warmup_period", (DL_FUNC)&wk_butterfly_warmup_period, 1}, + {"wk_butterfly_is_ready", (DL_FUNC)&wk_butterfly_is_ready, 1}, {"wk_butterfly_reset", (DL_FUNC)&wk_butterfly_reset, 1}, {"wk_calendar_spread_new", (DL_FUNC)&wk_calendar_spread_new, 0}, {"wk_calendar_spread_update", (DL_FUNC)&wk_calendar_spread_update, 13}, + {"wk_calendar_spread_warmup_period", (DL_FUNC)&wk_calendar_spread_warmup_period, 1}, + {"wk_calendar_spread_is_ready", (DL_FUNC)&wk_calendar_spread_is_ready, 1}, {"wk_calendar_spread_reset", (DL_FUNC)&wk_calendar_spread_reset, 1}, {"wk_calmar_ratio_new", (DL_FUNC)&wk_calmar_ratio_new, 1}, {"wk_calmar_ratio_update", (DL_FUNC)&wk_calmar_ratio_update, 2}, {"wk_calmar_ratio_batch", (DL_FUNC)&wk_calmar_ratio_batch, 2}, + {"wk_calmar_ratio_warmup_period", (DL_FUNC)&wk_calmar_ratio_warmup_period, 1}, + {"wk_calmar_ratio_is_ready", (DL_FUNC)&wk_calmar_ratio_is_ready, 1}, {"wk_calmar_ratio_reset", (DL_FUNC)&wk_calmar_ratio_reset, 1}, {"wk_camarilla_new", (DL_FUNC)&wk_camarilla_new, 0}, {"wk_camarilla_update", (DL_FUNC)&wk_camarilla_update, 7}, + {"wk_camarilla_warmup_period", (DL_FUNC)&wk_camarilla_warmup_period, 1}, + {"wk_camarilla_is_ready", (DL_FUNC)&wk_camarilla_is_ready, 1}, {"wk_camarilla_reset", (DL_FUNC)&wk_camarilla_reset, 1}, {"wk_candle_volume_new", (DL_FUNC)&wk_candle_volume_new, 1}, {"wk_candle_volume_update", (DL_FUNC)&wk_candle_volume_update, 7}, + {"wk_candle_volume_warmup_period", (DL_FUNC)&wk_candle_volume_warmup_period, 1}, + {"wk_candle_volume_is_ready", (DL_FUNC)&wk_candle_volume_is_ready, 1}, {"wk_candle_volume_reset", (DL_FUNC)&wk_candle_volume_reset, 1}, {"wk_cci_new", (DL_FUNC)&wk_cci_new, 1}, {"wk_cci_update", (DL_FUNC)&wk_cci_update, 7}, {"wk_cci_batch", (DL_FUNC)&wk_cci_batch, 7}, + {"wk_cci_warmup_period", (DL_FUNC)&wk_cci_warmup_period, 1}, + {"wk_cci_is_ready", (DL_FUNC)&wk_cci_is_ready, 1}, {"wk_cci_reset", (DL_FUNC)&wk_cci_reset, 1}, {"wk_center_of_gravity_new", (DL_FUNC)&wk_center_of_gravity_new, 1}, {"wk_center_of_gravity_update", (DL_FUNC)&wk_center_of_gravity_update, 2}, {"wk_center_of_gravity_batch", (DL_FUNC)&wk_center_of_gravity_batch, 2}, + {"wk_center_of_gravity_warmup_period", (DL_FUNC)&wk_center_of_gravity_warmup_period, 1}, + {"wk_center_of_gravity_is_ready", (DL_FUNC)&wk_center_of_gravity_is_ready, 1}, {"wk_center_of_gravity_reset", (DL_FUNC)&wk_center_of_gravity_reset, 1}, {"wk_central_pivot_range_new", (DL_FUNC)&wk_central_pivot_range_new, 0}, {"wk_central_pivot_range_update", (DL_FUNC)&wk_central_pivot_range_update, 7}, + {"wk_central_pivot_range_warmup_period", (DL_FUNC)&wk_central_pivot_range_warmup_period, 1}, + {"wk_central_pivot_range_is_ready", (DL_FUNC)&wk_central_pivot_range_is_ready, 1}, {"wk_central_pivot_range_reset", (DL_FUNC)&wk_central_pivot_range_reset, 1}, {"wk_cfo_new", (DL_FUNC)&wk_cfo_new, 1}, {"wk_cfo_update", (DL_FUNC)&wk_cfo_update, 2}, {"wk_cfo_batch", (DL_FUNC)&wk_cfo_batch, 2}, + {"wk_cfo_warmup_period", (DL_FUNC)&wk_cfo_warmup_period, 1}, + {"wk_cfo_is_ready", (DL_FUNC)&wk_cfo_is_ready, 1}, {"wk_cfo_reset", (DL_FUNC)&wk_cfo_reset, 1}, {"wk_chaikin_money_flow_new", (DL_FUNC)&wk_chaikin_money_flow_new, 1}, {"wk_chaikin_money_flow_update", (DL_FUNC)&wk_chaikin_money_flow_update, 7}, {"wk_chaikin_money_flow_batch", (DL_FUNC)&wk_chaikin_money_flow_batch, 7}, + {"wk_chaikin_money_flow_warmup_period", (DL_FUNC)&wk_chaikin_money_flow_warmup_period, 1}, + {"wk_chaikin_money_flow_is_ready", (DL_FUNC)&wk_chaikin_money_flow_is_ready, 1}, {"wk_chaikin_money_flow_reset", (DL_FUNC)&wk_chaikin_money_flow_reset, 1}, {"wk_chaikin_oscillator_new", (DL_FUNC)&wk_chaikin_oscillator_new, 2}, {"wk_chaikin_oscillator_update", (DL_FUNC)&wk_chaikin_oscillator_update, 7}, {"wk_chaikin_oscillator_batch", (DL_FUNC)&wk_chaikin_oscillator_batch, 7}, + {"wk_chaikin_oscillator_warmup_period", (DL_FUNC)&wk_chaikin_oscillator_warmup_period, 1}, + {"wk_chaikin_oscillator_is_ready", (DL_FUNC)&wk_chaikin_oscillator_is_ready, 1}, {"wk_chaikin_oscillator_reset", (DL_FUNC)&wk_chaikin_oscillator_reset, 1}, {"wk_chaikin_volatility_new", (DL_FUNC)&wk_chaikin_volatility_new, 2}, {"wk_chaikin_volatility_update", (DL_FUNC)&wk_chaikin_volatility_update, 7}, {"wk_chaikin_volatility_batch", (DL_FUNC)&wk_chaikin_volatility_batch, 7}, + {"wk_chaikin_volatility_warmup_period", (DL_FUNC)&wk_chaikin_volatility_warmup_period, 1}, + {"wk_chaikin_volatility_is_ready", (DL_FUNC)&wk_chaikin_volatility_is_ready, 1}, {"wk_chaikin_volatility_reset", (DL_FUNC)&wk_chaikin_volatility_reset, 1}, {"wk_chande_kroll_stop_new", (DL_FUNC)&wk_chande_kroll_stop_new, 3}, {"wk_chande_kroll_stop_update", (DL_FUNC)&wk_chande_kroll_stop_update, 7}, + {"wk_chande_kroll_stop_warmup_period", (DL_FUNC)&wk_chande_kroll_stop_warmup_period, 1}, + {"wk_chande_kroll_stop_is_ready", (DL_FUNC)&wk_chande_kroll_stop_is_ready, 1}, {"wk_chande_kroll_stop_reset", (DL_FUNC)&wk_chande_kroll_stop_reset, 1}, {"wk_chandelier_exit_new", (DL_FUNC)&wk_chandelier_exit_new, 2}, {"wk_chandelier_exit_update", (DL_FUNC)&wk_chandelier_exit_update, 7}, + {"wk_chandelier_exit_warmup_period", (DL_FUNC)&wk_chandelier_exit_warmup_period, 1}, + {"wk_chandelier_exit_is_ready", (DL_FUNC)&wk_chandelier_exit_is_ready, 1}, {"wk_chandelier_exit_reset", (DL_FUNC)&wk_chandelier_exit_reset, 1}, {"wk_choppiness_index_new", (DL_FUNC)&wk_choppiness_index_new, 1}, {"wk_choppiness_index_update", (DL_FUNC)&wk_choppiness_index_update, 7}, {"wk_choppiness_index_batch", (DL_FUNC)&wk_choppiness_index_batch, 7}, + {"wk_choppiness_index_warmup_period", (DL_FUNC)&wk_choppiness_index_warmup_period, 1}, + {"wk_choppiness_index_is_ready", (DL_FUNC)&wk_choppiness_index_is_ready, 1}, {"wk_choppiness_index_reset", (DL_FUNC)&wk_choppiness_index_reset, 1}, {"wk_classic_pivots_new", (DL_FUNC)&wk_classic_pivots_new, 0}, {"wk_classic_pivots_update", (DL_FUNC)&wk_classic_pivots_update, 7}, + {"wk_classic_pivots_warmup_period", (DL_FUNC)&wk_classic_pivots_warmup_period, 1}, + {"wk_classic_pivots_is_ready", (DL_FUNC)&wk_classic_pivots_is_ready, 1}, {"wk_classic_pivots_reset", (DL_FUNC)&wk_classic_pivots_reset, 1}, {"wk_close_vs_open_new", (DL_FUNC)&wk_close_vs_open_new, 0}, {"wk_close_vs_open_update", (DL_FUNC)&wk_close_vs_open_update, 7}, {"wk_close_vs_open_batch", (DL_FUNC)&wk_close_vs_open_batch, 7}, + {"wk_close_vs_open_warmup_period", (DL_FUNC)&wk_close_vs_open_warmup_period, 1}, + {"wk_close_vs_open_is_ready", (DL_FUNC)&wk_close_vs_open_is_ready, 1}, {"wk_close_vs_open_reset", (DL_FUNC)&wk_close_vs_open_reset, 1}, {"wk_closing_marubozu_new", (DL_FUNC)&wk_closing_marubozu_new, 0}, {"wk_closing_marubozu_update", (DL_FUNC)&wk_closing_marubozu_update, 7}, {"wk_closing_marubozu_batch", (DL_FUNC)&wk_closing_marubozu_batch, 7}, + {"wk_closing_marubozu_warmup_period", (DL_FUNC)&wk_closing_marubozu_warmup_period, 1}, + {"wk_closing_marubozu_is_ready", (DL_FUNC)&wk_closing_marubozu_is_ready, 1}, {"wk_closing_marubozu_reset", (DL_FUNC)&wk_closing_marubozu_reset, 1}, {"wk_cmo_new", (DL_FUNC)&wk_cmo_new, 1}, {"wk_cmo_update", (DL_FUNC)&wk_cmo_update, 2}, {"wk_cmo_batch", (DL_FUNC)&wk_cmo_batch, 2}, + {"wk_cmo_warmup_period", (DL_FUNC)&wk_cmo_warmup_period, 1}, + {"wk_cmo_is_ready", (DL_FUNC)&wk_cmo_is_ready, 1}, {"wk_cmo_reset", (DL_FUNC)&wk_cmo_reset, 1}, {"wk_coefficient_of_variation_new", (DL_FUNC)&wk_coefficient_of_variation_new, 1}, {"wk_coefficient_of_variation_update", (DL_FUNC)&wk_coefficient_of_variation_update, 2}, {"wk_coefficient_of_variation_batch", (DL_FUNC)&wk_coefficient_of_variation_batch, 2}, + {"wk_coefficient_of_variation_warmup_period", (DL_FUNC)&wk_coefficient_of_variation_warmup_period, 1}, + {"wk_coefficient_of_variation_is_ready", (DL_FUNC)&wk_coefficient_of_variation_is_ready, 1}, {"wk_coefficient_of_variation_reset", (DL_FUNC)&wk_coefficient_of_variation_reset, 1}, {"wk_cointegration_new", (DL_FUNC)&wk_cointegration_new, 2}, {"wk_cointegration_update", (DL_FUNC)&wk_cointegration_update, 3}, + {"wk_cointegration_warmup_period", (DL_FUNC)&wk_cointegration_warmup_period, 1}, + {"wk_cointegration_is_ready", (DL_FUNC)&wk_cointegration_is_ready, 1}, {"wk_cointegration_reset", (DL_FUNC)&wk_cointegration_reset, 1}, {"wk_common_sense_ratio_new", (DL_FUNC)&wk_common_sense_ratio_new, 1}, {"wk_common_sense_ratio_update", (DL_FUNC)&wk_common_sense_ratio_update, 2}, {"wk_common_sense_ratio_batch", (DL_FUNC)&wk_common_sense_ratio_batch, 2}, + {"wk_common_sense_ratio_warmup_period", (DL_FUNC)&wk_common_sense_ratio_warmup_period, 1}, + {"wk_common_sense_ratio_is_ready", (DL_FUNC)&wk_common_sense_ratio_is_ready, 1}, {"wk_common_sense_ratio_reset", (DL_FUNC)&wk_common_sense_ratio_reset, 1}, {"wk_composite_profile_new", (DL_FUNC)&wk_composite_profile_new, 3}, {"wk_composite_profile_update", (DL_FUNC)&wk_composite_profile_update, 7}, + {"wk_composite_profile_warmup_period", (DL_FUNC)&wk_composite_profile_warmup_period, 1}, + {"wk_composite_profile_is_ready", (DL_FUNC)&wk_composite_profile_is_ready, 1}, {"wk_composite_profile_reset", (DL_FUNC)&wk_composite_profile_reset, 1}, {"wk_concealing_baby_swallow_new", (DL_FUNC)&wk_concealing_baby_swallow_new, 0}, {"wk_concealing_baby_swallow_update", (DL_FUNC)&wk_concealing_baby_swallow_update, 7}, {"wk_concealing_baby_swallow_batch", (DL_FUNC)&wk_concealing_baby_swallow_batch, 7}, + {"wk_concealing_baby_swallow_warmup_period", (DL_FUNC)&wk_concealing_baby_swallow_warmup_period, 1}, + {"wk_concealing_baby_swallow_is_ready", (DL_FUNC)&wk_concealing_baby_swallow_is_ready, 1}, {"wk_concealing_baby_swallow_reset", (DL_FUNC)&wk_concealing_baby_swallow_reset, 1}, {"wk_conditional_value_at_risk_new", (DL_FUNC)&wk_conditional_value_at_risk_new, 2}, {"wk_conditional_value_at_risk_update", (DL_FUNC)&wk_conditional_value_at_risk_update, 2}, {"wk_conditional_value_at_risk_batch", (DL_FUNC)&wk_conditional_value_at_risk_batch, 2}, + {"wk_conditional_value_at_risk_warmup_period", (DL_FUNC)&wk_conditional_value_at_risk_warmup_period, 1}, + {"wk_conditional_value_at_risk_is_ready", (DL_FUNC)&wk_conditional_value_at_risk_is_ready, 1}, {"wk_conditional_value_at_risk_reset", (DL_FUNC)&wk_conditional_value_at_risk_reset, 1}, {"wk_connors_rsi_new", (DL_FUNC)&wk_connors_rsi_new, 3}, {"wk_connors_rsi_update", (DL_FUNC)&wk_connors_rsi_update, 2}, {"wk_connors_rsi_batch", (DL_FUNC)&wk_connors_rsi_batch, 2}, + {"wk_connors_rsi_warmup_period", (DL_FUNC)&wk_connors_rsi_warmup_period, 1}, + {"wk_connors_rsi_is_ready", (DL_FUNC)&wk_connors_rsi_is_ready, 1}, {"wk_connors_rsi_reset", (DL_FUNC)&wk_connors_rsi_reset, 1}, {"wk_coppock_new", (DL_FUNC)&wk_coppock_new, 3}, {"wk_coppock_update", (DL_FUNC)&wk_coppock_update, 2}, {"wk_coppock_batch", (DL_FUNC)&wk_coppock_batch, 2}, + {"wk_coppock_warmup_period", (DL_FUNC)&wk_coppock_warmup_period, 1}, + {"wk_coppock_is_ready", (DL_FUNC)&wk_coppock_is_ready, 1}, {"wk_coppock_reset", (DL_FUNC)&wk_coppock_reset, 1}, {"wk_correlation_trend_indicator_new", (DL_FUNC)&wk_correlation_trend_indicator_new, 1}, {"wk_correlation_trend_indicator_update", (DL_FUNC)&wk_correlation_trend_indicator_update, 2}, {"wk_correlation_trend_indicator_batch", (DL_FUNC)&wk_correlation_trend_indicator_batch, 2}, + {"wk_correlation_trend_indicator_warmup_period", (DL_FUNC)&wk_correlation_trend_indicator_warmup_period, 1}, + {"wk_correlation_trend_indicator_is_ready", (DL_FUNC)&wk_correlation_trend_indicator_is_ready, 1}, {"wk_correlation_trend_indicator_reset", (DL_FUNC)&wk_correlation_trend_indicator_reset, 1}, {"wk_counterattack_new", (DL_FUNC)&wk_counterattack_new, 0}, {"wk_counterattack_update", (DL_FUNC)&wk_counterattack_update, 7}, {"wk_counterattack_batch", (DL_FUNC)&wk_counterattack_batch, 7}, + {"wk_counterattack_warmup_period", (DL_FUNC)&wk_counterattack_warmup_period, 1}, + {"wk_counterattack_is_ready", (DL_FUNC)&wk_counterattack_is_ready, 1}, {"wk_counterattack_reset", (DL_FUNC)&wk_counterattack_reset, 1}, {"wk_crab_new", (DL_FUNC)&wk_crab_new, 0}, {"wk_crab_update", (DL_FUNC)&wk_crab_update, 7}, {"wk_crab_batch", (DL_FUNC)&wk_crab_batch, 7}, + {"wk_crab_warmup_period", (DL_FUNC)&wk_crab_warmup_period, 1}, + {"wk_crab_is_ready", (DL_FUNC)&wk_crab_is_ready, 1}, {"wk_crab_reset", (DL_FUNC)&wk_crab_reset, 1}, {"wk_cumulative_volume_delta_new", (DL_FUNC)&wk_cumulative_volume_delta_new, 0}, {"wk_cumulative_volume_delta_update", (DL_FUNC)&wk_cumulative_volume_delta_update, 5}, + {"wk_cumulative_volume_delta_warmup_period", (DL_FUNC)&wk_cumulative_volume_delta_warmup_period, 1}, + {"wk_cumulative_volume_delta_is_ready", (DL_FUNC)&wk_cumulative_volume_delta_is_ready, 1}, {"wk_cumulative_volume_delta_reset", (DL_FUNC)&wk_cumulative_volume_delta_reset, 1}, {"wk_cumulative_volume_index_new", (DL_FUNC)&wk_cumulative_volume_index_new, 0}, {"wk_cumulative_volume_index_update", (DL_FUNC)&wk_cumulative_volume_index_update, 8}, + {"wk_cumulative_volume_index_warmup_period", (DL_FUNC)&wk_cumulative_volume_index_warmup_period, 1}, + {"wk_cumulative_volume_index_is_ready", (DL_FUNC)&wk_cumulative_volume_index_is_ready, 1}, {"wk_cumulative_volume_index_reset", (DL_FUNC)&wk_cumulative_volume_index_reset, 1}, {"wk_cup_and_handle_new", (DL_FUNC)&wk_cup_and_handle_new, 0}, {"wk_cup_and_handle_update", (DL_FUNC)&wk_cup_and_handle_update, 7}, {"wk_cup_and_handle_batch", (DL_FUNC)&wk_cup_and_handle_batch, 7}, + {"wk_cup_and_handle_warmup_period", (DL_FUNC)&wk_cup_and_handle_warmup_period, 1}, + {"wk_cup_and_handle_is_ready", (DL_FUNC)&wk_cup_and_handle_is_ready, 1}, {"wk_cup_and_handle_reset", (DL_FUNC)&wk_cup_and_handle_reset, 1}, {"wk_cybernetic_cycle_new", (DL_FUNC)&wk_cybernetic_cycle_new, 1}, {"wk_cybernetic_cycle_update", (DL_FUNC)&wk_cybernetic_cycle_update, 2}, {"wk_cybernetic_cycle_batch", (DL_FUNC)&wk_cybernetic_cycle_batch, 2}, + {"wk_cybernetic_cycle_warmup_period", (DL_FUNC)&wk_cybernetic_cycle_warmup_period, 1}, + {"wk_cybernetic_cycle_is_ready", (DL_FUNC)&wk_cybernetic_cycle_is_ready, 1}, {"wk_cybernetic_cycle_reset", (DL_FUNC)&wk_cybernetic_cycle_reset, 1}, {"wk_cypher_new", (DL_FUNC)&wk_cypher_new, 0}, {"wk_cypher_update", (DL_FUNC)&wk_cypher_update, 7}, {"wk_cypher_batch", (DL_FUNC)&wk_cypher_batch, 7}, + {"wk_cypher_warmup_period", (DL_FUNC)&wk_cypher_warmup_period, 1}, + {"wk_cypher_is_ready", (DL_FUNC)&wk_cypher_is_ready, 1}, {"wk_cypher_reset", (DL_FUNC)&wk_cypher_reset, 1}, {"wk_day_of_week_profile_new", (DL_FUNC)&wk_day_of_week_profile_new, 1}, {"wk_day_of_week_profile_update", (DL_FUNC)&wk_day_of_week_profile_update, 8}, + {"wk_day_of_week_profile_warmup_period", (DL_FUNC)&wk_day_of_week_profile_warmup_period, 1}, + {"wk_day_of_week_profile_is_ready", (DL_FUNC)&wk_day_of_week_profile_is_ready, 1}, {"wk_day_of_week_profile_reset", (DL_FUNC)&wk_day_of_week_profile_reset, 1}, {"wk_decycler_new", (DL_FUNC)&wk_decycler_new, 1}, {"wk_decycler_update", (DL_FUNC)&wk_decycler_update, 2}, {"wk_decycler_batch", (DL_FUNC)&wk_decycler_batch, 2}, + {"wk_decycler_warmup_period", (DL_FUNC)&wk_decycler_warmup_period, 1}, + {"wk_decycler_is_ready", (DL_FUNC)&wk_decycler_is_ready, 1}, {"wk_decycler_reset", (DL_FUNC)&wk_decycler_reset, 1}, {"wk_decycler_oscillator_new", (DL_FUNC)&wk_decycler_oscillator_new, 2}, {"wk_decycler_oscillator_update", (DL_FUNC)&wk_decycler_oscillator_update, 2}, {"wk_decycler_oscillator_batch", (DL_FUNC)&wk_decycler_oscillator_batch, 2}, + {"wk_decycler_oscillator_warmup_period", (DL_FUNC)&wk_decycler_oscillator_warmup_period, 1}, + {"wk_decycler_oscillator_is_ready", (DL_FUNC)&wk_decycler_oscillator_is_ready, 1}, {"wk_decycler_oscillator_reset", (DL_FUNC)&wk_decycler_oscillator_reset, 1}, {"wk_dema_new", (DL_FUNC)&wk_dema_new, 1}, {"wk_dema_update", (DL_FUNC)&wk_dema_update, 2}, {"wk_dema_batch", (DL_FUNC)&wk_dema_batch, 2}, + {"wk_dema_warmup_period", (DL_FUNC)&wk_dema_warmup_period, 1}, + {"wk_dema_is_ready", (DL_FUNC)&wk_dema_is_ready, 1}, {"wk_dema_reset", (DL_FUNC)&wk_dema_reset, 1}, {"wk_demand_index_new", (DL_FUNC)&wk_demand_index_new, 1}, {"wk_demand_index_update", (DL_FUNC)&wk_demand_index_update, 7}, {"wk_demand_index_batch", (DL_FUNC)&wk_demand_index_batch, 7}, + {"wk_demand_index_warmup_period", (DL_FUNC)&wk_demand_index_warmup_period, 1}, + {"wk_demand_index_is_ready", (DL_FUNC)&wk_demand_index_is_ready, 1}, {"wk_demand_index_reset", (DL_FUNC)&wk_demand_index_reset, 1}, {"wk_demark_pivots_new", (DL_FUNC)&wk_demark_pivots_new, 0}, {"wk_demark_pivots_update", (DL_FUNC)&wk_demark_pivots_update, 7}, + {"wk_demark_pivots_warmup_period", (DL_FUNC)&wk_demark_pivots_warmup_period, 1}, + {"wk_demark_pivots_is_ready", (DL_FUNC)&wk_demark_pivots_is_ready, 1}, {"wk_demark_pivots_reset", (DL_FUNC)&wk_demark_pivots_reset, 1}, {"wk_depth_slope_new", (DL_FUNC)&wk_depth_slope_new, 0}, {"wk_depth_slope_update", (DL_FUNC)&wk_depth_slope_update, 5}, + {"wk_depth_slope_warmup_period", (DL_FUNC)&wk_depth_slope_warmup_period, 1}, + {"wk_depth_slope_is_ready", (DL_FUNC)&wk_depth_slope_is_ready, 1}, {"wk_depth_slope_reset", (DL_FUNC)&wk_depth_slope_reset, 1}, {"wk_derivative_oscillator_new", (DL_FUNC)&wk_derivative_oscillator_new, 4}, {"wk_derivative_oscillator_update", (DL_FUNC)&wk_derivative_oscillator_update, 2}, {"wk_derivative_oscillator_batch", (DL_FUNC)&wk_derivative_oscillator_batch, 2}, + {"wk_derivative_oscillator_warmup_period", (DL_FUNC)&wk_derivative_oscillator_warmup_period, 1}, + {"wk_derivative_oscillator_is_ready", (DL_FUNC)&wk_derivative_oscillator_is_ready, 1}, {"wk_derivative_oscillator_reset", (DL_FUNC)&wk_derivative_oscillator_reset, 1}, {"wk_detrended_std_dev_new", (DL_FUNC)&wk_detrended_std_dev_new, 1}, {"wk_detrended_std_dev_update", (DL_FUNC)&wk_detrended_std_dev_update, 2}, {"wk_detrended_std_dev_batch", (DL_FUNC)&wk_detrended_std_dev_batch, 2}, + {"wk_detrended_std_dev_warmup_period", (DL_FUNC)&wk_detrended_std_dev_warmup_period, 1}, + {"wk_detrended_std_dev_is_ready", (DL_FUNC)&wk_detrended_std_dev_is_ready, 1}, {"wk_detrended_std_dev_reset", (DL_FUNC)&wk_detrended_std_dev_reset, 1}, {"wk_disparity_index_new", (DL_FUNC)&wk_disparity_index_new, 1}, {"wk_disparity_index_update", (DL_FUNC)&wk_disparity_index_update, 2}, {"wk_disparity_index_batch", (DL_FUNC)&wk_disparity_index_batch, 2}, + {"wk_disparity_index_warmup_period", (DL_FUNC)&wk_disparity_index_warmup_period, 1}, + {"wk_disparity_index_is_ready", (DL_FUNC)&wk_disparity_index_is_ready, 1}, {"wk_disparity_index_reset", (DL_FUNC)&wk_disparity_index_reset, 1}, {"wk_distance_ssd_new", (DL_FUNC)&wk_distance_ssd_new, 1}, {"wk_distance_ssd_update", (DL_FUNC)&wk_distance_ssd_update, 3}, {"wk_distance_ssd_batch", (DL_FUNC)&wk_distance_ssd_batch, 3}, + {"wk_distance_ssd_warmup_period", (DL_FUNC)&wk_distance_ssd_warmup_period, 1}, + {"wk_distance_ssd_is_ready", (DL_FUNC)&wk_distance_ssd_is_ready, 1}, {"wk_distance_ssd_reset", (DL_FUNC)&wk_distance_ssd_reset, 1}, {"wk_doji_new", (DL_FUNC)&wk_doji_new, 0}, {"wk_doji_update", (DL_FUNC)&wk_doji_update, 7}, {"wk_doji_batch", (DL_FUNC)&wk_doji_batch, 7}, + {"wk_doji_warmup_period", (DL_FUNC)&wk_doji_warmup_period, 1}, + {"wk_doji_is_ready", (DL_FUNC)&wk_doji_is_ready, 1}, {"wk_doji_reset", (DL_FUNC)&wk_doji_reset, 1}, {"wk_doji_star_new", (DL_FUNC)&wk_doji_star_new, 0}, {"wk_doji_star_update", (DL_FUNC)&wk_doji_star_update, 7}, {"wk_doji_star_batch", (DL_FUNC)&wk_doji_star_batch, 7}, + {"wk_doji_star_warmup_period", (DL_FUNC)&wk_doji_star_warmup_period, 1}, + {"wk_doji_star_is_ready", (DL_FUNC)&wk_doji_star_is_ready, 1}, {"wk_doji_star_reset", (DL_FUNC)&wk_doji_star_reset, 1}, {"wk_dollar_bars_new", (DL_FUNC)&wk_dollar_bars_new, 1}, {"wk_dollar_bars_update", (DL_FUNC)&wk_dollar_bars_update, 7}, {"wk_dollar_bars_reset", (DL_FUNC)&wk_dollar_bars_reset, 1}, {"wk_donchian_new", (DL_FUNC)&wk_donchian_new, 1}, {"wk_donchian_update", (DL_FUNC)&wk_donchian_update, 7}, + {"wk_donchian_warmup_period", (DL_FUNC)&wk_donchian_warmup_period, 1}, + {"wk_donchian_is_ready", (DL_FUNC)&wk_donchian_is_ready, 1}, {"wk_donchian_reset", (DL_FUNC)&wk_donchian_reset, 1}, {"wk_donchian_stop_new", (DL_FUNC)&wk_donchian_stop_new, 1}, {"wk_donchian_stop_update", (DL_FUNC)&wk_donchian_stop_update, 7}, + {"wk_donchian_stop_warmup_period", (DL_FUNC)&wk_donchian_stop_warmup_period, 1}, + {"wk_donchian_stop_is_ready", (DL_FUNC)&wk_donchian_stop_is_ready, 1}, {"wk_donchian_stop_reset", (DL_FUNC)&wk_donchian_stop_reset, 1}, {"wk_double_bollinger_new", (DL_FUNC)&wk_double_bollinger_new, 3}, {"wk_double_bollinger_update", (DL_FUNC)&wk_double_bollinger_update, 2}, + {"wk_double_bollinger_warmup_period", (DL_FUNC)&wk_double_bollinger_warmup_period, 1}, + {"wk_double_bollinger_is_ready", (DL_FUNC)&wk_double_bollinger_is_ready, 1}, {"wk_double_bollinger_reset", (DL_FUNC)&wk_double_bollinger_reset, 1}, {"wk_double_top_bottom_new", (DL_FUNC)&wk_double_top_bottom_new, 0}, {"wk_double_top_bottom_update", (DL_FUNC)&wk_double_top_bottom_update, 7}, {"wk_double_top_bottom_batch", (DL_FUNC)&wk_double_top_bottom_batch, 7}, + {"wk_double_top_bottom_warmup_period", (DL_FUNC)&wk_double_top_bottom_warmup_period, 1}, + {"wk_double_top_bottom_is_ready", (DL_FUNC)&wk_double_top_bottom_is_ready, 1}, {"wk_double_top_bottom_reset", (DL_FUNC)&wk_double_top_bottom_reset, 1}, {"wk_downside_gap_three_methods_new", (DL_FUNC)&wk_downside_gap_three_methods_new, 0}, {"wk_downside_gap_three_methods_update", (DL_FUNC)&wk_downside_gap_three_methods_update, 7}, {"wk_downside_gap_three_methods_batch", (DL_FUNC)&wk_downside_gap_three_methods_batch, 7}, + {"wk_downside_gap_three_methods_warmup_period", (DL_FUNC)&wk_downside_gap_three_methods_warmup_period, 1}, + {"wk_downside_gap_three_methods_is_ready", (DL_FUNC)&wk_downside_gap_three_methods_is_ready, 1}, {"wk_downside_gap_three_methods_reset", (DL_FUNC)&wk_downside_gap_three_methods_reset, 1}, {"wk_dpo_new", (DL_FUNC)&wk_dpo_new, 1}, {"wk_dpo_update", (DL_FUNC)&wk_dpo_update, 2}, {"wk_dpo_batch", (DL_FUNC)&wk_dpo_batch, 2}, + {"wk_dpo_warmup_period", (DL_FUNC)&wk_dpo_warmup_period, 1}, + {"wk_dpo_is_ready", (DL_FUNC)&wk_dpo_is_ready, 1}, {"wk_dpo_reset", (DL_FUNC)&wk_dpo_reset, 1}, {"wk_dragonfly_doji_new", (DL_FUNC)&wk_dragonfly_doji_new, 0}, {"wk_dragonfly_doji_update", (DL_FUNC)&wk_dragonfly_doji_update, 7}, {"wk_dragonfly_doji_batch", (DL_FUNC)&wk_dragonfly_doji_batch, 7}, + {"wk_dragonfly_doji_warmup_period", (DL_FUNC)&wk_dragonfly_doji_warmup_period, 1}, + {"wk_dragonfly_doji_is_ready", (DL_FUNC)&wk_dragonfly_doji_is_ready, 1}, {"wk_dragonfly_doji_reset", (DL_FUNC)&wk_dragonfly_doji_reset, 1}, {"wk_drawdown_duration_new", (DL_FUNC)&wk_drawdown_duration_new, 0}, {"wk_drawdown_duration_update", (DL_FUNC)&wk_drawdown_duration_update, 2}, {"wk_drawdown_duration_batch", (DL_FUNC)&wk_drawdown_duration_batch, 2}, + {"wk_drawdown_duration_warmup_period", (DL_FUNC)&wk_drawdown_duration_warmup_period, 1}, + {"wk_drawdown_duration_is_ready", (DL_FUNC)&wk_drawdown_duration_is_ready, 1}, {"wk_drawdown_duration_reset", (DL_FUNC)&wk_drawdown_duration_reset, 1}, {"wk_dumpling_top_new", (DL_FUNC)&wk_dumpling_top_new, 1}, {"wk_dumpling_top_update", (DL_FUNC)&wk_dumpling_top_update, 7}, {"wk_dumpling_top_batch", (DL_FUNC)&wk_dumpling_top_batch, 7}, + {"wk_dumpling_top_warmup_period", (DL_FUNC)&wk_dumpling_top_warmup_period, 1}, + {"wk_dumpling_top_is_ready", (DL_FUNC)&wk_dumpling_top_is_ready, 1}, {"wk_dumpling_top_reset", (DL_FUNC)&wk_dumpling_top_reset, 1}, {"wk_dx_new", (DL_FUNC)&wk_dx_new, 1}, {"wk_dx_update", (DL_FUNC)&wk_dx_update, 7}, {"wk_dx_batch", (DL_FUNC)&wk_dx_batch, 7}, + {"wk_dx_warmup_period", (DL_FUNC)&wk_dx_warmup_period, 1}, + {"wk_dx_is_ready", (DL_FUNC)&wk_dx_is_ready, 1}, {"wk_dx_reset", (DL_FUNC)&wk_dx_reset, 1}, {"wk_dynamic_momentum_index_new", (DL_FUNC)&wk_dynamic_momentum_index_new, 1}, {"wk_dynamic_momentum_index_update", (DL_FUNC)&wk_dynamic_momentum_index_update, 2}, {"wk_dynamic_momentum_index_batch", (DL_FUNC)&wk_dynamic_momentum_index_batch, 2}, + {"wk_dynamic_momentum_index_warmup_period", (DL_FUNC)&wk_dynamic_momentum_index_warmup_period, 1}, + {"wk_dynamic_momentum_index_is_ready", (DL_FUNC)&wk_dynamic_momentum_index_is_ready, 1}, {"wk_dynamic_momentum_index_reset", (DL_FUNC)&wk_dynamic_momentum_index_reset, 1}, {"wk_ease_of_movement_new", (DL_FUNC)&wk_ease_of_movement_new, 1}, {"wk_ease_of_movement_update", (DL_FUNC)&wk_ease_of_movement_update, 7}, {"wk_ease_of_movement_batch", (DL_FUNC)&wk_ease_of_movement_batch, 7}, + {"wk_ease_of_movement_warmup_period", (DL_FUNC)&wk_ease_of_movement_warmup_period, 1}, + {"wk_ease_of_movement_is_ready", (DL_FUNC)&wk_ease_of_movement_is_ready, 1}, {"wk_ease_of_movement_reset", (DL_FUNC)&wk_ease_of_movement_reset, 1}, {"wk_effective_spread_new", (DL_FUNC)&wk_effective_spread_new, 0}, {"wk_effective_spread_update", (DL_FUNC)&wk_effective_spread_update, 6}, + {"wk_effective_spread_warmup_period", (DL_FUNC)&wk_effective_spread_warmup_period, 1}, + {"wk_effective_spread_is_ready", (DL_FUNC)&wk_effective_spread_is_ready, 1}, {"wk_effective_spread_reset", (DL_FUNC)&wk_effective_spread_reset, 1}, {"wk_ehlers_stochastic_new", (DL_FUNC)&wk_ehlers_stochastic_new, 1}, {"wk_ehlers_stochastic_update", (DL_FUNC)&wk_ehlers_stochastic_update, 2}, {"wk_ehlers_stochastic_batch", (DL_FUNC)&wk_ehlers_stochastic_batch, 2}, + {"wk_ehlers_stochastic_warmup_period", (DL_FUNC)&wk_ehlers_stochastic_warmup_period, 1}, + {"wk_ehlers_stochastic_is_ready", (DL_FUNC)&wk_ehlers_stochastic_is_ready, 1}, {"wk_ehlers_stochastic_reset", (DL_FUNC)&wk_ehlers_stochastic_reset, 1}, {"wk_ehma_new", (DL_FUNC)&wk_ehma_new, 1}, {"wk_ehma_update", (DL_FUNC)&wk_ehma_update, 2}, {"wk_ehma_batch", (DL_FUNC)&wk_ehma_batch, 2}, + {"wk_ehma_warmup_period", (DL_FUNC)&wk_ehma_warmup_period, 1}, + {"wk_ehma_is_ready", (DL_FUNC)&wk_ehma_is_ready, 1}, {"wk_ehma_reset", (DL_FUNC)&wk_ehma_reset, 1}, {"wk_elder_impulse_new", (DL_FUNC)&wk_elder_impulse_new, 4}, {"wk_elder_impulse_update", (DL_FUNC)&wk_elder_impulse_update, 2}, {"wk_elder_impulse_batch", (DL_FUNC)&wk_elder_impulse_batch, 2}, + {"wk_elder_impulse_warmup_period", (DL_FUNC)&wk_elder_impulse_warmup_period, 1}, + {"wk_elder_impulse_is_ready", (DL_FUNC)&wk_elder_impulse_is_ready, 1}, {"wk_elder_impulse_reset", (DL_FUNC)&wk_elder_impulse_reset, 1}, {"wk_elder_ray_new", (DL_FUNC)&wk_elder_ray_new, 1}, {"wk_elder_ray_update", (DL_FUNC)&wk_elder_ray_update, 7}, + {"wk_elder_ray_warmup_period", (DL_FUNC)&wk_elder_ray_warmup_period, 1}, + {"wk_elder_ray_is_ready", (DL_FUNC)&wk_elder_ray_is_ready, 1}, {"wk_elder_ray_reset", (DL_FUNC)&wk_elder_ray_reset, 1}, {"wk_elder_safe_zone_new", (DL_FUNC)&wk_elder_safe_zone_new, 2}, {"wk_elder_safe_zone_update", (DL_FUNC)&wk_elder_safe_zone_update, 7}, + {"wk_elder_safe_zone_warmup_period", (DL_FUNC)&wk_elder_safe_zone_warmup_period, 1}, + {"wk_elder_safe_zone_is_ready", (DL_FUNC)&wk_elder_safe_zone_is_ready, 1}, {"wk_elder_safe_zone_reset", (DL_FUNC)&wk_elder_safe_zone_reset, 1}, {"wk_ema_new", (DL_FUNC)&wk_ema_new, 1}, {"wk_ema_update", (DL_FUNC)&wk_ema_update, 2}, {"wk_ema_batch", (DL_FUNC)&wk_ema_batch, 2}, + {"wk_ema_warmup_period", (DL_FUNC)&wk_ema_warmup_period, 1}, + {"wk_ema_is_ready", (DL_FUNC)&wk_ema_is_ready, 1}, {"wk_ema_reset", (DL_FUNC)&wk_ema_reset, 1}, {"wk_empirical_mode_decomposition_new", (DL_FUNC)&wk_empirical_mode_decomposition_new, 2}, {"wk_empirical_mode_decomposition_update", (DL_FUNC)&wk_empirical_mode_decomposition_update, 2}, {"wk_empirical_mode_decomposition_batch", (DL_FUNC)&wk_empirical_mode_decomposition_batch, 2}, + {"wk_empirical_mode_decomposition_warmup_period", (DL_FUNC)&wk_empirical_mode_decomposition_warmup_period, 1}, + {"wk_empirical_mode_decomposition_is_ready", (DL_FUNC)&wk_empirical_mode_decomposition_is_ready, 1}, {"wk_empirical_mode_decomposition_reset", (DL_FUNC)&wk_empirical_mode_decomposition_reset, 1}, {"wk_engulfing_new", (DL_FUNC)&wk_engulfing_new, 0}, {"wk_engulfing_update", (DL_FUNC)&wk_engulfing_update, 7}, {"wk_engulfing_batch", (DL_FUNC)&wk_engulfing_batch, 7}, + {"wk_engulfing_warmup_period", (DL_FUNC)&wk_engulfing_warmup_period, 1}, + {"wk_engulfing_is_ready", (DL_FUNC)&wk_engulfing_is_ready, 1}, {"wk_engulfing_reset", (DL_FUNC)&wk_engulfing_reset, 1}, {"wk_equivolume_new", (DL_FUNC)&wk_equivolume_new, 1}, {"wk_equivolume_update", (DL_FUNC)&wk_equivolume_update, 7}, + {"wk_equivolume_warmup_period", (DL_FUNC)&wk_equivolume_warmup_period, 1}, + {"wk_equivolume_is_ready", (DL_FUNC)&wk_equivolume_is_ready, 1}, {"wk_equivolume_reset", (DL_FUNC)&wk_equivolume_reset, 1}, {"wk_estimated_leverage_ratio_new", (DL_FUNC)&wk_estimated_leverage_ratio_new, 0}, {"wk_estimated_leverage_ratio_update", (DL_FUNC)&wk_estimated_leverage_ratio_update, 13}, + {"wk_estimated_leverage_ratio_warmup_period", (DL_FUNC)&wk_estimated_leverage_ratio_warmup_period, 1}, + {"wk_estimated_leverage_ratio_is_ready", (DL_FUNC)&wk_estimated_leverage_ratio_is_ready, 1}, {"wk_estimated_leverage_ratio_reset", (DL_FUNC)&wk_estimated_leverage_ratio_reset, 1}, {"wk_even_better_sinewave_new", (DL_FUNC)&wk_even_better_sinewave_new, 2}, {"wk_even_better_sinewave_update", (DL_FUNC)&wk_even_better_sinewave_update, 2}, {"wk_even_better_sinewave_batch", (DL_FUNC)&wk_even_better_sinewave_batch, 2}, + {"wk_even_better_sinewave_warmup_period", (DL_FUNC)&wk_even_better_sinewave_warmup_period, 1}, + {"wk_even_better_sinewave_is_ready", (DL_FUNC)&wk_even_better_sinewave_is_ready, 1}, {"wk_even_better_sinewave_reset", (DL_FUNC)&wk_even_better_sinewave_reset, 1}, {"wk_evening_doji_star_new", (DL_FUNC)&wk_evening_doji_star_new, 0}, {"wk_evening_doji_star_update", (DL_FUNC)&wk_evening_doji_star_update, 7}, {"wk_evening_doji_star_batch", (DL_FUNC)&wk_evening_doji_star_batch, 7}, + {"wk_evening_doji_star_warmup_period", (DL_FUNC)&wk_evening_doji_star_warmup_period, 1}, + {"wk_evening_doji_star_is_ready", (DL_FUNC)&wk_evening_doji_star_is_ready, 1}, {"wk_evening_doji_star_reset", (DL_FUNC)&wk_evening_doji_star_reset, 1}, {"wk_evwma_new", (DL_FUNC)&wk_evwma_new, 1}, {"wk_evwma_update", (DL_FUNC)&wk_evwma_update, 7}, {"wk_evwma_batch", (DL_FUNC)&wk_evwma_batch, 7}, + {"wk_evwma_warmup_period", (DL_FUNC)&wk_evwma_warmup_period, 1}, + {"wk_evwma_is_ready", (DL_FUNC)&wk_evwma_is_ready, 1}, {"wk_evwma_reset", (DL_FUNC)&wk_evwma_reset, 1}, {"wk_ewma_volatility_new", (DL_FUNC)&wk_ewma_volatility_new, 1}, {"wk_ewma_volatility_update", (DL_FUNC)&wk_ewma_volatility_update, 2}, {"wk_ewma_volatility_batch", (DL_FUNC)&wk_ewma_volatility_batch, 2}, + {"wk_ewma_volatility_warmup_period", (DL_FUNC)&wk_ewma_volatility_warmup_period, 1}, + {"wk_ewma_volatility_is_ready", (DL_FUNC)&wk_ewma_volatility_is_ready, 1}, {"wk_ewma_volatility_reset", (DL_FUNC)&wk_ewma_volatility_reset, 1}, {"wk_expectancy_new", (DL_FUNC)&wk_expectancy_new, 1}, {"wk_expectancy_update", (DL_FUNC)&wk_expectancy_update, 2}, {"wk_expectancy_batch", (DL_FUNC)&wk_expectancy_batch, 2}, + {"wk_expectancy_warmup_period", (DL_FUNC)&wk_expectancy_warmup_period, 1}, + {"wk_expectancy_is_ready", (DL_FUNC)&wk_expectancy_is_ready, 1}, {"wk_expectancy_reset", (DL_FUNC)&wk_expectancy_reset, 1}, {"wk_falling_three_methods_new", (DL_FUNC)&wk_falling_three_methods_new, 0}, {"wk_falling_three_methods_update", (DL_FUNC)&wk_falling_three_methods_update, 7}, {"wk_falling_three_methods_batch", (DL_FUNC)&wk_falling_three_methods_batch, 7}, + {"wk_falling_three_methods_warmup_period", (DL_FUNC)&wk_falling_three_methods_warmup_period, 1}, + {"wk_falling_three_methods_is_ready", (DL_FUNC)&wk_falling_three_methods_is_ready, 1}, {"wk_falling_three_methods_reset", (DL_FUNC)&wk_falling_three_methods_reset, 1}, {"wk_fama_new", (DL_FUNC)&wk_fama_new, 2}, {"wk_fama_update", (DL_FUNC)&wk_fama_update, 2}, {"wk_fama_batch", (DL_FUNC)&wk_fama_batch, 2}, + {"wk_fama_warmup_period", (DL_FUNC)&wk_fama_warmup_period, 1}, + {"wk_fama_is_ready", (DL_FUNC)&wk_fama_is_ready, 1}, {"wk_fama_reset", (DL_FUNC)&wk_fama_reset, 1}, {"wk_fib_arcs_new", (DL_FUNC)&wk_fib_arcs_new, 0}, {"wk_fib_arcs_update", (DL_FUNC)&wk_fib_arcs_update, 7}, + {"wk_fib_arcs_warmup_period", (DL_FUNC)&wk_fib_arcs_warmup_period, 1}, + {"wk_fib_arcs_is_ready", (DL_FUNC)&wk_fib_arcs_is_ready, 1}, {"wk_fib_arcs_reset", (DL_FUNC)&wk_fib_arcs_reset, 1}, {"wk_fib_channel_new", (DL_FUNC)&wk_fib_channel_new, 0}, {"wk_fib_channel_update", (DL_FUNC)&wk_fib_channel_update, 7}, + {"wk_fib_channel_warmup_period", (DL_FUNC)&wk_fib_channel_warmup_period, 1}, + {"wk_fib_channel_is_ready", (DL_FUNC)&wk_fib_channel_is_ready, 1}, {"wk_fib_channel_reset", (DL_FUNC)&wk_fib_channel_reset, 1}, {"wk_fib_confluence_new", (DL_FUNC)&wk_fib_confluence_new, 0}, {"wk_fib_confluence_update", (DL_FUNC)&wk_fib_confluence_update, 7}, + {"wk_fib_confluence_warmup_period", (DL_FUNC)&wk_fib_confluence_warmup_period, 1}, + {"wk_fib_confluence_is_ready", (DL_FUNC)&wk_fib_confluence_is_ready, 1}, {"wk_fib_confluence_reset", (DL_FUNC)&wk_fib_confluence_reset, 1}, {"wk_fib_extension_new", (DL_FUNC)&wk_fib_extension_new, 0}, {"wk_fib_extension_update", (DL_FUNC)&wk_fib_extension_update, 7}, + {"wk_fib_extension_warmup_period", (DL_FUNC)&wk_fib_extension_warmup_period, 1}, + {"wk_fib_extension_is_ready", (DL_FUNC)&wk_fib_extension_is_ready, 1}, {"wk_fib_extension_reset", (DL_FUNC)&wk_fib_extension_reset, 1}, {"wk_fib_fan_new", (DL_FUNC)&wk_fib_fan_new, 0}, {"wk_fib_fan_update", (DL_FUNC)&wk_fib_fan_update, 7}, + {"wk_fib_fan_warmup_period", (DL_FUNC)&wk_fib_fan_warmup_period, 1}, + {"wk_fib_fan_is_ready", (DL_FUNC)&wk_fib_fan_is_ready, 1}, {"wk_fib_fan_reset", (DL_FUNC)&wk_fib_fan_reset, 1}, {"wk_fib_projection_new", (DL_FUNC)&wk_fib_projection_new, 0}, {"wk_fib_projection_update", (DL_FUNC)&wk_fib_projection_update, 7}, + {"wk_fib_projection_warmup_period", (DL_FUNC)&wk_fib_projection_warmup_period, 1}, + {"wk_fib_projection_is_ready", (DL_FUNC)&wk_fib_projection_is_ready, 1}, {"wk_fib_projection_reset", (DL_FUNC)&wk_fib_projection_reset, 1}, {"wk_fib_retracement_new", (DL_FUNC)&wk_fib_retracement_new, 0}, {"wk_fib_retracement_update", (DL_FUNC)&wk_fib_retracement_update, 7}, + {"wk_fib_retracement_warmup_period", (DL_FUNC)&wk_fib_retracement_warmup_period, 1}, + {"wk_fib_retracement_is_ready", (DL_FUNC)&wk_fib_retracement_is_ready, 1}, {"wk_fib_retracement_reset", (DL_FUNC)&wk_fib_retracement_reset, 1}, {"wk_fib_time_zones_new", (DL_FUNC)&wk_fib_time_zones_new, 0}, {"wk_fib_time_zones_update", (DL_FUNC)&wk_fib_time_zones_update, 7}, + {"wk_fib_time_zones_warmup_period", (DL_FUNC)&wk_fib_time_zones_warmup_period, 1}, + {"wk_fib_time_zones_is_ready", (DL_FUNC)&wk_fib_time_zones_is_ready, 1}, {"wk_fib_time_zones_reset", (DL_FUNC)&wk_fib_time_zones_reset, 1}, {"wk_fibonacci_pivots_new", (DL_FUNC)&wk_fibonacci_pivots_new, 0}, {"wk_fibonacci_pivots_update", (DL_FUNC)&wk_fibonacci_pivots_update, 7}, + {"wk_fibonacci_pivots_warmup_period", (DL_FUNC)&wk_fibonacci_pivots_warmup_period, 1}, + {"wk_fibonacci_pivots_is_ready", (DL_FUNC)&wk_fibonacci_pivots_is_ready, 1}, {"wk_fibonacci_pivots_reset", (DL_FUNC)&wk_fibonacci_pivots_reset, 1}, {"wk_fisher_rsi_new", (DL_FUNC)&wk_fisher_rsi_new, 1}, {"wk_fisher_rsi_update", (DL_FUNC)&wk_fisher_rsi_update, 2}, {"wk_fisher_rsi_batch", (DL_FUNC)&wk_fisher_rsi_batch, 2}, + {"wk_fisher_rsi_warmup_period", (DL_FUNC)&wk_fisher_rsi_warmup_period, 1}, + {"wk_fisher_rsi_is_ready", (DL_FUNC)&wk_fisher_rsi_is_ready, 1}, {"wk_fisher_rsi_reset", (DL_FUNC)&wk_fisher_rsi_reset, 1}, {"wk_fisher_transform_new", (DL_FUNC)&wk_fisher_transform_new, 1}, {"wk_fisher_transform_update", (DL_FUNC)&wk_fisher_transform_update, 2}, {"wk_fisher_transform_batch", (DL_FUNC)&wk_fisher_transform_batch, 2}, + {"wk_fisher_transform_warmup_period", (DL_FUNC)&wk_fisher_transform_warmup_period, 1}, + {"wk_fisher_transform_is_ready", (DL_FUNC)&wk_fisher_transform_is_ready, 1}, {"wk_fisher_transform_reset", (DL_FUNC)&wk_fisher_transform_reset, 1}, {"wk_flag_pennant_new", (DL_FUNC)&wk_flag_pennant_new, 0}, {"wk_flag_pennant_update", (DL_FUNC)&wk_flag_pennant_update, 7}, {"wk_flag_pennant_batch", (DL_FUNC)&wk_flag_pennant_batch, 7}, + {"wk_flag_pennant_warmup_period", (DL_FUNC)&wk_flag_pennant_warmup_period, 1}, + {"wk_flag_pennant_is_ready", (DL_FUNC)&wk_flag_pennant_is_ready, 1}, {"wk_flag_pennant_reset", (DL_FUNC)&wk_flag_pennant_reset, 1}, {"wk_footprint_new", (DL_FUNC)&wk_footprint_new, 1}, {"wk_footprint_update", (DL_FUNC)&wk_footprint_update, 5}, + {"wk_footprint_warmup_period", (DL_FUNC)&wk_footprint_warmup_period, 1}, + {"wk_footprint_is_ready", (DL_FUNC)&wk_footprint_is_ready, 1}, {"wk_footprint_reset", (DL_FUNC)&wk_footprint_reset, 1}, {"wk_force_index_new", (DL_FUNC)&wk_force_index_new, 1}, {"wk_force_index_update", (DL_FUNC)&wk_force_index_update, 7}, {"wk_force_index_batch", (DL_FUNC)&wk_force_index_batch, 7}, + {"wk_force_index_warmup_period", (DL_FUNC)&wk_force_index_warmup_period, 1}, + {"wk_force_index_is_ready", (DL_FUNC)&wk_force_index_is_ready, 1}, {"wk_force_index_reset", (DL_FUNC)&wk_force_index_reset, 1}, {"wk_fractal_chaos_bands_new", (DL_FUNC)&wk_fractal_chaos_bands_new, 1}, {"wk_fractal_chaos_bands_update", (DL_FUNC)&wk_fractal_chaos_bands_update, 7}, + {"wk_fractal_chaos_bands_warmup_period", (DL_FUNC)&wk_fractal_chaos_bands_warmup_period, 1}, + {"wk_fractal_chaos_bands_is_ready", (DL_FUNC)&wk_fractal_chaos_bands_is_ready, 1}, {"wk_fractal_chaos_bands_reset", (DL_FUNC)&wk_fractal_chaos_bands_reset, 1}, {"wk_frama_new", (DL_FUNC)&wk_frama_new, 1}, {"wk_frama_update", (DL_FUNC)&wk_frama_update, 2}, {"wk_frama_batch", (DL_FUNC)&wk_frama_batch, 2}, + {"wk_frama_warmup_period", (DL_FUNC)&wk_frama_warmup_period, 1}, + {"wk_frama_is_ready", (DL_FUNC)&wk_frama_is_ready, 1}, {"wk_frama_reset", (DL_FUNC)&wk_frama_reset, 1}, {"wk_fry_pan_bottom_new", (DL_FUNC)&wk_fry_pan_bottom_new, 1}, {"wk_fry_pan_bottom_update", (DL_FUNC)&wk_fry_pan_bottom_update, 7}, {"wk_fry_pan_bottom_batch", (DL_FUNC)&wk_fry_pan_bottom_batch, 7}, + {"wk_fry_pan_bottom_warmup_period", (DL_FUNC)&wk_fry_pan_bottom_warmup_period, 1}, + {"wk_fry_pan_bottom_is_ready", (DL_FUNC)&wk_fry_pan_bottom_is_ready, 1}, {"wk_fry_pan_bottom_reset", (DL_FUNC)&wk_fry_pan_bottom_reset, 1}, {"wk_funding_basis_new", (DL_FUNC)&wk_funding_basis_new, 0}, {"wk_funding_basis_update", (DL_FUNC)&wk_funding_basis_update, 13}, + {"wk_funding_basis_warmup_period", (DL_FUNC)&wk_funding_basis_warmup_period, 1}, + {"wk_funding_basis_is_ready", (DL_FUNC)&wk_funding_basis_is_ready, 1}, {"wk_funding_basis_reset", (DL_FUNC)&wk_funding_basis_reset, 1}, {"wk_funding_implied_apr_new", (DL_FUNC)&wk_funding_implied_apr_new, 1}, {"wk_funding_implied_apr_update", (DL_FUNC)&wk_funding_implied_apr_update, 13}, + {"wk_funding_implied_apr_warmup_period", (DL_FUNC)&wk_funding_implied_apr_warmup_period, 1}, + {"wk_funding_implied_apr_is_ready", (DL_FUNC)&wk_funding_implied_apr_is_ready, 1}, {"wk_funding_implied_apr_reset", (DL_FUNC)&wk_funding_implied_apr_reset, 1}, {"wk_funding_rate_new", (DL_FUNC)&wk_funding_rate_new, 0}, {"wk_funding_rate_update", (DL_FUNC)&wk_funding_rate_update, 13}, + {"wk_funding_rate_warmup_period", (DL_FUNC)&wk_funding_rate_warmup_period, 1}, + {"wk_funding_rate_is_ready", (DL_FUNC)&wk_funding_rate_is_ready, 1}, {"wk_funding_rate_reset", (DL_FUNC)&wk_funding_rate_reset, 1}, {"wk_funding_rate_mean_new", (DL_FUNC)&wk_funding_rate_mean_new, 1}, {"wk_funding_rate_mean_update", (DL_FUNC)&wk_funding_rate_mean_update, 13}, + {"wk_funding_rate_mean_warmup_period", (DL_FUNC)&wk_funding_rate_mean_warmup_period, 1}, + {"wk_funding_rate_mean_is_ready", (DL_FUNC)&wk_funding_rate_mean_is_ready, 1}, {"wk_funding_rate_mean_reset", (DL_FUNC)&wk_funding_rate_mean_reset, 1}, {"wk_funding_rate_z_score_new", (DL_FUNC)&wk_funding_rate_z_score_new, 1}, {"wk_funding_rate_z_score_update", (DL_FUNC)&wk_funding_rate_z_score_update, 13}, + {"wk_funding_rate_z_score_warmup_period", (DL_FUNC)&wk_funding_rate_z_score_warmup_period, 1}, + {"wk_funding_rate_z_score_is_ready", (DL_FUNC)&wk_funding_rate_z_score_is_ready, 1}, {"wk_funding_rate_z_score_reset", (DL_FUNC)&wk_funding_rate_z_score_reset, 1}, {"wk_gain_loss_ratio_new", (DL_FUNC)&wk_gain_loss_ratio_new, 1}, {"wk_gain_loss_ratio_update", (DL_FUNC)&wk_gain_loss_ratio_update, 2}, {"wk_gain_loss_ratio_batch", (DL_FUNC)&wk_gain_loss_ratio_batch, 2}, + {"wk_gain_loss_ratio_warmup_period", (DL_FUNC)&wk_gain_loss_ratio_warmup_period, 1}, + {"wk_gain_loss_ratio_is_ready", (DL_FUNC)&wk_gain_loss_ratio_is_ready, 1}, {"wk_gain_loss_ratio_reset", (DL_FUNC)&wk_gain_loss_ratio_reset, 1}, {"wk_gain_to_pain_ratio_new", (DL_FUNC)&wk_gain_to_pain_ratio_new, 1}, {"wk_gain_to_pain_ratio_update", (DL_FUNC)&wk_gain_to_pain_ratio_update, 2}, {"wk_gain_to_pain_ratio_batch", (DL_FUNC)&wk_gain_to_pain_ratio_batch, 2}, + {"wk_gain_to_pain_ratio_warmup_period", (DL_FUNC)&wk_gain_to_pain_ratio_warmup_period, 1}, + {"wk_gain_to_pain_ratio_is_ready", (DL_FUNC)&wk_gain_to_pain_ratio_is_ready, 1}, {"wk_gain_to_pain_ratio_reset", (DL_FUNC)&wk_gain_to_pain_ratio_reset, 1}, {"wk_gap_side_by_side_white_new", (DL_FUNC)&wk_gap_side_by_side_white_new, 0}, {"wk_gap_side_by_side_white_update", (DL_FUNC)&wk_gap_side_by_side_white_update, 7}, {"wk_gap_side_by_side_white_batch", (DL_FUNC)&wk_gap_side_by_side_white_batch, 7}, + {"wk_gap_side_by_side_white_warmup_period", (DL_FUNC)&wk_gap_side_by_side_white_warmup_period, 1}, + {"wk_gap_side_by_side_white_is_ready", (DL_FUNC)&wk_gap_side_by_side_white_is_ready, 1}, {"wk_gap_side_by_side_white_reset", (DL_FUNC)&wk_gap_side_by_side_white_reset, 1}, {"wk_garch11_new", (DL_FUNC)&wk_garch11_new, 3}, {"wk_garch11_update", (DL_FUNC)&wk_garch11_update, 2}, {"wk_garch11_batch", (DL_FUNC)&wk_garch11_batch, 2}, + {"wk_garch11_warmup_period", (DL_FUNC)&wk_garch11_warmup_period, 1}, + {"wk_garch11_is_ready", (DL_FUNC)&wk_garch11_is_ready, 1}, {"wk_garch11_reset", (DL_FUNC)&wk_garch11_reset, 1}, {"wk_garman_klass_volatility_new", (DL_FUNC)&wk_garman_klass_volatility_new, 2}, {"wk_garman_klass_volatility_update", (DL_FUNC)&wk_garman_klass_volatility_update, 7}, {"wk_garman_klass_volatility_batch", (DL_FUNC)&wk_garman_klass_volatility_batch, 7}, + {"wk_garman_klass_volatility_warmup_period", (DL_FUNC)&wk_garman_klass_volatility_warmup_period, 1}, + {"wk_garman_klass_volatility_is_ready", (DL_FUNC)&wk_garman_klass_volatility_is_ready, 1}, {"wk_garman_klass_volatility_reset", (DL_FUNC)&wk_garman_klass_volatility_reset, 1}, {"wk_gartley_new", (DL_FUNC)&wk_gartley_new, 0}, {"wk_gartley_update", (DL_FUNC)&wk_gartley_update, 7}, {"wk_gartley_batch", (DL_FUNC)&wk_gartley_batch, 7}, + {"wk_gartley_warmup_period", (DL_FUNC)&wk_gartley_warmup_period, 1}, + {"wk_gartley_is_ready", (DL_FUNC)&wk_gartley_is_ready, 1}, {"wk_gartley_reset", (DL_FUNC)&wk_gartley_reset, 1}, {"wk_gator_oscillator_new", (DL_FUNC)&wk_gator_oscillator_new, 3}, {"wk_gator_oscillator_update", (DL_FUNC)&wk_gator_oscillator_update, 7}, + {"wk_gator_oscillator_warmup_period", (DL_FUNC)&wk_gator_oscillator_warmup_period, 1}, + {"wk_gator_oscillator_is_ready", (DL_FUNC)&wk_gator_oscillator_is_ready, 1}, {"wk_gator_oscillator_reset", (DL_FUNC)&wk_gator_oscillator_reset, 1}, {"wk_generalized_dema_new", (DL_FUNC)&wk_generalized_dema_new, 2}, {"wk_generalized_dema_update", (DL_FUNC)&wk_generalized_dema_update, 2}, {"wk_generalized_dema_batch", (DL_FUNC)&wk_generalized_dema_batch, 2}, + {"wk_generalized_dema_warmup_period", (DL_FUNC)&wk_generalized_dema_warmup_period, 1}, + {"wk_generalized_dema_is_ready", (DL_FUNC)&wk_generalized_dema_is_ready, 1}, {"wk_generalized_dema_reset", (DL_FUNC)&wk_generalized_dema_reset, 1}, {"wk_geometric_ma_new", (DL_FUNC)&wk_geometric_ma_new, 1}, {"wk_geometric_ma_update", (DL_FUNC)&wk_geometric_ma_update, 2}, {"wk_geometric_ma_batch", (DL_FUNC)&wk_geometric_ma_batch, 2}, + {"wk_geometric_ma_warmup_period", (DL_FUNC)&wk_geometric_ma_warmup_period, 1}, + {"wk_geometric_ma_is_ready", (DL_FUNC)&wk_geometric_ma_is_ready, 1}, {"wk_geometric_ma_reset", (DL_FUNC)&wk_geometric_ma_reset, 1}, {"wk_golden_pocket_new", (DL_FUNC)&wk_golden_pocket_new, 0}, {"wk_golden_pocket_update", (DL_FUNC)&wk_golden_pocket_update, 7}, + {"wk_golden_pocket_warmup_period", (DL_FUNC)&wk_golden_pocket_warmup_period, 1}, + {"wk_golden_pocket_is_ready", (DL_FUNC)&wk_golden_pocket_is_ready, 1}, {"wk_golden_pocket_reset", (DL_FUNC)&wk_golden_pocket_reset, 1}, {"wk_granger_causality_new", (DL_FUNC)&wk_granger_causality_new, 2}, {"wk_granger_causality_update", (DL_FUNC)&wk_granger_causality_update, 3}, {"wk_granger_causality_batch", (DL_FUNC)&wk_granger_causality_batch, 3}, + {"wk_granger_causality_warmup_period", (DL_FUNC)&wk_granger_causality_warmup_period, 1}, + {"wk_granger_causality_is_ready", (DL_FUNC)&wk_granger_causality_is_ready, 1}, {"wk_granger_causality_reset", (DL_FUNC)&wk_granger_causality_reset, 1}, {"wk_gravestone_doji_new", (DL_FUNC)&wk_gravestone_doji_new, 0}, {"wk_gravestone_doji_update", (DL_FUNC)&wk_gravestone_doji_update, 7}, {"wk_gravestone_doji_batch", (DL_FUNC)&wk_gravestone_doji_batch, 7}, + {"wk_gravestone_doji_warmup_period", (DL_FUNC)&wk_gravestone_doji_warmup_period, 1}, + {"wk_gravestone_doji_is_ready", (DL_FUNC)&wk_gravestone_doji_is_ready, 1}, {"wk_gravestone_doji_reset", (DL_FUNC)&wk_gravestone_doji_reset, 1}, {"wk_hammer_new", (DL_FUNC)&wk_hammer_new, 0}, {"wk_hammer_update", (DL_FUNC)&wk_hammer_update, 7}, {"wk_hammer_batch", (DL_FUNC)&wk_hammer_batch, 7}, + {"wk_hammer_warmup_period", (DL_FUNC)&wk_hammer_warmup_period, 1}, + {"wk_hammer_is_ready", (DL_FUNC)&wk_hammer_is_ready, 1}, {"wk_hammer_reset", (DL_FUNC)&wk_hammer_reset, 1}, {"wk_hanging_man_new", (DL_FUNC)&wk_hanging_man_new, 0}, {"wk_hanging_man_update", (DL_FUNC)&wk_hanging_man_update, 7}, {"wk_hanging_man_batch", (DL_FUNC)&wk_hanging_man_batch, 7}, + {"wk_hanging_man_warmup_period", (DL_FUNC)&wk_hanging_man_warmup_period, 1}, + {"wk_hanging_man_is_ready", (DL_FUNC)&wk_hanging_man_is_ready, 1}, {"wk_hanging_man_reset", (DL_FUNC)&wk_hanging_man_reset, 1}, {"wk_harami_new", (DL_FUNC)&wk_harami_new, 0}, {"wk_harami_update", (DL_FUNC)&wk_harami_update, 7}, {"wk_harami_batch", (DL_FUNC)&wk_harami_batch, 7}, + {"wk_harami_warmup_period", (DL_FUNC)&wk_harami_warmup_period, 1}, + {"wk_harami_is_ready", (DL_FUNC)&wk_harami_is_ready, 1}, {"wk_harami_reset", (DL_FUNC)&wk_harami_reset, 1}, {"wk_harami_cross_new", (DL_FUNC)&wk_harami_cross_new, 0}, {"wk_harami_cross_update", (DL_FUNC)&wk_harami_cross_update, 7}, {"wk_harami_cross_batch", (DL_FUNC)&wk_harami_cross_batch, 7}, + {"wk_harami_cross_warmup_period", (DL_FUNC)&wk_harami_cross_warmup_period, 1}, + {"wk_harami_cross_is_ready", (DL_FUNC)&wk_harami_cross_is_ready, 1}, {"wk_harami_cross_reset", (DL_FUNC)&wk_harami_cross_reset, 1}, {"wk_hasbrouck_information_share_new", (DL_FUNC)&wk_hasbrouck_information_share_new, 1}, {"wk_hasbrouck_information_share_update", (DL_FUNC)&wk_hasbrouck_information_share_update, 3}, {"wk_hasbrouck_information_share_batch", (DL_FUNC)&wk_hasbrouck_information_share_batch, 3}, + {"wk_hasbrouck_information_share_warmup_period", (DL_FUNC)&wk_hasbrouck_information_share_warmup_period, 1}, + {"wk_hasbrouck_information_share_is_ready", (DL_FUNC)&wk_hasbrouck_information_share_is_ready, 1}, {"wk_hasbrouck_information_share_reset", (DL_FUNC)&wk_hasbrouck_information_share_reset, 1}, {"wk_head_and_shoulders_new", (DL_FUNC)&wk_head_and_shoulders_new, 0}, {"wk_head_and_shoulders_update", (DL_FUNC)&wk_head_and_shoulders_update, 7}, {"wk_head_and_shoulders_batch", (DL_FUNC)&wk_head_and_shoulders_batch, 7}, + {"wk_head_and_shoulders_warmup_period", (DL_FUNC)&wk_head_and_shoulders_warmup_period, 1}, + {"wk_head_and_shoulders_is_ready", (DL_FUNC)&wk_head_and_shoulders_is_ready, 1}, {"wk_head_and_shoulders_reset", (DL_FUNC)&wk_head_and_shoulders_reset, 1}, {"wk_heikin_ashi_new", (DL_FUNC)&wk_heikin_ashi_new, 0}, {"wk_heikin_ashi_update", (DL_FUNC)&wk_heikin_ashi_update, 7}, + {"wk_heikin_ashi_warmup_period", (DL_FUNC)&wk_heikin_ashi_warmup_period, 1}, + {"wk_heikin_ashi_is_ready", (DL_FUNC)&wk_heikin_ashi_is_ready, 1}, {"wk_heikin_ashi_reset", (DL_FUNC)&wk_heikin_ashi_reset, 1}, {"wk_heikin_ashi_oscillator_new", (DL_FUNC)&wk_heikin_ashi_oscillator_new, 1}, {"wk_heikin_ashi_oscillator_update", (DL_FUNC)&wk_heikin_ashi_oscillator_update, 7}, {"wk_heikin_ashi_oscillator_batch", (DL_FUNC)&wk_heikin_ashi_oscillator_batch, 7}, + {"wk_heikin_ashi_oscillator_warmup_period", (DL_FUNC)&wk_heikin_ashi_oscillator_warmup_period, 1}, + {"wk_heikin_ashi_oscillator_is_ready", (DL_FUNC)&wk_heikin_ashi_oscillator_is_ready, 1}, {"wk_heikin_ashi_oscillator_reset", (DL_FUNC)&wk_heikin_ashi_oscillator_reset, 1}, {"wk_hi_lo_activator_new", (DL_FUNC)&wk_hi_lo_activator_new, 1}, {"wk_hi_lo_activator_update", (DL_FUNC)&wk_hi_lo_activator_update, 7}, {"wk_hi_lo_activator_batch", (DL_FUNC)&wk_hi_lo_activator_batch, 7}, + {"wk_hi_lo_activator_warmup_period", (DL_FUNC)&wk_hi_lo_activator_warmup_period, 1}, + {"wk_hi_lo_activator_is_ready", (DL_FUNC)&wk_hi_lo_activator_is_ready, 1}, {"wk_hi_lo_activator_reset", (DL_FUNC)&wk_hi_lo_activator_reset, 1}, {"wk_high_low_index_new", (DL_FUNC)&wk_high_low_index_new, 1}, {"wk_high_low_index_update", (DL_FUNC)&wk_high_low_index_update, 8}, + {"wk_high_low_index_warmup_period", (DL_FUNC)&wk_high_low_index_warmup_period, 1}, + {"wk_high_low_index_is_ready", (DL_FUNC)&wk_high_low_index_is_ready, 1}, {"wk_high_low_index_reset", (DL_FUNC)&wk_high_low_index_reset, 1}, {"wk_high_low_range_new", (DL_FUNC)&wk_high_low_range_new, 0}, {"wk_high_low_range_update", (DL_FUNC)&wk_high_low_range_update, 7}, {"wk_high_low_range_batch", (DL_FUNC)&wk_high_low_range_batch, 7}, + {"wk_high_low_range_warmup_period", (DL_FUNC)&wk_high_low_range_warmup_period, 1}, + {"wk_high_low_range_is_ready", (DL_FUNC)&wk_high_low_range_is_ready, 1}, {"wk_high_low_range_reset", (DL_FUNC)&wk_high_low_range_reset, 1}, {"wk_high_low_volume_nodes_new", (DL_FUNC)&wk_high_low_volume_nodes_new, 2}, {"wk_high_low_volume_nodes_update", (DL_FUNC)&wk_high_low_volume_nodes_update, 7}, + {"wk_high_low_volume_nodes_warmup_period", (DL_FUNC)&wk_high_low_volume_nodes_warmup_period, 1}, + {"wk_high_low_volume_nodes_is_ready", (DL_FUNC)&wk_high_low_volume_nodes_is_ready, 1}, {"wk_high_low_volume_nodes_reset", (DL_FUNC)&wk_high_low_volume_nodes_reset, 1}, {"wk_high_wave_new", (DL_FUNC)&wk_high_wave_new, 0}, {"wk_high_wave_update", (DL_FUNC)&wk_high_wave_update, 7}, {"wk_high_wave_batch", (DL_FUNC)&wk_high_wave_batch, 7}, + {"wk_high_wave_warmup_period", (DL_FUNC)&wk_high_wave_warmup_period, 1}, + {"wk_high_wave_is_ready", (DL_FUNC)&wk_high_wave_is_ready, 1}, {"wk_high_wave_reset", (DL_FUNC)&wk_high_wave_reset, 1}, {"wk_highpass_filter_new", (DL_FUNC)&wk_highpass_filter_new, 1}, {"wk_highpass_filter_update", (DL_FUNC)&wk_highpass_filter_update, 2}, {"wk_highpass_filter_batch", (DL_FUNC)&wk_highpass_filter_batch, 2}, + {"wk_highpass_filter_warmup_period", (DL_FUNC)&wk_highpass_filter_warmup_period, 1}, + {"wk_highpass_filter_is_ready", (DL_FUNC)&wk_highpass_filter_is_ready, 1}, {"wk_highpass_filter_reset", (DL_FUNC)&wk_highpass_filter_reset, 1}, {"wk_hikkake_new", (DL_FUNC)&wk_hikkake_new, 0}, {"wk_hikkake_update", (DL_FUNC)&wk_hikkake_update, 7}, {"wk_hikkake_batch", (DL_FUNC)&wk_hikkake_batch, 7}, + {"wk_hikkake_warmup_period", (DL_FUNC)&wk_hikkake_warmup_period, 1}, + {"wk_hikkake_is_ready", (DL_FUNC)&wk_hikkake_is_ready, 1}, {"wk_hikkake_reset", (DL_FUNC)&wk_hikkake_reset, 1}, {"wk_hikkake_modified_new", (DL_FUNC)&wk_hikkake_modified_new, 0}, {"wk_hikkake_modified_update", (DL_FUNC)&wk_hikkake_modified_update, 7}, {"wk_hikkake_modified_batch", (DL_FUNC)&wk_hikkake_modified_batch, 7}, + {"wk_hikkake_modified_warmup_period", (DL_FUNC)&wk_hikkake_modified_warmup_period, 1}, + {"wk_hikkake_modified_is_ready", (DL_FUNC)&wk_hikkake_modified_is_ready, 1}, {"wk_hikkake_modified_reset", (DL_FUNC)&wk_hikkake_modified_reset, 1}, {"wk_hilbert_dominant_cycle_new", (DL_FUNC)&wk_hilbert_dominant_cycle_new, 0}, {"wk_hilbert_dominant_cycle_update", (DL_FUNC)&wk_hilbert_dominant_cycle_update, 2}, {"wk_hilbert_dominant_cycle_batch", (DL_FUNC)&wk_hilbert_dominant_cycle_batch, 2}, + {"wk_hilbert_dominant_cycle_warmup_period", (DL_FUNC)&wk_hilbert_dominant_cycle_warmup_period, 1}, + {"wk_hilbert_dominant_cycle_is_ready", (DL_FUNC)&wk_hilbert_dominant_cycle_is_ready, 1}, {"wk_hilbert_dominant_cycle_reset", (DL_FUNC)&wk_hilbert_dominant_cycle_reset, 1}, {"wk_historical_volatility_new", (DL_FUNC)&wk_historical_volatility_new, 2}, {"wk_historical_volatility_update", (DL_FUNC)&wk_historical_volatility_update, 2}, {"wk_historical_volatility_batch", (DL_FUNC)&wk_historical_volatility_batch, 2}, + {"wk_historical_volatility_warmup_period", (DL_FUNC)&wk_historical_volatility_warmup_period, 1}, + {"wk_historical_volatility_is_ready", (DL_FUNC)&wk_historical_volatility_is_ready, 1}, {"wk_historical_volatility_reset", (DL_FUNC)&wk_historical_volatility_reset, 1}, {"wk_hma_new", (DL_FUNC)&wk_hma_new, 1}, {"wk_hma_update", (DL_FUNC)&wk_hma_update, 2}, {"wk_hma_batch", (DL_FUNC)&wk_hma_batch, 2}, + {"wk_hma_warmup_period", (DL_FUNC)&wk_hma_warmup_period, 1}, + {"wk_hma_is_ready", (DL_FUNC)&wk_hma_is_ready, 1}, {"wk_hma_reset", (DL_FUNC)&wk_hma_reset, 1}, {"wk_holt_winters_new", (DL_FUNC)&wk_holt_winters_new, 2}, {"wk_holt_winters_update", (DL_FUNC)&wk_holt_winters_update, 2}, {"wk_holt_winters_batch", (DL_FUNC)&wk_holt_winters_batch, 2}, + {"wk_holt_winters_warmup_period", (DL_FUNC)&wk_holt_winters_warmup_period, 1}, + {"wk_holt_winters_is_ready", (DL_FUNC)&wk_holt_winters_is_ready, 1}, {"wk_holt_winters_reset", (DL_FUNC)&wk_holt_winters_reset, 1}, {"wk_homing_pigeon_new", (DL_FUNC)&wk_homing_pigeon_new, 0}, {"wk_homing_pigeon_update", (DL_FUNC)&wk_homing_pigeon_update, 7}, {"wk_homing_pigeon_batch", (DL_FUNC)&wk_homing_pigeon_batch, 7}, + {"wk_homing_pigeon_warmup_period", (DL_FUNC)&wk_homing_pigeon_warmup_period, 1}, + {"wk_homing_pigeon_is_ready", (DL_FUNC)&wk_homing_pigeon_is_ready, 1}, {"wk_homing_pigeon_reset", (DL_FUNC)&wk_homing_pigeon_reset, 1}, {"wk_ht_dc_phase_new", (DL_FUNC)&wk_ht_dc_phase_new, 0}, {"wk_ht_dc_phase_update", (DL_FUNC)&wk_ht_dc_phase_update, 2}, {"wk_ht_dc_phase_batch", (DL_FUNC)&wk_ht_dc_phase_batch, 2}, + {"wk_ht_dc_phase_warmup_period", (DL_FUNC)&wk_ht_dc_phase_warmup_period, 1}, + {"wk_ht_dc_phase_is_ready", (DL_FUNC)&wk_ht_dc_phase_is_ready, 1}, {"wk_ht_dc_phase_reset", (DL_FUNC)&wk_ht_dc_phase_reset, 1}, {"wk_ht_phasor_new", (DL_FUNC)&wk_ht_phasor_new, 0}, {"wk_ht_phasor_update", (DL_FUNC)&wk_ht_phasor_update, 2}, + {"wk_ht_phasor_warmup_period", (DL_FUNC)&wk_ht_phasor_warmup_period, 1}, + {"wk_ht_phasor_is_ready", (DL_FUNC)&wk_ht_phasor_is_ready, 1}, {"wk_ht_phasor_reset", (DL_FUNC)&wk_ht_phasor_reset, 1}, {"wk_ht_trend_mode_new", (DL_FUNC)&wk_ht_trend_mode_new, 0}, {"wk_ht_trend_mode_update", (DL_FUNC)&wk_ht_trend_mode_update, 2}, {"wk_ht_trend_mode_batch", (DL_FUNC)&wk_ht_trend_mode_batch, 2}, + {"wk_ht_trend_mode_warmup_period", (DL_FUNC)&wk_ht_trend_mode_warmup_period, 1}, + {"wk_ht_trend_mode_is_ready", (DL_FUNC)&wk_ht_trend_mode_is_ready, 1}, {"wk_ht_trend_mode_reset", (DL_FUNC)&wk_ht_trend_mode_reset, 1}, {"wk_hurst_channel_new", (DL_FUNC)&wk_hurst_channel_new, 2}, {"wk_hurst_channel_update", (DL_FUNC)&wk_hurst_channel_update, 7}, + {"wk_hurst_channel_warmup_period", (DL_FUNC)&wk_hurst_channel_warmup_period, 1}, + {"wk_hurst_channel_is_ready", (DL_FUNC)&wk_hurst_channel_is_ready, 1}, {"wk_hurst_channel_reset", (DL_FUNC)&wk_hurst_channel_reset, 1}, {"wk_hurst_exponent_new", (DL_FUNC)&wk_hurst_exponent_new, 2}, {"wk_hurst_exponent_update", (DL_FUNC)&wk_hurst_exponent_update, 2}, {"wk_hurst_exponent_batch", (DL_FUNC)&wk_hurst_exponent_batch, 2}, + {"wk_hurst_exponent_warmup_period", (DL_FUNC)&wk_hurst_exponent_warmup_period, 1}, + {"wk_hurst_exponent_is_ready", (DL_FUNC)&wk_hurst_exponent_is_ready, 1}, {"wk_hurst_exponent_reset", (DL_FUNC)&wk_hurst_exponent_reset, 1}, {"wk_ichimoku_new", (DL_FUNC)&wk_ichimoku_new, 4}, {"wk_ichimoku_update", (DL_FUNC)&wk_ichimoku_update, 7}, + {"wk_ichimoku_warmup_period", (DL_FUNC)&wk_ichimoku_warmup_period, 1}, + {"wk_ichimoku_is_ready", (DL_FUNC)&wk_ichimoku_is_ready, 1}, {"wk_ichimoku_reset", (DL_FUNC)&wk_ichimoku_reset, 1}, {"wk_identical_three_crows_new", (DL_FUNC)&wk_identical_three_crows_new, 0}, {"wk_identical_three_crows_update", (DL_FUNC)&wk_identical_three_crows_update, 7}, {"wk_identical_three_crows_batch", (DL_FUNC)&wk_identical_three_crows_batch, 7}, + {"wk_identical_three_crows_warmup_period", (DL_FUNC)&wk_identical_three_crows_warmup_period, 1}, + {"wk_identical_three_crows_is_ready", (DL_FUNC)&wk_identical_three_crows_is_ready, 1}, {"wk_identical_three_crows_reset", (DL_FUNC)&wk_identical_three_crows_reset, 1}, {"wk_imbalance_bars_new", (DL_FUNC)&wk_imbalance_bars_new, 1}, {"wk_imbalance_bars_update", (DL_FUNC)&wk_imbalance_bars_update, 7}, @@ -17160,410 +21582,632 @@ static const R_CallMethodDef CallEntries[] = { {"wk_in_neck_new", (DL_FUNC)&wk_in_neck_new, 0}, {"wk_in_neck_update", (DL_FUNC)&wk_in_neck_update, 7}, {"wk_in_neck_batch", (DL_FUNC)&wk_in_neck_batch, 7}, + {"wk_in_neck_warmup_period", (DL_FUNC)&wk_in_neck_warmup_period, 1}, + {"wk_in_neck_is_ready", (DL_FUNC)&wk_in_neck_is_ready, 1}, {"wk_in_neck_reset", (DL_FUNC)&wk_in_neck_reset, 1}, {"wk_inertia_new", (DL_FUNC)&wk_inertia_new, 2}, {"wk_inertia_update", (DL_FUNC)&wk_inertia_update, 7}, {"wk_inertia_batch", (DL_FUNC)&wk_inertia_batch, 7}, + {"wk_inertia_warmup_period", (DL_FUNC)&wk_inertia_warmup_period, 1}, + {"wk_inertia_is_ready", (DL_FUNC)&wk_inertia_is_ready, 1}, {"wk_inertia_reset", (DL_FUNC)&wk_inertia_reset, 1}, {"wk_information_ratio_new", (DL_FUNC)&wk_information_ratio_new, 1}, {"wk_information_ratio_update", (DL_FUNC)&wk_information_ratio_update, 3}, {"wk_information_ratio_batch", (DL_FUNC)&wk_information_ratio_batch, 3}, + {"wk_information_ratio_warmup_period", (DL_FUNC)&wk_information_ratio_warmup_period, 1}, + {"wk_information_ratio_is_ready", (DL_FUNC)&wk_information_ratio_is_ready, 1}, {"wk_information_ratio_reset", (DL_FUNC)&wk_information_ratio_reset, 1}, {"wk_initial_balance_new", (DL_FUNC)&wk_initial_balance_new, 1}, {"wk_initial_balance_update", (DL_FUNC)&wk_initial_balance_update, 7}, + {"wk_initial_balance_warmup_period", (DL_FUNC)&wk_initial_balance_warmup_period, 1}, + {"wk_initial_balance_is_ready", (DL_FUNC)&wk_initial_balance_is_ready, 1}, {"wk_initial_balance_reset", (DL_FUNC)&wk_initial_balance_reset, 1}, {"wk_instantaneous_trendline_new", (DL_FUNC)&wk_instantaneous_trendline_new, 1}, {"wk_instantaneous_trendline_update", (DL_FUNC)&wk_instantaneous_trendline_update, 2}, {"wk_instantaneous_trendline_batch", (DL_FUNC)&wk_instantaneous_trendline_batch, 2}, + {"wk_instantaneous_trendline_warmup_period", (DL_FUNC)&wk_instantaneous_trendline_warmup_period, 1}, + {"wk_instantaneous_trendline_is_ready", (DL_FUNC)&wk_instantaneous_trendline_is_ready, 1}, {"wk_instantaneous_trendline_reset", (DL_FUNC)&wk_instantaneous_trendline_reset, 1}, {"wk_intraday_intensity_new", (DL_FUNC)&wk_intraday_intensity_new, 0}, {"wk_intraday_intensity_update", (DL_FUNC)&wk_intraday_intensity_update, 7}, {"wk_intraday_intensity_batch", (DL_FUNC)&wk_intraday_intensity_batch, 7}, + {"wk_intraday_intensity_warmup_period", (DL_FUNC)&wk_intraday_intensity_warmup_period, 1}, + {"wk_intraday_intensity_is_ready", (DL_FUNC)&wk_intraday_intensity_is_ready, 1}, {"wk_intraday_intensity_reset", (DL_FUNC)&wk_intraday_intensity_reset, 1}, {"wk_intraday_momentum_index_new", (DL_FUNC)&wk_intraday_momentum_index_new, 1}, {"wk_intraday_momentum_index_update", (DL_FUNC)&wk_intraday_momentum_index_update, 7}, {"wk_intraday_momentum_index_batch", (DL_FUNC)&wk_intraday_momentum_index_batch, 7}, + {"wk_intraday_momentum_index_warmup_period", (DL_FUNC)&wk_intraday_momentum_index_warmup_period, 1}, + {"wk_intraday_momentum_index_is_ready", (DL_FUNC)&wk_intraday_momentum_index_is_ready, 1}, {"wk_intraday_momentum_index_reset", (DL_FUNC)&wk_intraday_momentum_index_reset, 1}, {"wk_intraday_volatility_profile_new", (DL_FUNC)&wk_intraday_volatility_profile_new, 2}, {"wk_intraday_volatility_profile_update", (DL_FUNC)&wk_intraday_volatility_profile_update, 8}, + {"wk_intraday_volatility_profile_warmup_period", (DL_FUNC)&wk_intraday_volatility_profile_warmup_period, 1}, + {"wk_intraday_volatility_profile_is_ready", (DL_FUNC)&wk_intraday_volatility_profile_is_ready, 1}, {"wk_intraday_volatility_profile_reset", (DL_FUNC)&wk_intraday_volatility_profile_reset, 1}, {"wk_inverse_fisher_transform_new", (DL_FUNC)&wk_inverse_fisher_transform_new, 1}, {"wk_inverse_fisher_transform_update", (DL_FUNC)&wk_inverse_fisher_transform_update, 2}, {"wk_inverse_fisher_transform_batch", (DL_FUNC)&wk_inverse_fisher_transform_batch, 2}, + {"wk_inverse_fisher_transform_warmup_period", (DL_FUNC)&wk_inverse_fisher_transform_warmup_period, 1}, + {"wk_inverse_fisher_transform_is_ready", (DL_FUNC)&wk_inverse_fisher_transform_is_ready, 1}, {"wk_inverse_fisher_transform_reset", (DL_FUNC)&wk_inverse_fisher_transform_reset, 1}, {"wk_inverted_hammer_new", (DL_FUNC)&wk_inverted_hammer_new, 0}, {"wk_inverted_hammer_update", (DL_FUNC)&wk_inverted_hammer_update, 7}, {"wk_inverted_hammer_batch", (DL_FUNC)&wk_inverted_hammer_batch, 7}, + {"wk_inverted_hammer_warmup_period", (DL_FUNC)&wk_inverted_hammer_warmup_period, 1}, + {"wk_inverted_hammer_is_ready", (DL_FUNC)&wk_inverted_hammer_is_ready, 1}, {"wk_inverted_hammer_reset", (DL_FUNC)&wk_inverted_hammer_reset, 1}, {"wk_jarque_bera_new", (DL_FUNC)&wk_jarque_bera_new, 1}, {"wk_jarque_bera_update", (DL_FUNC)&wk_jarque_bera_update, 2}, {"wk_jarque_bera_batch", (DL_FUNC)&wk_jarque_bera_batch, 2}, + {"wk_jarque_bera_warmup_period", (DL_FUNC)&wk_jarque_bera_warmup_period, 1}, + {"wk_jarque_bera_is_ready", (DL_FUNC)&wk_jarque_bera_is_ready, 1}, {"wk_jarque_bera_reset", (DL_FUNC)&wk_jarque_bera_reset, 1}, {"wk_jma_new", (DL_FUNC)&wk_jma_new, 3}, {"wk_jma_update", (DL_FUNC)&wk_jma_update, 2}, {"wk_jma_batch", (DL_FUNC)&wk_jma_batch, 2}, + {"wk_jma_warmup_period", (DL_FUNC)&wk_jma_warmup_period, 1}, + {"wk_jma_is_ready", (DL_FUNC)&wk_jma_is_ready, 1}, {"wk_jma_reset", (DL_FUNC)&wk_jma_reset, 1}, {"wk_jump_indicator_new", (DL_FUNC)&wk_jump_indicator_new, 2}, {"wk_jump_indicator_update", (DL_FUNC)&wk_jump_indicator_update, 2}, {"wk_jump_indicator_batch", (DL_FUNC)&wk_jump_indicator_batch, 2}, + {"wk_jump_indicator_warmup_period", (DL_FUNC)&wk_jump_indicator_warmup_period, 1}, + {"wk_jump_indicator_is_ready", (DL_FUNC)&wk_jump_indicator_is_ready, 1}, {"wk_jump_indicator_reset", (DL_FUNC)&wk_jump_indicator_reset, 1}, {"wk_k_ratio_new", (DL_FUNC)&wk_k_ratio_new, 1}, {"wk_k_ratio_update", (DL_FUNC)&wk_k_ratio_update, 2}, {"wk_k_ratio_batch", (DL_FUNC)&wk_k_ratio_batch, 2}, + {"wk_k_ratio_warmup_period", (DL_FUNC)&wk_k_ratio_warmup_period, 1}, + {"wk_k_ratio_is_ready", (DL_FUNC)&wk_k_ratio_is_ready, 1}, {"wk_k_ratio_reset", (DL_FUNC)&wk_k_ratio_reset, 1}, {"wk_kagi_bars_new", (DL_FUNC)&wk_kagi_bars_new, 1}, {"wk_kagi_bars_update", (DL_FUNC)&wk_kagi_bars_update, 7}, {"wk_kagi_bars_reset", (DL_FUNC)&wk_kagi_bars_reset, 1}, {"wk_kalman_hedge_ratio_new", (DL_FUNC)&wk_kalman_hedge_ratio_new, 2}, {"wk_kalman_hedge_ratio_update", (DL_FUNC)&wk_kalman_hedge_ratio_update, 3}, + {"wk_kalman_hedge_ratio_warmup_period", (DL_FUNC)&wk_kalman_hedge_ratio_warmup_period, 1}, + {"wk_kalman_hedge_ratio_is_ready", (DL_FUNC)&wk_kalman_hedge_ratio_is_ready, 1}, {"wk_kalman_hedge_ratio_reset", (DL_FUNC)&wk_kalman_hedge_ratio_reset, 1}, {"wk_kama_new", (DL_FUNC)&wk_kama_new, 3}, {"wk_kama_update", (DL_FUNC)&wk_kama_update, 2}, {"wk_kama_batch", (DL_FUNC)&wk_kama_batch, 2}, + {"wk_kama_warmup_period", (DL_FUNC)&wk_kama_warmup_period, 1}, + {"wk_kama_is_ready", (DL_FUNC)&wk_kama_is_ready, 1}, {"wk_kama_reset", (DL_FUNC)&wk_kama_reset, 1}, {"wk_kase_dev_stop_new", (DL_FUNC)&wk_kase_dev_stop_new, 2}, {"wk_kase_dev_stop_update", (DL_FUNC)&wk_kase_dev_stop_update, 7}, + {"wk_kase_dev_stop_warmup_period", (DL_FUNC)&wk_kase_dev_stop_warmup_period, 1}, + {"wk_kase_dev_stop_is_ready", (DL_FUNC)&wk_kase_dev_stop_is_ready, 1}, {"wk_kase_dev_stop_reset", (DL_FUNC)&wk_kase_dev_stop_reset, 1}, {"wk_kase_permission_stochastic_new", (DL_FUNC)&wk_kase_permission_stochastic_new, 2}, {"wk_kase_permission_stochastic_update", (DL_FUNC)&wk_kase_permission_stochastic_update, 7}, + {"wk_kase_permission_stochastic_warmup_period", (DL_FUNC)&wk_kase_permission_stochastic_warmup_period, 1}, + {"wk_kase_permission_stochastic_is_ready", (DL_FUNC)&wk_kase_permission_stochastic_is_ready, 1}, {"wk_kase_permission_stochastic_reset", (DL_FUNC)&wk_kase_permission_stochastic_reset, 1}, {"wk_kelly_criterion_new", (DL_FUNC)&wk_kelly_criterion_new, 1}, {"wk_kelly_criterion_update", (DL_FUNC)&wk_kelly_criterion_update, 2}, {"wk_kelly_criterion_batch", (DL_FUNC)&wk_kelly_criterion_batch, 2}, + {"wk_kelly_criterion_warmup_period", (DL_FUNC)&wk_kelly_criterion_warmup_period, 1}, + {"wk_kelly_criterion_is_ready", (DL_FUNC)&wk_kelly_criterion_is_ready, 1}, {"wk_kelly_criterion_reset", (DL_FUNC)&wk_kelly_criterion_reset, 1}, {"wk_keltner_new", (DL_FUNC)&wk_keltner_new, 3}, {"wk_keltner_update", (DL_FUNC)&wk_keltner_update, 7}, + {"wk_keltner_warmup_period", (DL_FUNC)&wk_keltner_warmup_period, 1}, + {"wk_keltner_is_ready", (DL_FUNC)&wk_keltner_is_ready, 1}, {"wk_keltner_reset", (DL_FUNC)&wk_keltner_reset, 1}, {"wk_kendall_tau_new", (DL_FUNC)&wk_kendall_tau_new, 1}, {"wk_kendall_tau_update", (DL_FUNC)&wk_kendall_tau_update, 3}, {"wk_kendall_tau_batch", (DL_FUNC)&wk_kendall_tau_batch, 3}, + {"wk_kendall_tau_warmup_period", (DL_FUNC)&wk_kendall_tau_warmup_period, 1}, + {"wk_kendall_tau_is_ready", (DL_FUNC)&wk_kendall_tau_is_ready, 1}, {"wk_kendall_tau_reset", (DL_FUNC)&wk_kendall_tau_reset, 1}, {"wk_kicking_new", (DL_FUNC)&wk_kicking_new, 0}, {"wk_kicking_update", (DL_FUNC)&wk_kicking_update, 7}, {"wk_kicking_batch", (DL_FUNC)&wk_kicking_batch, 7}, + {"wk_kicking_warmup_period", (DL_FUNC)&wk_kicking_warmup_period, 1}, + {"wk_kicking_is_ready", (DL_FUNC)&wk_kicking_is_ready, 1}, {"wk_kicking_reset", (DL_FUNC)&wk_kicking_reset, 1}, {"wk_kicking_by_length_new", (DL_FUNC)&wk_kicking_by_length_new, 0}, {"wk_kicking_by_length_update", (DL_FUNC)&wk_kicking_by_length_update, 7}, {"wk_kicking_by_length_batch", (DL_FUNC)&wk_kicking_by_length_batch, 7}, + {"wk_kicking_by_length_warmup_period", (DL_FUNC)&wk_kicking_by_length_warmup_period, 1}, + {"wk_kicking_by_length_is_ready", (DL_FUNC)&wk_kicking_by_length_is_ready, 1}, {"wk_kicking_by_length_reset", (DL_FUNC)&wk_kicking_by_length_reset, 1}, {"wk_kst_new", (DL_FUNC)&wk_kst_new, 9}, {"wk_kst_update", (DL_FUNC)&wk_kst_update, 2}, + {"wk_kst_warmup_period", (DL_FUNC)&wk_kst_warmup_period, 1}, + {"wk_kst_is_ready", (DL_FUNC)&wk_kst_is_ready, 1}, {"wk_kst_reset", (DL_FUNC)&wk_kst_reset, 1}, {"wk_kurtosis_new", (DL_FUNC)&wk_kurtosis_new, 1}, {"wk_kurtosis_update", (DL_FUNC)&wk_kurtosis_update, 2}, {"wk_kurtosis_batch", (DL_FUNC)&wk_kurtosis_batch, 2}, + {"wk_kurtosis_warmup_period", (DL_FUNC)&wk_kurtosis_warmup_period, 1}, + {"wk_kurtosis_is_ready", (DL_FUNC)&wk_kurtosis_is_ready, 1}, {"wk_kurtosis_reset", (DL_FUNC)&wk_kurtosis_reset, 1}, {"wk_kvo_new", (DL_FUNC)&wk_kvo_new, 2}, {"wk_kvo_update", (DL_FUNC)&wk_kvo_update, 7}, {"wk_kvo_batch", (DL_FUNC)&wk_kvo_batch, 7}, + {"wk_kvo_warmup_period", (DL_FUNC)&wk_kvo_warmup_period, 1}, + {"wk_kvo_is_ready", (DL_FUNC)&wk_kvo_is_ready, 1}, {"wk_kvo_reset", (DL_FUNC)&wk_kvo_reset, 1}, {"wk_kyles_lambda_new", (DL_FUNC)&wk_kyles_lambda_new, 1}, {"wk_kyles_lambda_update", (DL_FUNC)&wk_kyles_lambda_update, 6}, + {"wk_kyles_lambda_warmup_period", (DL_FUNC)&wk_kyles_lambda_warmup_period, 1}, + {"wk_kyles_lambda_is_ready", (DL_FUNC)&wk_kyles_lambda_is_ready, 1}, {"wk_kyles_lambda_reset", (DL_FUNC)&wk_kyles_lambda_reset, 1}, {"wk_ladder_bottom_new", (DL_FUNC)&wk_ladder_bottom_new, 0}, {"wk_ladder_bottom_update", (DL_FUNC)&wk_ladder_bottom_update, 7}, {"wk_ladder_bottom_batch", (DL_FUNC)&wk_ladder_bottom_batch, 7}, + {"wk_ladder_bottom_warmup_period", (DL_FUNC)&wk_ladder_bottom_warmup_period, 1}, + {"wk_ladder_bottom_is_ready", (DL_FUNC)&wk_ladder_bottom_is_ready, 1}, {"wk_ladder_bottom_reset", (DL_FUNC)&wk_ladder_bottom_reset, 1}, {"wk_laguerre_rsi_new", (DL_FUNC)&wk_laguerre_rsi_new, 1}, {"wk_laguerre_rsi_update", (DL_FUNC)&wk_laguerre_rsi_update, 2}, {"wk_laguerre_rsi_batch", (DL_FUNC)&wk_laguerre_rsi_batch, 2}, + {"wk_laguerre_rsi_warmup_period", (DL_FUNC)&wk_laguerre_rsi_warmup_period, 1}, + {"wk_laguerre_rsi_is_ready", (DL_FUNC)&wk_laguerre_rsi_is_ready, 1}, {"wk_laguerre_rsi_reset", (DL_FUNC)&wk_laguerre_rsi_reset, 1}, {"wk_lead_lag_cross_correlation_new", (DL_FUNC)&wk_lead_lag_cross_correlation_new, 2}, {"wk_lead_lag_cross_correlation_update", (DL_FUNC)&wk_lead_lag_cross_correlation_update, 3}, + {"wk_lead_lag_cross_correlation_warmup_period", (DL_FUNC)&wk_lead_lag_cross_correlation_warmup_period, 1}, + {"wk_lead_lag_cross_correlation_is_ready", (DL_FUNC)&wk_lead_lag_cross_correlation_is_ready, 1}, {"wk_lead_lag_cross_correlation_reset", (DL_FUNC)&wk_lead_lag_cross_correlation_reset, 1}, {"wk_lin_reg_angle_new", (DL_FUNC)&wk_lin_reg_angle_new, 1}, {"wk_lin_reg_angle_update", (DL_FUNC)&wk_lin_reg_angle_update, 2}, {"wk_lin_reg_angle_batch", (DL_FUNC)&wk_lin_reg_angle_batch, 2}, + {"wk_lin_reg_angle_warmup_period", (DL_FUNC)&wk_lin_reg_angle_warmup_period, 1}, + {"wk_lin_reg_angle_is_ready", (DL_FUNC)&wk_lin_reg_angle_is_ready, 1}, {"wk_lin_reg_angle_reset", (DL_FUNC)&wk_lin_reg_angle_reset, 1}, {"wk_lin_reg_channel_new", (DL_FUNC)&wk_lin_reg_channel_new, 2}, {"wk_lin_reg_channel_update", (DL_FUNC)&wk_lin_reg_channel_update, 2}, + {"wk_lin_reg_channel_warmup_period", (DL_FUNC)&wk_lin_reg_channel_warmup_period, 1}, + {"wk_lin_reg_channel_is_ready", (DL_FUNC)&wk_lin_reg_channel_is_ready, 1}, {"wk_lin_reg_channel_reset", (DL_FUNC)&wk_lin_reg_channel_reset, 1}, {"wk_lin_reg_intercept_new", (DL_FUNC)&wk_lin_reg_intercept_new, 1}, {"wk_lin_reg_intercept_update", (DL_FUNC)&wk_lin_reg_intercept_update, 2}, {"wk_lin_reg_intercept_batch", (DL_FUNC)&wk_lin_reg_intercept_batch, 2}, + {"wk_lin_reg_intercept_warmup_period", (DL_FUNC)&wk_lin_reg_intercept_warmup_period, 1}, + {"wk_lin_reg_intercept_is_ready", (DL_FUNC)&wk_lin_reg_intercept_is_ready, 1}, {"wk_lin_reg_intercept_reset", (DL_FUNC)&wk_lin_reg_intercept_reset, 1}, {"wk_lin_reg_slope_new", (DL_FUNC)&wk_lin_reg_slope_new, 1}, {"wk_lin_reg_slope_update", (DL_FUNC)&wk_lin_reg_slope_update, 2}, {"wk_lin_reg_slope_batch", (DL_FUNC)&wk_lin_reg_slope_batch, 2}, + {"wk_lin_reg_slope_warmup_period", (DL_FUNC)&wk_lin_reg_slope_warmup_period, 1}, + {"wk_lin_reg_slope_is_ready", (DL_FUNC)&wk_lin_reg_slope_is_ready, 1}, {"wk_lin_reg_slope_reset", (DL_FUNC)&wk_lin_reg_slope_reset, 1}, {"wk_linear_regression_new", (DL_FUNC)&wk_linear_regression_new, 1}, {"wk_linear_regression_update", (DL_FUNC)&wk_linear_regression_update, 2}, {"wk_linear_regression_batch", (DL_FUNC)&wk_linear_regression_batch, 2}, + {"wk_linear_regression_warmup_period", (DL_FUNC)&wk_linear_regression_warmup_period, 1}, + {"wk_linear_regression_is_ready", (DL_FUNC)&wk_linear_regression_is_ready, 1}, {"wk_linear_regression_reset", (DL_FUNC)&wk_linear_regression_reset, 1}, {"wk_liquidation_features_new", (DL_FUNC)&wk_liquidation_features_new, 0}, {"wk_liquidation_features_update", (DL_FUNC)&wk_liquidation_features_update, 13}, + {"wk_liquidation_features_warmup_period", (DL_FUNC)&wk_liquidation_features_warmup_period, 1}, + {"wk_liquidation_features_is_ready", (DL_FUNC)&wk_liquidation_features_is_ready, 1}, {"wk_liquidation_features_reset", (DL_FUNC)&wk_liquidation_features_reset, 1}, {"wk_log_return_new", (DL_FUNC)&wk_log_return_new, 1}, {"wk_log_return_update", (DL_FUNC)&wk_log_return_update, 2}, {"wk_log_return_batch", (DL_FUNC)&wk_log_return_batch, 2}, + {"wk_log_return_warmup_period", (DL_FUNC)&wk_log_return_warmup_period, 1}, + {"wk_log_return_is_ready", (DL_FUNC)&wk_log_return_is_ready, 1}, {"wk_log_return_reset", (DL_FUNC)&wk_log_return_reset, 1}, {"wk_long_legged_doji_new", (DL_FUNC)&wk_long_legged_doji_new, 0}, {"wk_long_legged_doji_update", (DL_FUNC)&wk_long_legged_doji_update, 7}, {"wk_long_legged_doji_batch", (DL_FUNC)&wk_long_legged_doji_batch, 7}, + {"wk_long_legged_doji_warmup_period", (DL_FUNC)&wk_long_legged_doji_warmup_period, 1}, + {"wk_long_legged_doji_is_ready", (DL_FUNC)&wk_long_legged_doji_is_ready, 1}, {"wk_long_legged_doji_reset", (DL_FUNC)&wk_long_legged_doji_reset, 1}, {"wk_long_line_new", (DL_FUNC)&wk_long_line_new, 0}, {"wk_long_line_update", (DL_FUNC)&wk_long_line_update, 7}, {"wk_long_line_batch", (DL_FUNC)&wk_long_line_batch, 7}, + {"wk_long_line_warmup_period", (DL_FUNC)&wk_long_line_warmup_period, 1}, + {"wk_long_line_is_ready", (DL_FUNC)&wk_long_line_is_ready, 1}, {"wk_long_line_reset", (DL_FUNC)&wk_long_line_reset, 1}, {"wk_long_short_ratio_new", (DL_FUNC)&wk_long_short_ratio_new, 0}, {"wk_long_short_ratio_update", (DL_FUNC)&wk_long_short_ratio_update, 13}, + {"wk_long_short_ratio_warmup_period", (DL_FUNC)&wk_long_short_ratio_warmup_period, 1}, + {"wk_long_short_ratio_is_ready", (DL_FUNC)&wk_long_short_ratio_is_ready, 1}, {"wk_long_short_ratio_reset", (DL_FUNC)&wk_long_short_ratio_reset, 1}, {"wk_m2_measure_new", (DL_FUNC)&wk_m2_measure_new, 3}, {"wk_m2_measure_update", (DL_FUNC)&wk_m2_measure_update, 2}, {"wk_m2_measure_batch", (DL_FUNC)&wk_m2_measure_batch, 2}, + {"wk_m2_measure_warmup_period", (DL_FUNC)&wk_m2_measure_warmup_period, 1}, + {"wk_m2_measure_is_ready", (DL_FUNC)&wk_m2_measure_is_ready, 1}, {"wk_m2_measure_reset", (DL_FUNC)&wk_m2_measure_reset, 1}, {"wk_ma_envelope_new", (DL_FUNC)&wk_ma_envelope_new, 2}, {"wk_ma_envelope_update", (DL_FUNC)&wk_ma_envelope_update, 2}, + {"wk_ma_envelope_warmup_period", (DL_FUNC)&wk_ma_envelope_warmup_period, 1}, + {"wk_ma_envelope_is_ready", (DL_FUNC)&wk_ma_envelope_is_ready, 1}, {"wk_ma_envelope_reset", (DL_FUNC)&wk_ma_envelope_reset, 1}, {"wk_macd_ext_new", (DL_FUNC)&wk_macd_ext_new, 6}, {"wk_macd_ext_update", (DL_FUNC)&wk_macd_ext_update, 2}, + {"wk_macd_ext_warmup_period", (DL_FUNC)&wk_macd_ext_warmup_period, 1}, + {"wk_macd_ext_is_ready", (DL_FUNC)&wk_macd_ext_is_ready, 1}, {"wk_macd_ext_reset", (DL_FUNC)&wk_macd_ext_reset, 1}, {"wk_macd_fix_new", (DL_FUNC)&wk_macd_fix_new, 1}, {"wk_macd_fix_update", (DL_FUNC)&wk_macd_fix_update, 2}, + {"wk_macd_fix_warmup_period", (DL_FUNC)&wk_macd_fix_warmup_period, 1}, + {"wk_macd_fix_is_ready", (DL_FUNC)&wk_macd_fix_is_ready, 1}, {"wk_macd_fix_reset", (DL_FUNC)&wk_macd_fix_reset, 1}, {"wk_macd_histogram_new", (DL_FUNC)&wk_macd_histogram_new, 3}, {"wk_macd_histogram_update", (DL_FUNC)&wk_macd_histogram_update, 2}, {"wk_macd_histogram_batch", (DL_FUNC)&wk_macd_histogram_batch, 2}, + {"wk_macd_histogram_warmup_period", (DL_FUNC)&wk_macd_histogram_warmup_period, 1}, + {"wk_macd_histogram_is_ready", (DL_FUNC)&wk_macd_histogram_is_ready, 1}, {"wk_macd_histogram_reset", (DL_FUNC)&wk_macd_histogram_reset, 1}, {"wk_macd_indicator_new", (DL_FUNC)&wk_macd_indicator_new, 3}, {"wk_macd_indicator_update", (DL_FUNC)&wk_macd_indicator_update, 2}, + {"wk_macd_indicator_warmup_period", (DL_FUNC)&wk_macd_indicator_warmup_period, 1}, + {"wk_macd_indicator_is_ready", (DL_FUNC)&wk_macd_indicator_is_ready, 1}, {"wk_macd_indicator_reset", (DL_FUNC)&wk_macd_indicator_reset, 1}, {"wk_mama_new", (DL_FUNC)&wk_mama_new, 2}, {"wk_mama_update", (DL_FUNC)&wk_mama_update, 2}, + {"wk_mama_warmup_period", (DL_FUNC)&wk_mama_warmup_period, 1}, + {"wk_mama_is_ready", (DL_FUNC)&wk_mama_is_ready, 1}, {"wk_mama_reset", (DL_FUNC)&wk_mama_reset, 1}, {"wk_market_facilitation_index_new", (DL_FUNC)&wk_market_facilitation_index_new, 0}, {"wk_market_facilitation_index_update", (DL_FUNC)&wk_market_facilitation_index_update, 7}, {"wk_market_facilitation_index_batch", (DL_FUNC)&wk_market_facilitation_index_batch, 7}, + {"wk_market_facilitation_index_warmup_period", (DL_FUNC)&wk_market_facilitation_index_warmup_period, 1}, + {"wk_market_facilitation_index_is_ready", (DL_FUNC)&wk_market_facilitation_index_is_ready, 1}, {"wk_market_facilitation_index_reset", (DL_FUNC)&wk_market_facilitation_index_reset, 1}, {"wk_martin_ratio_new", (DL_FUNC)&wk_martin_ratio_new, 1}, {"wk_martin_ratio_update", (DL_FUNC)&wk_martin_ratio_update, 2}, {"wk_martin_ratio_batch", (DL_FUNC)&wk_martin_ratio_batch, 2}, + {"wk_martin_ratio_warmup_period", (DL_FUNC)&wk_martin_ratio_warmup_period, 1}, + {"wk_martin_ratio_is_ready", (DL_FUNC)&wk_martin_ratio_is_ready, 1}, {"wk_martin_ratio_reset", (DL_FUNC)&wk_martin_ratio_reset, 1}, {"wk_marubozu_new", (DL_FUNC)&wk_marubozu_new, 0}, {"wk_marubozu_update", (DL_FUNC)&wk_marubozu_update, 7}, {"wk_marubozu_batch", (DL_FUNC)&wk_marubozu_batch, 7}, + {"wk_marubozu_warmup_period", (DL_FUNC)&wk_marubozu_warmup_period, 1}, + {"wk_marubozu_is_ready", (DL_FUNC)&wk_marubozu_is_ready, 1}, {"wk_marubozu_reset", (DL_FUNC)&wk_marubozu_reset, 1}, {"wk_mass_index_new", (DL_FUNC)&wk_mass_index_new, 2}, {"wk_mass_index_update", (DL_FUNC)&wk_mass_index_update, 7}, {"wk_mass_index_batch", (DL_FUNC)&wk_mass_index_batch, 7}, + {"wk_mass_index_warmup_period", (DL_FUNC)&wk_mass_index_warmup_period, 1}, + {"wk_mass_index_is_ready", (DL_FUNC)&wk_mass_index_is_ready, 1}, {"wk_mass_index_reset", (DL_FUNC)&wk_mass_index_reset, 1}, {"wk_mat_hold_new", (DL_FUNC)&wk_mat_hold_new, 0}, {"wk_mat_hold_update", (DL_FUNC)&wk_mat_hold_update, 7}, {"wk_mat_hold_batch", (DL_FUNC)&wk_mat_hold_batch, 7}, + {"wk_mat_hold_warmup_period", (DL_FUNC)&wk_mat_hold_warmup_period, 1}, + {"wk_mat_hold_is_ready", (DL_FUNC)&wk_mat_hold_is_ready, 1}, {"wk_mat_hold_reset", (DL_FUNC)&wk_mat_hold_reset, 1}, {"wk_matching_low_new", (DL_FUNC)&wk_matching_low_new, 0}, {"wk_matching_low_update", (DL_FUNC)&wk_matching_low_update, 7}, {"wk_matching_low_batch", (DL_FUNC)&wk_matching_low_batch, 7}, + {"wk_matching_low_warmup_period", (DL_FUNC)&wk_matching_low_warmup_period, 1}, + {"wk_matching_low_is_ready", (DL_FUNC)&wk_matching_low_is_ready, 1}, {"wk_matching_low_reset", (DL_FUNC)&wk_matching_low_reset, 1}, {"wk_max_drawdown_new", (DL_FUNC)&wk_max_drawdown_new, 1}, {"wk_max_drawdown_update", (DL_FUNC)&wk_max_drawdown_update, 2}, {"wk_max_drawdown_batch", (DL_FUNC)&wk_max_drawdown_batch, 2}, + {"wk_max_drawdown_warmup_period", (DL_FUNC)&wk_max_drawdown_warmup_period, 1}, + {"wk_max_drawdown_is_ready", (DL_FUNC)&wk_max_drawdown_is_ready, 1}, {"wk_max_drawdown_reset", (DL_FUNC)&wk_max_drawdown_reset, 1}, {"wk_mc_clellan_oscillator_new", (DL_FUNC)&wk_mc_clellan_oscillator_new, 0}, {"wk_mc_clellan_oscillator_update", (DL_FUNC)&wk_mc_clellan_oscillator_update, 8}, + {"wk_mc_clellan_oscillator_warmup_period", (DL_FUNC)&wk_mc_clellan_oscillator_warmup_period, 1}, + {"wk_mc_clellan_oscillator_is_ready", (DL_FUNC)&wk_mc_clellan_oscillator_is_ready, 1}, {"wk_mc_clellan_oscillator_reset", (DL_FUNC)&wk_mc_clellan_oscillator_reset, 1}, {"wk_mc_clellan_summation_index_new", (DL_FUNC)&wk_mc_clellan_summation_index_new, 0}, {"wk_mc_clellan_summation_index_update", (DL_FUNC)&wk_mc_clellan_summation_index_update, 8}, + {"wk_mc_clellan_summation_index_warmup_period", (DL_FUNC)&wk_mc_clellan_summation_index_warmup_period, 1}, + {"wk_mc_clellan_summation_index_is_ready", (DL_FUNC)&wk_mc_clellan_summation_index_is_ready, 1}, {"wk_mc_clellan_summation_index_reset", (DL_FUNC)&wk_mc_clellan_summation_index_reset, 1}, {"wk_mc_ginley_dynamic_new", (DL_FUNC)&wk_mc_ginley_dynamic_new, 1}, {"wk_mc_ginley_dynamic_update", (DL_FUNC)&wk_mc_ginley_dynamic_update, 2}, {"wk_mc_ginley_dynamic_batch", (DL_FUNC)&wk_mc_ginley_dynamic_batch, 2}, + {"wk_mc_ginley_dynamic_warmup_period", (DL_FUNC)&wk_mc_ginley_dynamic_warmup_period, 1}, + {"wk_mc_ginley_dynamic_is_ready", (DL_FUNC)&wk_mc_ginley_dynamic_is_ready, 1}, {"wk_mc_ginley_dynamic_reset", (DL_FUNC)&wk_mc_ginley_dynamic_reset, 1}, {"wk_median_absolute_deviation_new", (DL_FUNC)&wk_median_absolute_deviation_new, 1}, {"wk_median_absolute_deviation_update", (DL_FUNC)&wk_median_absolute_deviation_update, 2}, {"wk_median_absolute_deviation_batch", (DL_FUNC)&wk_median_absolute_deviation_batch, 2}, + {"wk_median_absolute_deviation_warmup_period", (DL_FUNC)&wk_median_absolute_deviation_warmup_period, 1}, + {"wk_median_absolute_deviation_is_ready", (DL_FUNC)&wk_median_absolute_deviation_is_ready, 1}, {"wk_median_absolute_deviation_reset", (DL_FUNC)&wk_median_absolute_deviation_reset, 1}, {"wk_median_channel_new", (DL_FUNC)&wk_median_channel_new, 2}, {"wk_median_channel_update", (DL_FUNC)&wk_median_channel_update, 2}, + {"wk_median_channel_warmup_period", (DL_FUNC)&wk_median_channel_warmup_period, 1}, + {"wk_median_channel_is_ready", (DL_FUNC)&wk_median_channel_is_ready, 1}, {"wk_median_channel_reset", (DL_FUNC)&wk_median_channel_reset, 1}, {"wk_median_ma_new", (DL_FUNC)&wk_median_ma_new, 1}, {"wk_median_ma_update", (DL_FUNC)&wk_median_ma_update, 2}, {"wk_median_ma_batch", (DL_FUNC)&wk_median_ma_batch, 2}, + {"wk_median_ma_warmup_period", (DL_FUNC)&wk_median_ma_warmup_period, 1}, + {"wk_median_ma_is_ready", (DL_FUNC)&wk_median_ma_is_ready, 1}, {"wk_median_ma_reset", (DL_FUNC)&wk_median_ma_reset, 1}, {"wk_median_price_new", (DL_FUNC)&wk_median_price_new, 0}, {"wk_median_price_update", (DL_FUNC)&wk_median_price_update, 7}, {"wk_median_price_batch", (DL_FUNC)&wk_median_price_batch, 7}, + {"wk_median_price_warmup_period", (DL_FUNC)&wk_median_price_warmup_period, 1}, + {"wk_median_price_is_ready", (DL_FUNC)&wk_median_price_is_ready, 1}, {"wk_median_price_reset", (DL_FUNC)&wk_median_price_reset, 1}, {"wk_mfi_new", (DL_FUNC)&wk_mfi_new, 1}, {"wk_mfi_update", (DL_FUNC)&wk_mfi_update, 7}, {"wk_mfi_batch", (DL_FUNC)&wk_mfi_batch, 7}, + {"wk_mfi_warmup_period", (DL_FUNC)&wk_mfi_warmup_period, 1}, + {"wk_mfi_is_ready", (DL_FUNC)&wk_mfi_is_ready, 1}, {"wk_mfi_reset", (DL_FUNC)&wk_mfi_reset, 1}, {"wk_microprice_new", (DL_FUNC)&wk_microprice_new, 0}, {"wk_microprice_update", (DL_FUNC)&wk_microprice_update, 5}, + {"wk_microprice_warmup_period", (DL_FUNC)&wk_microprice_warmup_period, 1}, + {"wk_microprice_is_ready", (DL_FUNC)&wk_microprice_is_ready, 1}, {"wk_microprice_reset", (DL_FUNC)&wk_microprice_reset, 1}, {"wk_mid_point_new", (DL_FUNC)&wk_mid_point_new, 1}, {"wk_mid_point_update", (DL_FUNC)&wk_mid_point_update, 2}, {"wk_mid_point_batch", (DL_FUNC)&wk_mid_point_batch, 2}, + {"wk_mid_point_warmup_period", (DL_FUNC)&wk_mid_point_warmup_period, 1}, + {"wk_mid_point_is_ready", (DL_FUNC)&wk_mid_point_is_ready, 1}, {"wk_mid_point_reset", (DL_FUNC)&wk_mid_point_reset, 1}, {"wk_mid_price_new", (DL_FUNC)&wk_mid_price_new, 1}, {"wk_mid_price_update", (DL_FUNC)&wk_mid_price_update, 7}, {"wk_mid_price_batch", (DL_FUNC)&wk_mid_price_batch, 7}, + {"wk_mid_price_warmup_period", (DL_FUNC)&wk_mid_price_warmup_period, 1}, + {"wk_mid_price_is_ready", (DL_FUNC)&wk_mid_price_is_ready, 1}, {"wk_mid_price_reset", (DL_FUNC)&wk_mid_price_reset, 1}, {"wk_minus_di_new", (DL_FUNC)&wk_minus_di_new, 1}, {"wk_minus_di_update", (DL_FUNC)&wk_minus_di_update, 7}, {"wk_minus_di_batch", (DL_FUNC)&wk_minus_di_batch, 7}, + {"wk_minus_di_warmup_period", (DL_FUNC)&wk_minus_di_warmup_period, 1}, + {"wk_minus_di_is_ready", (DL_FUNC)&wk_minus_di_is_ready, 1}, {"wk_minus_di_reset", (DL_FUNC)&wk_minus_di_reset, 1}, {"wk_minus_dm_new", (DL_FUNC)&wk_minus_dm_new, 1}, {"wk_minus_dm_update", (DL_FUNC)&wk_minus_dm_update, 7}, {"wk_minus_dm_batch", (DL_FUNC)&wk_minus_dm_batch, 7}, + {"wk_minus_dm_warmup_period", (DL_FUNC)&wk_minus_dm_warmup_period, 1}, + {"wk_minus_dm_is_ready", (DL_FUNC)&wk_minus_dm_is_ready, 1}, {"wk_minus_dm_reset", (DL_FUNC)&wk_minus_dm_reset, 1}, {"wk_modified_ma_stop_new", (DL_FUNC)&wk_modified_ma_stop_new, 1}, {"wk_modified_ma_stop_update", (DL_FUNC)&wk_modified_ma_stop_update, 7}, + {"wk_modified_ma_stop_warmup_period", (DL_FUNC)&wk_modified_ma_stop_warmup_period, 1}, + {"wk_modified_ma_stop_is_ready", (DL_FUNC)&wk_modified_ma_stop_is_ready, 1}, {"wk_modified_ma_stop_reset", (DL_FUNC)&wk_modified_ma_stop_reset, 1}, {"wk_mom_new", (DL_FUNC)&wk_mom_new, 1}, {"wk_mom_update", (DL_FUNC)&wk_mom_update, 2}, {"wk_mom_batch", (DL_FUNC)&wk_mom_batch, 2}, + {"wk_mom_warmup_period", (DL_FUNC)&wk_mom_warmup_period, 1}, + {"wk_mom_is_ready", (DL_FUNC)&wk_mom_is_ready, 1}, {"wk_mom_reset", (DL_FUNC)&wk_mom_reset, 1}, {"wk_morning_doji_star_new", (DL_FUNC)&wk_morning_doji_star_new, 0}, {"wk_morning_doji_star_update", (DL_FUNC)&wk_morning_doji_star_update, 7}, {"wk_morning_doji_star_batch", (DL_FUNC)&wk_morning_doji_star_batch, 7}, + {"wk_morning_doji_star_warmup_period", (DL_FUNC)&wk_morning_doji_star_warmup_period, 1}, + {"wk_morning_doji_star_is_ready", (DL_FUNC)&wk_morning_doji_star_is_ready, 1}, {"wk_morning_doji_star_reset", (DL_FUNC)&wk_morning_doji_star_reset, 1}, {"wk_morning_evening_star_new", (DL_FUNC)&wk_morning_evening_star_new, 0}, {"wk_morning_evening_star_update", (DL_FUNC)&wk_morning_evening_star_update, 7}, {"wk_morning_evening_star_batch", (DL_FUNC)&wk_morning_evening_star_batch, 7}, + {"wk_morning_evening_star_warmup_period", (DL_FUNC)&wk_morning_evening_star_warmup_period, 1}, + {"wk_morning_evening_star_is_ready", (DL_FUNC)&wk_morning_evening_star_is_ready, 1}, {"wk_morning_evening_star_reset", (DL_FUNC)&wk_morning_evening_star_reset, 1}, {"wk_murrey_math_lines_new", (DL_FUNC)&wk_murrey_math_lines_new, 1}, {"wk_murrey_math_lines_update", (DL_FUNC)&wk_murrey_math_lines_update, 7}, + {"wk_murrey_math_lines_warmup_period", (DL_FUNC)&wk_murrey_math_lines_warmup_period, 1}, + {"wk_murrey_math_lines_is_ready", (DL_FUNC)&wk_murrey_math_lines_is_ready, 1}, {"wk_murrey_math_lines_reset", (DL_FUNC)&wk_murrey_math_lines_reset, 1}, {"wk_naked_poc_new", (DL_FUNC)&wk_naked_poc_new, 2}, {"wk_naked_poc_update", (DL_FUNC)&wk_naked_poc_update, 7}, {"wk_naked_poc_batch", (DL_FUNC)&wk_naked_poc_batch, 7}, + {"wk_naked_poc_warmup_period", (DL_FUNC)&wk_naked_poc_warmup_period, 1}, + {"wk_naked_poc_is_ready", (DL_FUNC)&wk_naked_poc_is_ready, 1}, {"wk_naked_poc_reset", (DL_FUNC)&wk_naked_poc_reset, 1}, {"wk_natr_new", (DL_FUNC)&wk_natr_new, 1}, {"wk_natr_update", (DL_FUNC)&wk_natr_update, 7}, {"wk_natr_batch", (DL_FUNC)&wk_natr_batch, 7}, + {"wk_natr_warmup_period", (DL_FUNC)&wk_natr_warmup_period, 1}, + {"wk_natr_is_ready", (DL_FUNC)&wk_natr_is_ready, 1}, {"wk_natr_reset", (DL_FUNC)&wk_natr_reset, 1}, {"wk_new_highs_new_lows_new", (DL_FUNC)&wk_new_highs_new_lows_new, 0}, {"wk_new_highs_new_lows_update", (DL_FUNC)&wk_new_highs_new_lows_update, 8}, + {"wk_new_highs_new_lows_warmup_period", (DL_FUNC)&wk_new_highs_new_lows_warmup_period, 1}, + {"wk_new_highs_new_lows_is_ready", (DL_FUNC)&wk_new_highs_new_lows_is_ready, 1}, {"wk_new_highs_new_lows_reset", (DL_FUNC)&wk_new_highs_new_lows_reset, 1}, {"wk_new_price_lines_new", (DL_FUNC)&wk_new_price_lines_new, 1}, {"wk_new_price_lines_update", (DL_FUNC)&wk_new_price_lines_update, 7}, {"wk_new_price_lines_batch", (DL_FUNC)&wk_new_price_lines_batch, 7}, + {"wk_new_price_lines_warmup_period", (DL_FUNC)&wk_new_price_lines_warmup_period, 1}, + {"wk_new_price_lines_is_ready", (DL_FUNC)&wk_new_price_lines_is_ready, 1}, {"wk_new_price_lines_reset", (DL_FUNC)&wk_new_price_lines_reset, 1}, {"wk_nrtr_new", (DL_FUNC)&wk_nrtr_new, 1}, {"wk_nrtr_update", (DL_FUNC)&wk_nrtr_update, 7}, + {"wk_nrtr_warmup_period", (DL_FUNC)&wk_nrtr_warmup_period, 1}, + {"wk_nrtr_is_ready", (DL_FUNC)&wk_nrtr_is_ready, 1}, {"wk_nrtr_reset", (DL_FUNC)&wk_nrtr_reset, 1}, {"wk_nvi_new", (DL_FUNC)&wk_nvi_new, 0}, {"wk_nvi_update", (DL_FUNC)&wk_nvi_update, 7}, {"wk_nvi_batch", (DL_FUNC)&wk_nvi_batch, 7}, + {"wk_nvi_warmup_period", (DL_FUNC)&wk_nvi_warmup_period, 1}, + {"wk_nvi_is_ready", (DL_FUNC)&wk_nvi_is_ready, 1}, {"wk_nvi_reset", (DL_FUNC)&wk_nvi_reset, 1}, {"wk_obv_new", (DL_FUNC)&wk_obv_new, 0}, {"wk_obv_update", (DL_FUNC)&wk_obv_update, 7}, {"wk_obv_batch", (DL_FUNC)&wk_obv_batch, 7}, + {"wk_obv_warmup_period", (DL_FUNC)&wk_obv_warmup_period, 1}, + {"wk_obv_is_ready", (DL_FUNC)&wk_obv_is_ready, 1}, {"wk_obv_reset", (DL_FUNC)&wk_obv_reset, 1}, {"wk_oi_price_divergence_new", (DL_FUNC)&wk_oi_price_divergence_new, 1}, {"wk_oi_price_divergence_update", (DL_FUNC)&wk_oi_price_divergence_update, 13}, + {"wk_oi_price_divergence_warmup_period", (DL_FUNC)&wk_oi_price_divergence_warmup_period, 1}, + {"wk_oi_price_divergence_is_ready", (DL_FUNC)&wk_oi_price_divergence_is_ready, 1}, {"wk_oi_price_divergence_reset", (DL_FUNC)&wk_oi_price_divergence_reset, 1}, {"wk_oi_to_volume_ratio_new", (DL_FUNC)&wk_oi_to_volume_ratio_new, 0}, {"wk_oi_to_volume_ratio_update", (DL_FUNC)&wk_oi_to_volume_ratio_update, 13}, + {"wk_oi_to_volume_ratio_warmup_period", (DL_FUNC)&wk_oi_to_volume_ratio_warmup_period, 1}, + {"wk_oi_to_volume_ratio_is_ready", (DL_FUNC)&wk_oi_to_volume_ratio_is_ready, 1}, {"wk_oi_to_volume_ratio_reset", (DL_FUNC)&wk_oi_to_volume_ratio_reset, 1}, {"wk_oi_weighted_new", (DL_FUNC)&wk_oi_weighted_new, 0}, {"wk_oi_weighted_update", (DL_FUNC)&wk_oi_weighted_update, 13}, + {"wk_oi_weighted_warmup_period", (DL_FUNC)&wk_oi_weighted_warmup_period, 1}, + {"wk_oi_weighted_is_ready", (DL_FUNC)&wk_oi_weighted_is_ready, 1}, {"wk_oi_weighted_reset", (DL_FUNC)&wk_oi_weighted_reset, 1}, {"wk_omega_ratio_new", (DL_FUNC)&wk_omega_ratio_new, 2}, {"wk_omega_ratio_update", (DL_FUNC)&wk_omega_ratio_update, 2}, {"wk_omega_ratio_batch", (DL_FUNC)&wk_omega_ratio_batch, 2}, + {"wk_omega_ratio_warmup_period", (DL_FUNC)&wk_omega_ratio_warmup_period, 1}, + {"wk_omega_ratio_is_ready", (DL_FUNC)&wk_omega_ratio_is_ready, 1}, {"wk_omega_ratio_reset", (DL_FUNC)&wk_omega_ratio_reset, 1}, {"wk_on_neck_new", (DL_FUNC)&wk_on_neck_new, 0}, {"wk_on_neck_update", (DL_FUNC)&wk_on_neck_update, 7}, {"wk_on_neck_batch", (DL_FUNC)&wk_on_neck_batch, 7}, + {"wk_on_neck_warmup_period", (DL_FUNC)&wk_on_neck_warmup_period, 1}, + {"wk_on_neck_is_ready", (DL_FUNC)&wk_on_neck_is_ready, 1}, {"wk_on_neck_reset", (DL_FUNC)&wk_on_neck_reset, 1}, {"wk_open_interest_delta_new", (DL_FUNC)&wk_open_interest_delta_new, 0}, {"wk_open_interest_delta_update", (DL_FUNC)&wk_open_interest_delta_update, 13}, + {"wk_open_interest_delta_warmup_period", (DL_FUNC)&wk_open_interest_delta_warmup_period, 1}, + {"wk_open_interest_delta_is_ready", (DL_FUNC)&wk_open_interest_delta_is_ready, 1}, {"wk_open_interest_delta_reset", (DL_FUNC)&wk_open_interest_delta_reset, 1}, {"wk_open_interest_momentum_new", (DL_FUNC)&wk_open_interest_momentum_new, 1}, {"wk_open_interest_momentum_update", (DL_FUNC)&wk_open_interest_momentum_update, 13}, + {"wk_open_interest_momentum_warmup_period", (DL_FUNC)&wk_open_interest_momentum_warmup_period, 1}, + {"wk_open_interest_momentum_is_ready", (DL_FUNC)&wk_open_interest_momentum_is_ready, 1}, {"wk_open_interest_momentum_reset", (DL_FUNC)&wk_open_interest_momentum_reset, 1}, {"wk_opening_marubozu_new", (DL_FUNC)&wk_opening_marubozu_new, 0}, {"wk_opening_marubozu_update", (DL_FUNC)&wk_opening_marubozu_update, 7}, {"wk_opening_marubozu_batch", (DL_FUNC)&wk_opening_marubozu_batch, 7}, + {"wk_opening_marubozu_warmup_period", (DL_FUNC)&wk_opening_marubozu_warmup_period, 1}, + {"wk_opening_marubozu_is_ready", (DL_FUNC)&wk_opening_marubozu_is_ready, 1}, {"wk_opening_marubozu_reset", (DL_FUNC)&wk_opening_marubozu_reset, 1}, {"wk_opening_range_new", (DL_FUNC)&wk_opening_range_new, 1}, {"wk_opening_range_update", (DL_FUNC)&wk_opening_range_update, 7}, + {"wk_opening_range_warmup_period", (DL_FUNC)&wk_opening_range_warmup_period, 1}, + {"wk_opening_range_is_ready", (DL_FUNC)&wk_opening_range_is_ready, 1}, {"wk_opening_range_reset", (DL_FUNC)&wk_opening_range_reset, 1}, {"wk_order_book_imbalance_full_new", (DL_FUNC)&wk_order_book_imbalance_full_new, 0}, {"wk_order_book_imbalance_full_update", (DL_FUNC)&wk_order_book_imbalance_full_update, 5}, + {"wk_order_book_imbalance_full_warmup_period", (DL_FUNC)&wk_order_book_imbalance_full_warmup_period, 1}, + {"wk_order_book_imbalance_full_is_ready", (DL_FUNC)&wk_order_book_imbalance_full_is_ready, 1}, {"wk_order_book_imbalance_full_reset", (DL_FUNC)&wk_order_book_imbalance_full_reset, 1}, {"wk_order_book_imbalance_top1_new", (DL_FUNC)&wk_order_book_imbalance_top1_new, 0}, {"wk_order_book_imbalance_top1_update", (DL_FUNC)&wk_order_book_imbalance_top1_update, 5}, + {"wk_order_book_imbalance_top1_warmup_period", (DL_FUNC)&wk_order_book_imbalance_top1_warmup_period, 1}, + {"wk_order_book_imbalance_top1_is_ready", (DL_FUNC)&wk_order_book_imbalance_top1_is_ready, 1}, {"wk_order_book_imbalance_top1_reset", (DL_FUNC)&wk_order_book_imbalance_top1_reset, 1}, {"wk_order_book_imbalance_top_n_new", (DL_FUNC)&wk_order_book_imbalance_top_n_new, 1}, {"wk_order_book_imbalance_top_n_update", (DL_FUNC)&wk_order_book_imbalance_top_n_update, 5}, + {"wk_order_book_imbalance_top_n_warmup_period", (DL_FUNC)&wk_order_book_imbalance_top_n_warmup_period, 1}, + {"wk_order_book_imbalance_top_n_is_ready", (DL_FUNC)&wk_order_book_imbalance_top_n_is_ready, 1}, {"wk_order_book_imbalance_top_n_reset", (DL_FUNC)&wk_order_book_imbalance_top_n_reset, 1}, {"wk_order_flow_imbalance_new", (DL_FUNC)&wk_order_flow_imbalance_new, 1}, {"wk_order_flow_imbalance_update", (DL_FUNC)&wk_order_flow_imbalance_update, 5}, + {"wk_order_flow_imbalance_warmup_period", (DL_FUNC)&wk_order_flow_imbalance_warmup_period, 1}, + {"wk_order_flow_imbalance_is_ready", (DL_FUNC)&wk_order_flow_imbalance_is_ready, 1}, {"wk_order_flow_imbalance_reset", (DL_FUNC)&wk_order_flow_imbalance_reset, 1}, {"wk_ou_half_life_new", (DL_FUNC)&wk_ou_half_life_new, 1}, {"wk_ou_half_life_update", (DL_FUNC)&wk_ou_half_life_update, 3}, {"wk_ou_half_life_batch", (DL_FUNC)&wk_ou_half_life_batch, 3}, + {"wk_ou_half_life_warmup_period", (DL_FUNC)&wk_ou_half_life_warmup_period, 1}, + {"wk_ou_half_life_is_ready", (DL_FUNC)&wk_ou_half_life_is_ready, 1}, {"wk_ou_half_life_reset", (DL_FUNC)&wk_ou_half_life_reset, 1}, {"wk_overnight_gap_new", (DL_FUNC)&wk_overnight_gap_new, 1}, {"wk_overnight_gap_update", (DL_FUNC)&wk_overnight_gap_update, 7}, {"wk_overnight_gap_batch", (DL_FUNC)&wk_overnight_gap_batch, 7}, + {"wk_overnight_gap_warmup_period", (DL_FUNC)&wk_overnight_gap_warmup_period, 1}, + {"wk_overnight_gap_is_ready", (DL_FUNC)&wk_overnight_gap_is_ready, 1}, {"wk_overnight_gap_reset", (DL_FUNC)&wk_overnight_gap_reset, 1}, {"wk_overnight_intraday_return_new", (DL_FUNC)&wk_overnight_intraday_return_new, 1}, {"wk_overnight_intraday_return_update", (DL_FUNC)&wk_overnight_intraday_return_update, 7}, + {"wk_overnight_intraday_return_warmup_period", (DL_FUNC)&wk_overnight_intraday_return_warmup_period, 1}, + {"wk_overnight_intraday_return_is_ready", (DL_FUNC)&wk_overnight_intraday_return_is_ready, 1}, {"wk_overnight_intraday_return_reset", (DL_FUNC)&wk_overnight_intraday_return_reset, 1}, {"wk_pain_index_new", (DL_FUNC)&wk_pain_index_new, 1}, {"wk_pain_index_update", (DL_FUNC)&wk_pain_index_update, 2}, {"wk_pain_index_batch", (DL_FUNC)&wk_pain_index_batch, 2}, + {"wk_pain_index_warmup_period", (DL_FUNC)&wk_pain_index_warmup_period, 1}, + {"wk_pain_index_is_ready", (DL_FUNC)&wk_pain_index_is_ready, 1}, {"wk_pain_index_reset", (DL_FUNC)&wk_pain_index_reset, 1}, {"wk_pair_spread_z_score_new", (DL_FUNC)&wk_pair_spread_z_score_new, 2}, {"wk_pair_spread_z_score_update", (DL_FUNC)&wk_pair_spread_z_score_update, 3}, {"wk_pair_spread_z_score_batch", (DL_FUNC)&wk_pair_spread_z_score_batch, 3}, + {"wk_pair_spread_z_score_warmup_period", (DL_FUNC)&wk_pair_spread_z_score_warmup_period, 1}, + {"wk_pair_spread_z_score_is_ready", (DL_FUNC)&wk_pair_spread_z_score_is_ready, 1}, {"wk_pair_spread_z_score_reset", (DL_FUNC)&wk_pair_spread_z_score_reset, 1}, {"wk_pairwise_beta_new", (DL_FUNC)&wk_pairwise_beta_new, 1}, {"wk_pairwise_beta_update", (DL_FUNC)&wk_pairwise_beta_update, 3}, {"wk_pairwise_beta_batch", (DL_FUNC)&wk_pairwise_beta_batch, 3}, + {"wk_pairwise_beta_warmup_period", (DL_FUNC)&wk_pairwise_beta_warmup_period, 1}, + {"wk_pairwise_beta_is_ready", (DL_FUNC)&wk_pairwise_beta_is_ready, 1}, {"wk_pairwise_beta_reset", (DL_FUNC)&wk_pairwise_beta_reset, 1}, {"wk_parkinson_volatility_new", (DL_FUNC)&wk_parkinson_volatility_new, 2}, {"wk_parkinson_volatility_update", (DL_FUNC)&wk_parkinson_volatility_update, 7}, {"wk_parkinson_volatility_batch", (DL_FUNC)&wk_parkinson_volatility_batch, 7}, + {"wk_parkinson_volatility_warmup_period", (DL_FUNC)&wk_parkinson_volatility_warmup_period, 1}, + {"wk_parkinson_volatility_is_ready", (DL_FUNC)&wk_parkinson_volatility_is_ready, 1}, {"wk_parkinson_volatility_reset", (DL_FUNC)&wk_parkinson_volatility_reset, 1}, {"wk_pearson_correlation_new", (DL_FUNC)&wk_pearson_correlation_new, 1}, {"wk_pearson_correlation_update", (DL_FUNC)&wk_pearson_correlation_update, 3}, {"wk_pearson_correlation_batch", (DL_FUNC)&wk_pearson_correlation_batch, 3}, + {"wk_pearson_correlation_warmup_period", (DL_FUNC)&wk_pearson_correlation_warmup_period, 1}, + {"wk_pearson_correlation_is_ready", (DL_FUNC)&wk_pearson_correlation_is_ready, 1}, {"wk_pearson_correlation_reset", (DL_FUNC)&wk_pearson_correlation_reset, 1}, {"wk_percent_above_ma_new", (DL_FUNC)&wk_percent_above_ma_new, 0}, {"wk_percent_above_ma_update", (DL_FUNC)&wk_percent_above_ma_update, 8}, + {"wk_percent_above_ma_warmup_period", (DL_FUNC)&wk_percent_above_ma_warmup_period, 1}, + {"wk_percent_above_ma_is_ready", (DL_FUNC)&wk_percent_above_ma_is_ready, 1}, {"wk_percent_above_ma_reset", (DL_FUNC)&wk_percent_above_ma_reset, 1}, {"wk_percent_b_new", (DL_FUNC)&wk_percent_b_new, 2}, {"wk_percent_b_update", (DL_FUNC)&wk_percent_b_update, 2}, {"wk_percent_b_batch", (DL_FUNC)&wk_percent_b_batch, 2}, + {"wk_percent_b_warmup_period", (DL_FUNC)&wk_percent_b_warmup_period, 1}, + {"wk_percent_b_is_ready", (DL_FUNC)&wk_percent_b_is_ready, 1}, {"wk_percent_b_reset", (DL_FUNC)&wk_percent_b_reset, 1}, {"wk_percentage_trailing_stop_new", (DL_FUNC)&wk_percentage_trailing_stop_new, 1}, {"wk_percentage_trailing_stop_update", (DL_FUNC)&wk_percentage_trailing_stop_update, 2}, {"wk_percentage_trailing_stop_batch", (DL_FUNC)&wk_percentage_trailing_stop_batch, 2}, + {"wk_percentage_trailing_stop_warmup_period", (DL_FUNC)&wk_percentage_trailing_stop_warmup_period, 1}, + {"wk_percentage_trailing_stop_is_ready", (DL_FUNC)&wk_percentage_trailing_stop_is_ready, 1}, {"wk_percentage_trailing_stop_reset", (DL_FUNC)&wk_percentage_trailing_stop_reset, 1}, {"wk_perpetual_premium_index_new", (DL_FUNC)&wk_perpetual_premium_index_new, 0}, {"wk_perpetual_premium_index_update", (DL_FUNC)&wk_perpetual_premium_index_update, 13}, + {"wk_perpetual_premium_index_warmup_period", (DL_FUNC)&wk_perpetual_premium_index_warmup_period, 1}, + {"wk_perpetual_premium_index_is_ready", (DL_FUNC)&wk_perpetual_premium_index_is_ready, 1}, {"wk_perpetual_premium_index_reset", (DL_FUNC)&wk_perpetual_premium_index_reset, 1}, {"wk_pgo_new", (DL_FUNC)&wk_pgo_new, 1}, {"wk_pgo_update", (DL_FUNC)&wk_pgo_update, 7}, {"wk_pgo_batch", (DL_FUNC)&wk_pgo_batch, 7}, + {"wk_pgo_warmup_period", (DL_FUNC)&wk_pgo_warmup_period, 1}, + {"wk_pgo_is_ready", (DL_FUNC)&wk_pgo_is_ready, 1}, {"wk_pgo_reset", (DL_FUNC)&wk_pgo_reset, 1}, {"wk_piercing_dark_cloud_new", (DL_FUNC)&wk_piercing_dark_cloud_new, 0}, {"wk_piercing_dark_cloud_update", (DL_FUNC)&wk_piercing_dark_cloud_update, 7}, {"wk_piercing_dark_cloud_batch", (DL_FUNC)&wk_piercing_dark_cloud_batch, 7}, + {"wk_piercing_dark_cloud_warmup_period", (DL_FUNC)&wk_piercing_dark_cloud_warmup_period, 1}, + {"wk_piercing_dark_cloud_is_ready", (DL_FUNC)&wk_piercing_dark_cloud_is_ready, 1}, {"wk_piercing_dark_cloud_reset", (DL_FUNC)&wk_piercing_dark_cloud_reset, 1}, {"wk_pin_new", (DL_FUNC)&wk_pin_new, 1}, {"wk_pin_update", (DL_FUNC)&wk_pin_update, 5}, + {"wk_pin_warmup_period", (DL_FUNC)&wk_pin_warmup_period, 1}, + {"wk_pin_is_ready", (DL_FUNC)&wk_pin_is_ready, 1}, {"wk_pin_reset", (DL_FUNC)&wk_pin_reset, 1}, {"wk_pivot_reversal_new", (DL_FUNC)&wk_pivot_reversal_new, 2}, {"wk_pivot_reversal_update", (DL_FUNC)&wk_pivot_reversal_update, 7}, {"wk_pivot_reversal_batch", (DL_FUNC)&wk_pivot_reversal_batch, 7}, + {"wk_pivot_reversal_warmup_period", (DL_FUNC)&wk_pivot_reversal_warmup_period, 1}, + {"wk_pivot_reversal_is_ready", (DL_FUNC)&wk_pivot_reversal_is_ready, 1}, {"wk_pivot_reversal_reset", (DL_FUNC)&wk_pivot_reversal_reset, 1}, {"wk_plus_di_new", (DL_FUNC)&wk_plus_di_new, 1}, {"wk_plus_di_update", (DL_FUNC)&wk_plus_di_update, 7}, {"wk_plus_di_batch", (DL_FUNC)&wk_plus_di_batch, 7}, + {"wk_plus_di_warmup_period", (DL_FUNC)&wk_plus_di_warmup_period, 1}, + {"wk_plus_di_is_ready", (DL_FUNC)&wk_plus_di_is_ready, 1}, {"wk_plus_di_reset", (DL_FUNC)&wk_plus_di_reset, 1}, {"wk_plus_dm_new", (DL_FUNC)&wk_plus_dm_new, 1}, {"wk_plus_dm_update", (DL_FUNC)&wk_plus_dm_update, 7}, {"wk_plus_dm_batch", (DL_FUNC)&wk_plus_dm_batch, 7}, + {"wk_plus_dm_warmup_period", (DL_FUNC)&wk_plus_dm_warmup_period, 1}, + {"wk_plus_dm_is_ready", (DL_FUNC)&wk_plus_dm_is_ready, 1}, {"wk_plus_dm_reset", (DL_FUNC)&wk_plus_dm_reset, 1}, {"wk_pmo_new", (DL_FUNC)&wk_pmo_new, 2}, {"wk_pmo_update", (DL_FUNC)&wk_pmo_update, 2}, {"wk_pmo_batch", (DL_FUNC)&wk_pmo_batch, 2}, + {"wk_pmo_warmup_period", (DL_FUNC)&wk_pmo_warmup_period, 1}, + {"wk_pmo_is_ready", (DL_FUNC)&wk_pmo_is_ready, 1}, {"wk_pmo_reset", (DL_FUNC)&wk_pmo_reset, 1}, {"wk_point_and_figure_bars_new", (DL_FUNC)&wk_point_and_figure_bars_new, 2}, {"wk_point_and_figure_bars_update", (DL_FUNC)&wk_point_and_figure_bars_update, 7}, @@ -17571,83 +22215,125 @@ static const R_CallMethodDef CallEntries[] = { {"wk_polarized_fractal_efficiency_new", (DL_FUNC)&wk_polarized_fractal_efficiency_new, 2}, {"wk_polarized_fractal_efficiency_update", (DL_FUNC)&wk_polarized_fractal_efficiency_update, 2}, {"wk_polarized_fractal_efficiency_batch", (DL_FUNC)&wk_polarized_fractal_efficiency_batch, 2}, + {"wk_polarized_fractal_efficiency_warmup_period", (DL_FUNC)&wk_polarized_fractal_efficiency_warmup_period, 1}, + {"wk_polarized_fractal_efficiency_is_ready", (DL_FUNC)&wk_polarized_fractal_efficiency_is_ready, 1}, {"wk_polarized_fractal_efficiency_reset", (DL_FUNC)&wk_polarized_fractal_efficiency_reset, 1}, {"wk_ppo_new", (DL_FUNC)&wk_ppo_new, 2}, {"wk_ppo_update", (DL_FUNC)&wk_ppo_update, 2}, {"wk_ppo_batch", (DL_FUNC)&wk_ppo_batch, 2}, + {"wk_ppo_warmup_period", (DL_FUNC)&wk_ppo_warmup_period, 1}, + {"wk_ppo_is_ready", (DL_FUNC)&wk_ppo_is_ready, 1}, {"wk_ppo_reset", (DL_FUNC)&wk_ppo_reset, 1}, {"wk_ppo_histogram_new", (DL_FUNC)&wk_ppo_histogram_new, 3}, {"wk_ppo_histogram_update", (DL_FUNC)&wk_ppo_histogram_update, 2}, {"wk_ppo_histogram_batch", (DL_FUNC)&wk_ppo_histogram_batch, 2}, + {"wk_ppo_histogram_warmup_period", (DL_FUNC)&wk_ppo_histogram_warmup_period, 1}, + {"wk_ppo_histogram_is_ready", (DL_FUNC)&wk_ppo_histogram_is_ready, 1}, {"wk_ppo_histogram_reset", (DL_FUNC)&wk_ppo_histogram_reset, 1}, {"wk_profile_shape_new", (DL_FUNC)&wk_profile_shape_new, 2}, {"wk_profile_shape_update", (DL_FUNC)&wk_profile_shape_update, 7}, {"wk_profile_shape_batch", (DL_FUNC)&wk_profile_shape_batch, 7}, + {"wk_profile_shape_warmup_period", (DL_FUNC)&wk_profile_shape_warmup_period, 1}, + {"wk_profile_shape_is_ready", (DL_FUNC)&wk_profile_shape_is_ready, 1}, {"wk_profile_shape_reset", (DL_FUNC)&wk_profile_shape_reset, 1}, {"wk_profit_factor_new", (DL_FUNC)&wk_profit_factor_new, 1}, {"wk_profit_factor_update", (DL_FUNC)&wk_profit_factor_update, 2}, {"wk_profit_factor_batch", (DL_FUNC)&wk_profit_factor_batch, 2}, + {"wk_profit_factor_warmup_period", (DL_FUNC)&wk_profit_factor_warmup_period, 1}, + {"wk_profit_factor_is_ready", (DL_FUNC)&wk_profit_factor_is_ready, 1}, {"wk_profit_factor_reset", (DL_FUNC)&wk_profit_factor_reset, 1}, {"wk_projection_bands_new", (DL_FUNC)&wk_projection_bands_new, 1}, {"wk_projection_bands_update", (DL_FUNC)&wk_projection_bands_update, 7}, + {"wk_projection_bands_warmup_period", (DL_FUNC)&wk_projection_bands_warmup_period, 1}, + {"wk_projection_bands_is_ready", (DL_FUNC)&wk_projection_bands_is_ready, 1}, {"wk_projection_bands_reset", (DL_FUNC)&wk_projection_bands_reset, 1}, {"wk_projection_oscillator_new", (DL_FUNC)&wk_projection_oscillator_new, 1}, {"wk_projection_oscillator_update", (DL_FUNC)&wk_projection_oscillator_update, 7}, {"wk_projection_oscillator_batch", (DL_FUNC)&wk_projection_oscillator_batch, 7}, + {"wk_projection_oscillator_warmup_period", (DL_FUNC)&wk_projection_oscillator_warmup_period, 1}, + {"wk_projection_oscillator_is_ready", (DL_FUNC)&wk_projection_oscillator_is_ready, 1}, {"wk_projection_oscillator_reset", (DL_FUNC)&wk_projection_oscillator_reset, 1}, {"wk_psar_new", (DL_FUNC)&wk_psar_new, 3}, {"wk_psar_update", (DL_FUNC)&wk_psar_update, 7}, {"wk_psar_batch", (DL_FUNC)&wk_psar_batch, 7}, + {"wk_psar_warmup_period", (DL_FUNC)&wk_psar_warmup_period, 1}, + {"wk_psar_is_ready", (DL_FUNC)&wk_psar_is_ready, 1}, {"wk_psar_reset", (DL_FUNC)&wk_psar_reset, 1}, {"wk_pvi_new", (DL_FUNC)&wk_pvi_new, 0}, {"wk_pvi_update", (DL_FUNC)&wk_pvi_update, 7}, {"wk_pvi_batch", (DL_FUNC)&wk_pvi_batch, 7}, + {"wk_pvi_warmup_period", (DL_FUNC)&wk_pvi_warmup_period, 1}, + {"wk_pvi_is_ready", (DL_FUNC)&wk_pvi_is_ready, 1}, {"wk_pvi_reset", (DL_FUNC)&wk_pvi_reset, 1}, {"wk_qqe_new", (DL_FUNC)&wk_qqe_new, 3}, {"wk_qqe_update", (DL_FUNC)&wk_qqe_update, 2}, + {"wk_qqe_warmup_period", (DL_FUNC)&wk_qqe_warmup_period, 1}, + {"wk_qqe_is_ready", (DL_FUNC)&wk_qqe_is_ready, 1}, {"wk_qqe_reset", (DL_FUNC)&wk_qqe_reset, 1}, {"wk_qstick_new", (DL_FUNC)&wk_qstick_new, 1}, {"wk_qstick_update", (DL_FUNC)&wk_qstick_update, 7}, {"wk_qstick_batch", (DL_FUNC)&wk_qstick_batch, 7}, + {"wk_qstick_warmup_period", (DL_FUNC)&wk_qstick_warmup_period, 1}, + {"wk_qstick_is_ready", (DL_FUNC)&wk_qstick_is_ready, 1}, {"wk_qstick_reset", (DL_FUNC)&wk_qstick_reset, 1}, {"wk_quartile_bands_new", (DL_FUNC)&wk_quartile_bands_new, 1}, {"wk_quartile_bands_update", (DL_FUNC)&wk_quartile_bands_update, 2}, + {"wk_quartile_bands_warmup_period", (DL_FUNC)&wk_quartile_bands_warmup_period, 1}, + {"wk_quartile_bands_is_ready", (DL_FUNC)&wk_quartile_bands_is_ready, 1}, {"wk_quartile_bands_reset", (DL_FUNC)&wk_quartile_bands_reset, 1}, {"wk_quoted_spread_new", (DL_FUNC)&wk_quoted_spread_new, 0}, {"wk_quoted_spread_update", (DL_FUNC)&wk_quoted_spread_update, 5}, + {"wk_quoted_spread_warmup_period", (DL_FUNC)&wk_quoted_spread_warmup_period, 1}, + {"wk_quoted_spread_is_ready", (DL_FUNC)&wk_quoted_spread_is_ready, 1}, {"wk_quoted_spread_reset", (DL_FUNC)&wk_quoted_spread_reset, 1}, {"wk_r_squared_new", (DL_FUNC)&wk_r_squared_new, 1}, {"wk_r_squared_update", (DL_FUNC)&wk_r_squared_update, 2}, {"wk_r_squared_batch", (DL_FUNC)&wk_r_squared_batch, 2}, + {"wk_r_squared_warmup_period", (DL_FUNC)&wk_r_squared_warmup_period, 1}, + {"wk_r_squared_is_ready", (DL_FUNC)&wk_r_squared_is_ready, 1}, {"wk_r_squared_reset", (DL_FUNC)&wk_r_squared_reset, 1}, {"wk_range_bars_new", (DL_FUNC)&wk_range_bars_new, 1}, {"wk_range_bars_update", (DL_FUNC)&wk_range_bars_update, 7}, {"wk_range_bars_reset", (DL_FUNC)&wk_range_bars_reset, 1}, {"wk_realized_spread_new", (DL_FUNC)&wk_realized_spread_new, 1}, {"wk_realized_spread_update", (DL_FUNC)&wk_realized_spread_update, 6}, + {"wk_realized_spread_warmup_period", (DL_FUNC)&wk_realized_spread_warmup_period, 1}, + {"wk_realized_spread_is_ready", (DL_FUNC)&wk_realized_spread_is_ready, 1}, {"wk_realized_spread_reset", (DL_FUNC)&wk_realized_spread_reset, 1}, {"wk_realized_volatility_new", (DL_FUNC)&wk_realized_volatility_new, 1}, {"wk_realized_volatility_update", (DL_FUNC)&wk_realized_volatility_update, 2}, {"wk_realized_volatility_batch", (DL_FUNC)&wk_realized_volatility_batch, 2}, + {"wk_realized_volatility_warmup_period", (DL_FUNC)&wk_realized_volatility_warmup_period, 1}, + {"wk_realized_volatility_is_ready", (DL_FUNC)&wk_realized_volatility_is_ready, 1}, {"wk_realized_volatility_reset", (DL_FUNC)&wk_realized_volatility_reset, 1}, {"wk_recovery_factor_new", (DL_FUNC)&wk_recovery_factor_new, 0}, {"wk_recovery_factor_update", (DL_FUNC)&wk_recovery_factor_update, 2}, {"wk_recovery_factor_batch", (DL_FUNC)&wk_recovery_factor_batch, 2}, + {"wk_recovery_factor_warmup_period", (DL_FUNC)&wk_recovery_factor_warmup_period, 1}, + {"wk_recovery_factor_is_ready", (DL_FUNC)&wk_recovery_factor_is_ready, 1}, {"wk_recovery_factor_reset", (DL_FUNC)&wk_recovery_factor_reset, 1}, {"wk_rectangle_range_new", (DL_FUNC)&wk_rectangle_range_new, 0}, {"wk_rectangle_range_update", (DL_FUNC)&wk_rectangle_range_update, 7}, {"wk_rectangle_range_batch", (DL_FUNC)&wk_rectangle_range_batch, 7}, + {"wk_rectangle_range_warmup_period", (DL_FUNC)&wk_rectangle_range_warmup_period, 1}, + {"wk_rectangle_range_is_ready", (DL_FUNC)&wk_rectangle_range_is_ready, 1}, {"wk_rectangle_range_reset", (DL_FUNC)&wk_rectangle_range_reset, 1}, {"wk_reflex_new", (DL_FUNC)&wk_reflex_new, 1}, {"wk_reflex_update", (DL_FUNC)&wk_reflex_update, 2}, {"wk_reflex_batch", (DL_FUNC)&wk_reflex_batch, 2}, + {"wk_reflex_warmup_period", (DL_FUNC)&wk_reflex_warmup_period, 1}, + {"wk_reflex_is_ready", (DL_FUNC)&wk_reflex_is_ready, 1}, {"wk_reflex_reset", (DL_FUNC)&wk_reflex_reset, 1}, {"wk_regime_label_new", (DL_FUNC)&wk_regime_label_new, 2}, {"wk_regime_label_update", (DL_FUNC)&wk_regime_label_update, 2}, {"wk_regime_label_batch", (DL_FUNC)&wk_regime_label_batch, 2}, + {"wk_regime_label_warmup_period", (DL_FUNC)&wk_regime_label_warmup_period, 1}, + {"wk_regime_label_is_ready", (DL_FUNC)&wk_regime_label_is_ready, 1}, {"wk_regime_label_reset", (DL_FUNC)&wk_regime_label_reset, 1}, {"wk_relative_strength_ab_new", (DL_FUNC)&wk_relative_strength_ab_new, 2}, {"wk_relative_strength_ab_update", (DL_FUNC)&wk_relative_strength_ab_update, 3}, + {"wk_relative_strength_ab_warmup_period", (DL_FUNC)&wk_relative_strength_ab_warmup_period, 1}, + {"wk_relative_strength_ab_is_ready", (DL_FUNC)&wk_relative_strength_ab_is_ready, 1}, {"wk_relative_strength_ab_reset", (DL_FUNC)&wk_relative_strength_ab_reset, 1}, {"wk_renko_bars_new", (DL_FUNC)&wk_renko_bars_new, 1}, {"wk_renko_bars_update", (DL_FUNC)&wk_renko_bars_update, 7}, @@ -17655,81 +22341,121 @@ static const R_CallMethodDef CallEntries[] = { {"wk_renko_trailing_stop_new", (DL_FUNC)&wk_renko_trailing_stop_new, 1}, {"wk_renko_trailing_stop_update", (DL_FUNC)&wk_renko_trailing_stop_update, 2}, {"wk_renko_trailing_stop_batch", (DL_FUNC)&wk_renko_trailing_stop_batch, 2}, + {"wk_renko_trailing_stop_warmup_period", (DL_FUNC)&wk_renko_trailing_stop_warmup_period, 1}, + {"wk_renko_trailing_stop_is_ready", (DL_FUNC)&wk_renko_trailing_stop_is_ready, 1}, {"wk_renko_trailing_stop_reset", (DL_FUNC)&wk_renko_trailing_stop_reset, 1}, {"wk_rickshaw_man_new", (DL_FUNC)&wk_rickshaw_man_new, 0}, {"wk_rickshaw_man_update", (DL_FUNC)&wk_rickshaw_man_update, 7}, {"wk_rickshaw_man_batch", (DL_FUNC)&wk_rickshaw_man_batch, 7}, + {"wk_rickshaw_man_warmup_period", (DL_FUNC)&wk_rickshaw_man_warmup_period, 1}, + {"wk_rickshaw_man_is_ready", (DL_FUNC)&wk_rickshaw_man_is_ready, 1}, {"wk_rickshaw_man_reset", (DL_FUNC)&wk_rickshaw_man_reset, 1}, {"wk_rising_three_methods_new", (DL_FUNC)&wk_rising_three_methods_new, 0}, {"wk_rising_three_methods_update", (DL_FUNC)&wk_rising_three_methods_update, 7}, {"wk_rising_three_methods_batch", (DL_FUNC)&wk_rising_three_methods_batch, 7}, + {"wk_rising_three_methods_warmup_period", (DL_FUNC)&wk_rising_three_methods_warmup_period, 1}, + {"wk_rising_three_methods_is_ready", (DL_FUNC)&wk_rising_three_methods_is_ready, 1}, {"wk_rising_three_methods_reset", (DL_FUNC)&wk_rising_three_methods_reset, 1}, {"wk_rmi_new", (DL_FUNC)&wk_rmi_new, 2}, {"wk_rmi_update", (DL_FUNC)&wk_rmi_update, 2}, {"wk_rmi_batch", (DL_FUNC)&wk_rmi_batch, 2}, + {"wk_rmi_warmup_period", (DL_FUNC)&wk_rmi_warmup_period, 1}, + {"wk_rmi_is_ready", (DL_FUNC)&wk_rmi_is_ready, 1}, {"wk_rmi_reset", (DL_FUNC)&wk_rmi_reset, 1}, {"wk_roc_new", (DL_FUNC)&wk_roc_new, 1}, {"wk_roc_update", (DL_FUNC)&wk_roc_update, 2}, {"wk_roc_batch", (DL_FUNC)&wk_roc_batch, 2}, + {"wk_roc_warmup_period", (DL_FUNC)&wk_roc_warmup_period, 1}, + {"wk_roc_is_ready", (DL_FUNC)&wk_roc_is_ready, 1}, {"wk_roc_reset", (DL_FUNC)&wk_roc_reset, 1}, {"wk_rocp_new", (DL_FUNC)&wk_rocp_new, 1}, {"wk_rocp_update", (DL_FUNC)&wk_rocp_update, 2}, {"wk_rocp_batch", (DL_FUNC)&wk_rocp_batch, 2}, + {"wk_rocp_warmup_period", (DL_FUNC)&wk_rocp_warmup_period, 1}, + {"wk_rocp_is_ready", (DL_FUNC)&wk_rocp_is_ready, 1}, {"wk_rocp_reset", (DL_FUNC)&wk_rocp_reset, 1}, {"wk_rocr_new", (DL_FUNC)&wk_rocr_new, 1}, {"wk_rocr_update", (DL_FUNC)&wk_rocr_update, 2}, {"wk_rocr_batch", (DL_FUNC)&wk_rocr_batch, 2}, + {"wk_rocr_warmup_period", (DL_FUNC)&wk_rocr_warmup_period, 1}, + {"wk_rocr_is_ready", (DL_FUNC)&wk_rocr_is_ready, 1}, {"wk_rocr_reset", (DL_FUNC)&wk_rocr_reset, 1}, {"wk_rocr100_new", (DL_FUNC)&wk_rocr100_new, 1}, {"wk_rocr100_update", (DL_FUNC)&wk_rocr100_update, 2}, {"wk_rocr100_batch", (DL_FUNC)&wk_rocr100_batch, 2}, + {"wk_rocr100_warmup_period", (DL_FUNC)&wk_rocr100_warmup_period, 1}, + {"wk_rocr100_is_ready", (DL_FUNC)&wk_rocr100_is_ready, 1}, {"wk_rocr100_reset", (DL_FUNC)&wk_rocr100_reset, 1}, {"wk_rogers_satchell_volatility_new", (DL_FUNC)&wk_rogers_satchell_volatility_new, 2}, {"wk_rogers_satchell_volatility_update", (DL_FUNC)&wk_rogers_satchell_volatility_update, 7}, {"wk_rogers_satchell_volatility_batch", (DL_FUNC)&wk_rogers_satchell_volatility_batch, 7}, + {"wk_rogers_satchell_volatility_warmup_period", (DL_FUNC)&wk_rogers_satchell_volatility_warmup_period, 1}, + {"wk_rogers_satchell_volatility_is_ready", (DL_FUNC)&wk_rogers_satchell_volatility_is_ready, 1}, {"wk_rogers_satchell_volatility_reset", (DL_FUNC)&wk_rogers_satchell_volatility_reset, 1}, {"wk_roll_measure_new", (DL_FUNC)&wk_roll_measure_new, 1}, {"wk_roll_measure_update", (DL_FUNC)&wk_roll_measure_update, 5}, + {"wk_roll_measure_warmup_period", (DL_FUNC)&wk_roll_measure_warmup_period, 1}, + {"wk_roll_measure_is_ready", (DL_FUNC)&wk_roll_measure_is_ready, 1}, {"wk_roll_measure_reset", (DL_FUNC)&wk_roll_measure_reset, 1}, {"wk_rolling_correlation_new", (DL_FUNC)&wk_rolling_correlation_new, 1}, {"wk_rolling_correlation_update", (DL_FUNC)&wk_rolling_correlation_update, 3}, {"wk_rolling_correlation_batch", (DL_FUNC)&wk_rolling_correlation_batch, 3}, + {"wk_rolling_correlation_warmup_period", (DL_FUNC)&wk_rolling_correlation_warmup_period, 1}, + {"wk_rolling_correlation_is_ready", (DL_FUNC)&wk_rolling_correlation_is_ready, 1}, {"wk_rolling_correlation_reset", (DL_FUNC)&wk_rolling_correlation_reset, 1}, {"wk_rolling_covariance_new", (DL_FUNC)&wk_rolling_covariance_new, 1}, {"wk_rolling_covariance_update", (DL_FUNC)&wk_rolling_covariance_update, 3}, {"wk_rolling_covariance_batch", (DL_FUNC)&wk_rolling_covariance_batch, 3}, + {"wk_rolling_covariance_warmup_period", (DL_FUNC)&wk_rolling_covariance_warmup_period, 1}, + {"wk_rolling_covariance_is_ready", (DL_FUNC)&wk_rolling_covariance_is_ready, 1}, {"wk_rolling_covariance_reset", (DL_FUNC)&wk_rolling_covariance_reset, 1}, {"wk_rolling_iqr_new", (DL_FUNC)&wk_rolling_iqr_new, 1}, {"wk_rolling_iqr_update", (DL_FUNC)&wk_rolling_iqr_update, 2}, {"wk_rolling_iqr_batch", (DL_FUNC)&wk_rolling_iqr_batch, 2}, + {"wk_rolling_iqr_warmup_period", (DL_FUNC)&wk_rolling_iqr_warmup_period, 1}, + {"wk_rolling_iqr_is_ready", (DL_FUNC)&wk_rolling_iqr_is_ready, 1}, {"wk_rolling_iqr_reset", (DL_FUNC)&wk_rolling_iqr_reset, 1}, {"wk_rolling_min_max_scaler_new", (DL_FUNC)&wk_rolling_min_max_scaler_new, 1}, {"wk_rolling_min_max_scaler_update", (DL_FUNC)&wk_rolling_min_max_scaler_update, 2}, {"wk_rolling_min_max_scaler_batch", (DL_FUNC)&wk_rolling_min_max_scaler_batch, 2}, + {"wk_rolling_min_max_scaler_warmup_period", (DL_FUNC)&wk_rolling_min_max_scaler_warmup_period, 1}, + {"wk_rolling_min_max_scaler_is_ready", (DL_FUNC)&wk_rolling_min_max_scaler_is_ready, 1}, {"wk_rolling_min_max_scaler_reset", (DL_FUNC)&wk_rolling_min_max_scaler_reset, 1}, {"wk_rolling_percentile_rank_new", (DL_FUNC)&wk_rolling_percentile_rank_new, 1}, {"wk_rolling_percentile_rank_update", (DL_FUNC)&wk_rolling_percentile_rank_update, 2}, {"wk_rolling_percentile_rank_batch", (DL_FUNC)&wk_rolling_percentile_rank_batch, 2}, + {"wk_rolling_percentile_rank_warmup_period", (DL_FUNC)&wk_rolling_percentile_rank_warmup_period, 1}, + {"wk_rolling_percentile_rank_is_ready", (DL_FUNC)&wk_rolling_percentile_rank_is_ready, 1}, {"wk_rolling_percentile_rank_reset", (DL_FUNC)&wk_rolling_percentile_rank_reset, 1}, {"wk_rolling_quantile_new", (DL_FUNC)&wk_rolling_quantile_new, 2}, {"wk_rolling_quantile_update", (DL_FUNC)&wk_rolling_quantile_update, 2}, {"wk_rolling_quantile_batch", (DL_FUNC)&wk_rolling_quantile_batch, 2}, + {"wk_rolling_quantile_warmup_period", (DL_FUNC)&wk_rolling_quantile_warmup_period, 1}, + {"wk_rolling_quantile_is_ready", (DL_FUNC)&wk_rolling_quantile_is_ready, 1}, {"wk_rolling_quantile_reset", (DL_FUNC)&wk_rolling_quantile_reset, 1}, {"wk_rolling_vwap_new", (DL_FUNC)&wk_rolling_vwap_new, 1}, {"wk_rolling_vwap_update", (DL_FUNC)&wk_rolling_vwap_update, 7}, {"wk_rolling_vwap_batch", (DL_FUNC)&wk_rolling_vwap_batch, 7}, + {"wk_rolling_vwap_warmup_period", (DL_FUNC)&wk_rolling_vwap_warmup_period, 1}, + {"wk_rolling_vwap_is_ready", (DL_FUNC)&wk_rolling_vwap_is_ready, 1}, {"wk_rolling_vwap_reset", (DL_FUNC)&wk_rolling_vwap_reset, 1}, {"wk_roofing_filter_new", (DL_FUNC)&wk_roofing_filter_new, 2}, {"wk_roofing_filter_update", (DL_FUNC)&wk_roofing_filter_update, 2}, {"wk_roofing_filter_batch", (DL_FUNC)&wk_roofing_filter_batch, 2}, + {"wk_roofing_filter_warmup_period", (DL_FUNC)&wk_roofing_filter_warmup_period, 1}, + {"wk_roofing_filter_is_ready", (DL_FUNC)&wk_roofing_filter_is_ready, 1}, {"wk_roofing_filter_reset", (DL_FUNC)&wk_roofing_filter_reset, 1}, {"wk_rsi_new", (DL_FUNC)&wk_rsi_new, 1}, {"wk_rsi_update", (DL_FUNC)&wk_rsi_update, 2}, {"wk_rsi_batch", (DL_FUNC)&wk_rsi_batch, 2}, + {"wk_rsi_warmup_period", (DL_FUNC)&wk_rsi_warmup_period, 1}, + {"wk_rsi_is_ready", (DL_FUNC)&wk_rsi_is_ready, 1}, {"wk_rsi_reset", (DL_FUNC)&wk_rsi_reset, 1}, {"wk_rsx_new", (DL_FUNC)&wk_rsx_new, 1}, {"wk_rsx_update", (DL_FUNC)&wk_rsx_update, 2}, {"wk_rsx_batch", (DL_FUNC)&wk_rsx_batch, 2}, + {"wk_rsx_warmup_period", (DL_FUNC)&wk_rsx_warmup_period, 1}, + {"wk_rsx_is_ready", (DL_FUNC)&wk_rsx_is_ready, 1}, {"wk_rsx_reset", (DL_FUNC)&wk_rsx_reset, 1}, {"wk_run_bars_new", (DL_FUNC)&wk_run_bars_new, 1}, {"wk_run_bars_update", (DL_FUNC)&wk_run_bars_update, 7}, @@ -17737,277 +22463,423 @@ static const R_CallMethodDef CallEntries[] = { {"wk_rvi_new", (DL_FUNC)&wk_rvi_new, 1}, {"wk_rvi_update", (DL_FUNC)&wk_rvi_update, 7}, {"wk_rvi_batch", (DL_FUNC)&wk_rvi_batch, 7}, + {"wk_rvi_warmup_period", (DL_FUNC)&wk_rvi_warmup_period, 1}, + {"wk_rvi_is_ready", (DL_FUNC)&wk_rvi_is_ready, 1}, {"wk_rvi_reset", (DL_FUNC)&wk_rvi_reset, 1}, {"wk_rvi_volatility_new", (DL_FUNC)&wk_rvi_volatility_new, 1}, {"wk_rvi_volatility_update", (DL_FUNC)&wk_rvi_volatility_update, 2}, {"wk_rvi_volatility_batch", (DL_FUNC)&wk_rvi_volatility_batch, 2}, + {"wk_rvi_volatility_warmup_period", (DL_FUNC)&wk_rvi_volatility_warmup_period, 1}, + {"wk_rvi_volatility_is_ready", (DL_FUNC)&wk_rvi_volatility_is_ready, 1}, {"wk_rvi_volatility_reset", (DL_FUNC)&wk_rvi_volatility_reset, 1}, {"wk_rwi_new", (DL_FUNC)&wk_rwi_new, 1}, {"wk_rwi_update", (DL_FUNC)&wk_rwi_update, 7}, + {"wk_rwi_warmup_period", (DL_FUNC)&wk_rwi_warmup_period, 1}, + {"wk_rwi_is_ready", (DL_FUNC)&wk_rwi_is_ready, 1}, {"wk_rwi_reset", (DL_FUNC)&wk_rwi_reset, 1}, {"wk_sample_entropy_new", (DL_FUNC)&wk_sample_entropy_new, 3}, {"wk_sample_entropy_update", (DL_FUNC)&wk_sample_entropy_update, 2}, {"wk_sample_entropy_batch", (DL_FUNC)&wk_sample_entropy_batch, 2}, + {"wk_sample_entropy_warmup_period", (DL_FUNC)&wk_sample_entropy_warmup_period, 1}, + {"wk_sample_entropy_is_ready", (DL_FUNC)&wk_sample_entropy_is_ready, 1}, {"wk_sample_entropy_reset", (DL_FUNC)&wk_sample_entropy_reset, 1}, {"wk_sar_ext_new", (DL_FUNC)&wk_sar_ext_new, 8}, {"wk_sar_ext_update", (DL_FUNC)&wk_sar_ext_update, 7}, {"wk_sar_ext_batch", (DL_FUNC)&wk_sar_ext_batch, 7}, + {"wk_sar_ext_warmup_period", (DL_FUNC)&wk_sar_ext_warmup_period, 1}, + {"wk_sar_ext_is_ready", (DL_FUNC)&wk_sar_ext_is_ready, 1}, {"wk_sar_ext_reset", (DL_FUNC)&wk_sar_ext_reset, 1}, {"wk_seasonal_z_score_new", (DL_FUNC)&wk_seasonal_z_score_new, 1}, {"wk_seasonal_z_score_update", (DL_FUNC)&wk_seasonal_z_score_update, 7}, {"wk_seasonal_z_score_batch", (DL_FUNC)&wk_seasonal_z_score_batch, 7}, + {"wk_seasonal_z_score_warmup_period", (DL_FUNC)&wk_seasonal_z_score_warmup_period, 1}, + {"wk_seasonal_z_score_is_ready", (DL_FUNC)&wk_seasonal_z_score_is_ready, 1}, {"wk_seasonal_z_score_reset", (DL_FUNC)&wk_seasonal_z_score_reset, 1}, {"wk_separating_lines_new", (DL_FUNC)&wk_separating_lines_new, 0}, {"wk_separating_lines_update", (DL_FUNC)&wk_separating_lines_update, 7}, {"wk_separating_lines_batch", (DL_FUNC)&wk_separating_lines_batch, 7}, + {"wk_separating_lines_warmup_period", (DL_FUNC)&wk_separating_lines_warmup_period, 1}, + {"wk_separating_lines_is_ready", (DL_FUNC)&wk_separating_lines_is_ready, 1}, {"wk_separating_lines_reset", (DL_FUNC)&wk_separating_lines_reset, 1}, {"wk_session_high_low_new", (DL_FUNC)&wk_session_high_low_new, 1}, {"wk_session_high_low_update", (DL_FUNC)&wk_session_high_low_update, 7}, + {"wk_session_high_low_warmup_period", (DL_FUNC)&wk_session_high_low_warmup_period, 1}, + {"wk_session_high_low_is_ready", (DL_FUNC)&wk_session_high_low_is_ready, 1}, {"wk_session_high_low_reset", (DL_FUNC)&wk_session_high_low_reset, 1}, {"wk_session_range_new", (DL_FUNC)&wk_session_range_new, 1}, {"wk_session_range_update", (DL_FUNC)&wk_session_range_update, 7}, + {"wk_session_range_warmup_period", (DL_FUNC)&wk_session_range_warmup_period, 1}, + {"wk_session_range_is_ready", (DL_FUNC)&wk_session_range_is_ready, 1}, {"wk_session_range_reset", (DL_FUNC)&wk_session_range_reset, 1}, {"wk_session_vwap_new", (DL_FUNC)&wk_session_vwap_new, 1}, {"wk_session_vwap_update", (DL_FUNC)&wk_session_vwap_update, 7}, {"wk_session_vwap_batch", (DL_FUNC)&wk_session_vwap_batch, 7}, + {"wk_session_vwap_warmup_period", (DL_FUNC)&wk_session_vwap_warmup_period, 1}, + {"wk_session_vwap_is_ready", (DL_FUNC)&wk_session_vwap_is_ready, 1}, {"wk_session_vwap_reset", (DL_FUNC)&wk_session_vwap_reset, 1}, {"wk_shannon_entropy_new", (DL_FUNC)&wk_shannon_entropy_new, 2}, {"wk_shannon_entropy_update", (DL_FUNC)&wk_shannon_entropy_update, 2}, {"wk_shannon_entropy_batch", (DL_FUNC)&wk_shannon_entropy_batch, 2}, + {"wk_shannon_entropy_warmup_period", (DL_FUNC)&wk_shannon_entropy_warmup_period, 1}, + {"wk_shannon_entropy_is_ready", (DL_FUNC)&wk_shannon_entropy_is_ready, 1}, {"wk_shannon_entropy_reset", (DL_FUNC)&wk_shannon_entropy_reset, 1}, {"wk_shark_new", (DL_FUNC)&wk_shark_new, 0}, {"wk_shark_update", (DL_FUNC)&wk_shark_update, 7}, {"wk_shark_batch", (DL_FUNC)&wk_shark_batch, 7}, + {"wk_shark_warmup_period", (DL_FUNC)&wk_shark_warmup_period, 1}, + {"wk_shark_is_ready", (DL_FUNC)&wk_shark_is_ready, 1}, {"wk_shark_reset", (DL_FUNC)&wk_shark_reset, 1}, {"wk_sharpe_ratio_new", (DL_FUNC)&wk_sharpe_ratio_new, 2}, {"wk_sharpe_ratio_update", (DL_FUNC)&wk_sharpe_ratio_update, 2}, {"wk_sharpe_ratio_batch", (DL_FUNC)&wk_sharpe_ratio_batch, 2}, + {"wk_sharpe_ratio_warmup_period", (DL_FUNC)&wk_sharpe_ratio_warmup_period, 1}, + {"wk_sharpe_ratio_is_ready", (DL_FUNC)&wk_sharpe_ratio_is_ready, 1}, {"wk_sharpe_ratio_reset", (DL_FUNC)&wk_sharpe_ratio_reset, 1}, {"wk_shooting_star_new", (DL_FUNC)&wk_shooting_star_new, 0}, {"wk_shooting_star_update", (DL_FUNC)&wk_shooting_star_update, 7}, {"wk_shooting_star_batch", (DL_FUNC)&wk_shooting_star_batch, 7}, + {"wk_shooting_star_warmup_period", (DL_FUNC)&wk_shooting_star_warmup_period, 1}, + {"wk_shooting_star_is_ready", (DL_FUNC)&wk_shooting_star_is_ready, 1}, {"wk_shooting_star_reset", (DL_FUNC)&wk_shooting_star_reset, 1}, {"wk_short_line_new", (DL_FUNC)&wk_short_line_new, 0}, {"wk_short_line_update", (DL_FUNC)&wk_short_line_update, 7}, {"wk_short_line_batch", (DL_FUNC)&wk_short_line_batch, 7}, + {"wk_short_line_warmup_period", (DL_FUNC)&wk_short_line_warmup_period, 1}, + {"wk_short_line_is_ready", (DL_FUNC)&wk_short_line_is_ready, 1}, {"wk_short_line_reset", (DL_FUNC)&wk_short_line_reset, 1}, {"wk_signed_volume_new", (DL_FUNC)&wk_signed_volume_new, 0}, {"wk_signed_volume_update", (DL_FUNC)&wk_signed_volume_update, 5}, + {"wk_signed_volume_warmup_period", (DL_FUNC)&wk_signed_volume_warmup_period, 1}, + {"wk_signed_volume_is_ready", (DL_FUNC)&wk_signed_volume_is_ready, 1}, {"wk_signed_volume_reset", (DL_FUNC)&wk_signed_volume_reset, 1}, {"wk_sine_wave_new", (DL_FUNC)&wk_sine_wave_new, 0}, {"wk_sine_wave_update", (DL_FUNC)&wk_sine_wave_update, 2}, {"wk_sine_wave_batch", (DL_FUNC)&wk_sine_wave_batch, 2}, + {"wk_sine_wave_warmup_period", (DL_FUNC)&wk_sine_wave_warmup_period, 1}, + {"wk_sine_wave_is_ready", (DL_FUNC)&wk_sine_wave_is_ready, 1}, {"wk_sine_wave_reset", (DL_FUNC)&wk_sine_wave_reset, 1}, {"wk_sine_weighted_ma_new", (DL_FUNC)&wk_sine_weighted_ma_new, 1}, {"wk_sine_weighted_ma_update", (DL_FUNC)&wk_sine_weighted_ma_update, 2}, {"wk_sine_weighted_ma_batch", (DL_FUNC)&wk_sine_weighted_ma_batch, 2}, + {"wk_sine_weighted_ma_warmup_period", (DL_FUNC)&wk_sine_weighted_ma_warmup_period, 1}, + {"wk_sine_weighted_ma_is_ready", (DL_FUNC)&wk_sine_weighted_ma_is_ready, 1}, {"wk_sine_weighted_ma_reset", (DL_FUNC)&wk_sine_weighted_ma_reset, 1}, {"wk_single_prints_new", (DL_FUNC)&wk_single_prints_new, 2}, {"wk_single_prints_update", (DL_FUNC)&wk_single_prints_update, 7}, {"wk_single_prints_batch", (DL_FUNC)&wk_single_prints_batch, 7}, + {"wk_single_prints_warmup_period", (DL_FUNC)&wk_single_prints_warmup_period, 1}, + {"wk_single_prints_is_ready", (DL_FUNC)&wk_single_prints_is_ready, 1}, {"wk_single_prints_reset", (DL_FUNC)&wk_single_prints_reset, 1}, {"wk_skewness_new", (DL_FUNC)&wk_skewness_new, 1}, {"wk_skewness_update", (DL_FUNC)&wk_skewness_update, 2}, {"wk_skewness_batch", (DL_FUNC)&wk_skewness_batch, 2}, + {"wk_skewness_warmup_period", (DL_FUNC)&wk_skewness_warmup_period, 1}, + {"wk_skewness_is_ready", (DL_FUNC)&wk_skewness_is_ready, 1}, {"wk_skewness_reset", (DL_FUNC)&wk_skewness_reset, 1}, {"wk_sma_new", (DL_FUNC)&wk_sma_new, 1}, {"wk_sma_update", (DL_FUNC)&wk_sma_update, 2}, {"wk_sma_batch", (DL_FUNC)&wk_sma_batch, 2}, + {"wk_sma_warmup_period", (DL_FUNC)&wk_sma_warmup_period, 1}, + {"wk_sma_is_ready", (DL_FUNC)&wk_sma_is_ready, 1}, {"wk_sma_reset", (DL_FUNC)&wk_sma_reset, 1}, {"wk_smi_new", (DL_FUNC)&wk_smi_new, 3}, {"wk_smi_update", (DL_FUNC)&wk_smi_update, 7}, {"wk_smi_batch", (DL_FUNC)&wk_smi_batch, 7}, + {"wk_smi_warmup_period", (DL_FUNC)&wk_smi_warmup_period, 1}, + {"wk_smi_is_ready", (DL_FUNC)&wk_smi_is_ready, 1}, {"wk_smi_reset", (DL_FUNC)&wk_smi_reset, 1}, {"wk_smma_new", (DL_FUNC)&wk_smma_new, 1}, {"wk_smma_update", (DL_FUNC)&wk_smma_update, 2}, {"wk_smma_batch", (DL_FUNC)&wk_smma_batch, 2}, + {"wk_smma_warmup_period", (DL_FUNC)&wk_smma_warmup_period, 1}, + {"wk_smma_is_ready", (DL_FUNC)&wk_smma_is_ready, 1}, {"wk_smma_reset", (DL_FUNC)&wk_smma_reset, 1}, {"wk_smoothed_heikin_ashi_new", (DL_FUNC)&wk_smoothed_heikin_ashi_new, 1}, {"wk_smoothed_heikin_ashi_update", (DL_FUNC)&wk_smoothed_heikin_ashi_update, 7}, + {"wk_smoothed_heikin_ashi_warmup_period", (DL_FUNC)&wk_smoothed_heikin_ashi_warmup_period, 1}, + {"wk_smoothed_heikin_ashi_is_ready", (DL_FUNC)&wk_smoothed_heikin_ashi_is_ready, 1}, {"wk_smoothed_heikin_ashi_reset", (DL_FUNC)&wk_smoothed_heikin_ashi_reset, 1}, {"wk_sortino_ratio_new", (DL_FUNC)&wk_sortino_ratio_new, 2}, {"wk_sortino_ratio_update", (DL_FUNC)&wk_sortino_ratio_update, 2}, {"wk_sortino_ratio_batch", (DL_FUNC)&wk_sortino_ratio_batch, 2}, + {"wk_sortino_ratio_warmup_period", (DL_FUNC)&wk_sortino_ratio_warmup_period, 1}, + {"wk_sortino_ratio_is_ready", (DL_FUNC)&wk_sortino_ratio_is_ready, 1}, {"wk_sortino_ratio_reset", (DL_FUNC)&wk_sortino_ratio_reset, 1}, {"wk_spearman_correlation_new", (DL_FUNC)&wk_spearman_correlation_new, 1}, {"wk_spearman_correlation_update", (DL_FUNC)&wk_spearman_correlation_update, 3}, {"wk_spearman_correlation_batch", (DL_FUNC)&wk_spearman_correlation_batch, 3}, + {"wk_spearman_correlation_warmup_period", (DL_FUNC)&wk_spearman_correlation_warmup_period, 1}, + {"wk_spearman_correlation_is_ready", (DL_FUNC)&wk_spearman_correlation_is_ready, 1}, {"wk_spearman_correlation_reset", (DL_FUNC)&wk_spearman_correlation_reset, 1}, {"wk_spinning_top_new", (DL_FUNC)&wk_spinning_top_new, 0}, {"wk_spinning_top_update", (DL_FUNC)&wk_spinning_top_update, 7}, {"wk_spinning_top_batch", (DL_FUNC)&wk_spinning_top_batch, 7}, + {"wk_spinning_top_warmup_period", (DL_FUNC)&wk_spinning_top_warmup_period, 1}, + {"wk_spinning_top_is_ready", (DL_FUNC)&wk_spinning_top_is_ready, 1}, {"wk_spinning_top_reset", (DL_FUNC)&wk_spinning_top_reset, 1}, {"wk_spread_ar1_coefficient_new", (DL_FUNC)&wk_spread_ar1_coefficient_new, 1}, {"wk_spread_ar1_coefficient_update", (DL_FUNC)&wk_spread_ar1_coefficient_update, 3}, {"wk_spread_ar1_coefficient_batch", (DL_FUNC)&wk_spread_ar1_coefficient_batch, 3}, + {"wk_spread_ar1_coefficient_warmup_period", (DL_FUNC)&wk_spread_ar1_coefficient_warmup_period, 1}, + {"wk_spread_ar1_coefficient_is_ready", (DL_FUNC)&wk_spread_ar1_coefficient_is_ready, 1}, {"wk_spread_ar1_coefficient_reset", (DL_FUNC)&wk_spread_ar1_coefficient_reset, 1}, {"wk_spread_bollinger_bands_new", (DL_FUNC)&wk_spread_bollinger_bands_new, 2}, {"wk_spread_bollinger_bands_update", (DL_FUNC)&wk_spread_bollinger_bands_update, 3}, + {"wk_spread_bollinger_bands_warmup_period", (DL_FUNC)&wk_spread_bollinger_bands_warmup_period, 1}, + {"wk_spread_bollinger_bands_is_ready", (DL_FUNC)&wk_spread_bollinger_bands_is_ready, 1}, {"wk_spread_bollinger_bands_reset", (DL_FUNC)&wk_spread_bollinger_bands_reset, 1}, {"wk_spread_hurst_new", (DL_FUNC)&wk_spread_hurst_new, 1}, {"wk_spread_hurst_update", (DL_FUNC)&wk_spread_hurst_update, 3}, {"wk_spread_hurst_batch", (DL_FUNC)&wk_spread_hurst_batch, 3}, + {"wk_spread_hurst_warmup_period", (DL_FUNC)&wk_spread_hurst_warmup_period, 1}, + {"wk_spread_hurst_is_ready", (DL_FUNC)&wk_spread_hurst_is_ready, 1}, {"wk_spread_hurst_reset", (DL_FUNC)&wk_spread_hurst_reset, 1}, {"wk_stalled_pattern_new", (DL_FUNC)&wk_stalled_pattern_new, 0}, {"wk_stalled_pattern_update", (DL_FUNC)&wk_stalled_pattern_update, 7}, {"wk_stalled_pattern_batch", (DL_FUNC)&wk_stalled_pattern_batch, 7}, + {"wk_stalled_pattern_warmup_period", (DL_FUNC)&wk_stalled_pattern_warmup_period, 1}, + {"wk_stalled_pattern_is_ready", (DL_FUNC)&wk_stalled_pattern_is_ready, 1}, {"wk_stalled_pattern_reset", (DL_FUNC)&wk_stalled_pattern_reset, 1}, {"wk_standard_error_new", (DL_FUNC)&wk_standard_error_new, 1}, {"wk_standard_error_update", (DL_FUNC)&wk_standard_error_update, 2}, {"wk_standard_error_batch", (DL_FUNC)&wk_standard_error_batch, 2}, + {"wk_standard_error_warmup_period", (DL_FUNC)&wk_standard_error_warmup_period, 1}, + {"wk_standard_error_is_ready", (DL_FUNC)&wk_standard_error_is_ready, 1}, {"wk_standard_error_reset", (DL_FUNC)&wk_standard_error_reset, 1}, {"wk_standard_error_bands_new", (DL_FUNC)&wk_standard_error_bands_new, 2}, {"wk_standard_error_bands_update", (DL_FUNC)&wk_standard_error_bands_update, 2}, + {"wk_standard_error_bands_warmup_period", (DL_FUNC)&wk_standard_error_bands_warmup_period, 1}, + {"wk_standard_error_bands_is_ready", (DL_FUNC)&wk_standard_error_bands_is_ready, 1}, {"wk_standard_error_bands_reset", (DL_FUNC)&wk_standard_error_bands_reset, 1}, {"wk_starc_bands_new", (DL_FUNC)&wk_starc_bands_new, 3}, {"wk_starc_bands_update", (DL_FUNC)&wk_starc_bands_update, 7}, + {"wk_starc_bands_warmup_period", (DL_FUNC)&wk_starc_bands_warmup_period, 1}, + {"wk_starc_bands_is_ready", (DL_FUNC)&wk_starc_bands_is_ready, 1}, {"wk_starc_bands_reset", (DL_FUNC)&wk_starc_bands_reset, 1}, {"wk_stc_new", (DL_FUNC)&wk_stc_new, 4}, {"wk_stc_update", (DL_FUNC)&wk_stc_update, 2}, {"wk_stc_batch", (DL_FUNC)&wk_stc_batch, 2}, + {"wk_stc_warmup_period", (DL_FUNC)&wk_stc_warmup_period, 1}, + {"wk_stc_is_ready", (DL_FUNC)&wk_stc_is_ready, 1}, {"wk_stc_reset", (DL_FUNC)&wk_stc_reset, 1}, {"wk_std_dev_new", (DL_FUNC)&wk_std_dev_new, 1}, {"wk_std_dev_update", (DL_FUNC)&wk_std_dev_update, 2}, {"wk_std_dev_batch", (DL_FUNC)&wk_std_dev_batch, 2}, + {"wk_std_dev_warmup_period", (DL_FUNC)&wk_std_dev_warmup_period, 1}, + {"wk_std_dev_is_ready", (DL_FUNC)&wk_std_dev_is_ready, 1}, {"wk_std_dev_reset", (DL_FUNC)&wk_std_dev_reset, 1}, {"wk_step_trailing_stop_new", (DL_FUNC)&wk_step_trailing_stop_new, 1}, {"wk_step_trailing_stop_update", (DL_FUNC)&wk_step_trailing_stop_update, 2}, {"wk_step_trailing_stop_batch", (DL_FUNC)&wk_step_trailing_stop_batch, 2}, + {"wk_step_trailing_stop_warmup_period", (DL_FUNC)&wk_step_trailing_stop_warmup_period, 1}, + {"wk_step_trailing_stop_is_ready", (DL_FUNC)&wk_step_trailing_stop_is_ready, 1}, {"wk_step_trailing_stop_reset", (DL_FUNC)&wk_step_trailing_stop_reset, 1}, {"wk_sterling_ratio_new", (DL_FUNC)&wk_sterling_ratio_new, 1}, {"wk_sterling_ratio_update", (DL_FUNC)&wk_sterling_ratio_update, 2}, {"wk_sterling_ratio_batch", (DL_FUNC)&wk_sterling_ratio_batch, 2}, + {"wk_sterling_ratio_warmup_period", (DL_FUNC)&wk_sterling_ratio_warmup_period, 1}, + {"wk_sterling_ratio_is_ready", (DL_FUNC)&wk_sterling_ratio_is_ready, 1}, {"wk_sterling_ratio_reset", (DL_FUNC)&wk_sterling_ratio_reset, 1}, {"wk_stick_sandwich_new", (DL_FUNC)&wk_stick_sandwich_new, 0}, {"wk_stick_sandwich_update", (DL_FUNC)&wk_stick_sandwich_update, 7}, {"wk_stick_sandwich_batch", (DL_FUNC)&wk_stick_sandwich_batch, 7}, + {"wk_stick_sandwich_warmup_period", (DL_FUNC)&wk_stick_sandwich_warmup_period, 1}, + {"wk_stick_sandwich_is_ready", (DL_FUNC)&wk_stick_sandwich_is_ready, 1}, {"wk_stick_sandwich_reset", (DL_FUNC)&wk_stick_sandwich_reset, 1}, {"wk_stoch_rsi_new", (DL_FUNC)&wk_stoch_rsi_new, 2}, {"wk_stoch_rsi_update", (DL_FUNC)&wk_stoch_rsi_update, 2}, {"wk_stoch_rsi_batch", (DL_FUNC)&wk_stoch_rsi_batch, 2}, + {"wk_stoch_rsi_warmup_period", (DL_FUNC)&wk_stoch_rsi_warmup_period, 1}, + {"wk_stoch_rsi_is_ready", (DL_FUNC)&wk_stoch_rsi_is_ready, 1}, {"wk_stoch_rsi_reset", (DL_FUNC)&wk_stoch_rsi_reset, 1}, {"wk_stochastic_new", (DL_FUNC)&wk_stochastic_new, 2}, {"wk_stochastic_update", (DL_FUNC)&wk_stochastic_update, 7}, + {"wk_stochastic_warmup_period", (DL_FUNC)&wk_stochastic_warmup_period, 1}, + {"wk_stochastic_is_ready", (DL_FUNC)&wk_stochastic_is_ready, 1}, {"wk_stochastic_reset", (DL_FUNC)&wk_stochastic_reset, 1}, {"wk_stochastic_cci_new", (DL_FUNC)&wk_stochastic_cci_new, 1}, {"wk_stochastic_cci_update", (DL_FUNC)&wk_stochastic_cci_update, 7}, {"wk_stochastic_cci_batch", (DL_FUNC)&wk_stochastic_cci_batch, 7}, + {"wk_stochastic_cci_warmup_period", (DL_FUNC)&wk_stochastic_cci_warmup_period, 1}, + {"wk_stochastic_cci_is_ready", (DL_FUNC)&wk_stochastic_cci_is_ready, 1}, {"wk_stochastic_cci_reset", (DL_FUNC)&wk_stochastic_cci_reset, 1}, {"wk_super_smoother_new", (DL_FUNC)&wk_super_smoother_new, 1}, {"wk_super_smoother_update", (DL_FUNC)&wk_super_smoother_update, 2}, {"wk_super_smoother_batch", (DL_FUNC)&wk_super_smoother_batch, 2}, + {"wk_super_smoother_warmup_period", (DL_FUNC)&wk_super_smoother_warmup_period, 1}, + {"wk_super_smoother_is_ready", (DL_FUNC)&wk_super_smoother_is_ready, 1}, {"wk_super_smoother_reset", (DL_FUNC)&wk_super_smoother_reset, 1}, {"wk_super_trend_new", (DL_FUNC)&wk_super_trend_new, 2}, {"wk_super_trend_update", (DL_FUNC)&wk_super_trend_update, 7}, + {"wk_super_trend_warmup_period", (DL_FUNC)&wk_super_trend_warmup_period, 1}, + {"wk_super_trend_is_ready", (DL_FUNC)&wk_super_trend_is_ready, 1}, {"wk_super_trend_reset", (DL_FUNC)&wk_super_trend_reset, 1}, {"wk_t3_new", (DL_FUNC)&wk_t3_new, 2}, {"wk_t3_update", (DL_FUNC)&wk_t3_update, 2}, {"wk_t3_batch", (DL_FUNC)&wk_t3_batch, 2}, + {"wk_t3_warmup_period", (DL_FUNC)&wk_t3_warmup_period, 1}, + {"wk_t3_is_ready", (DL_FUNC)&wk_t3_is_ready, 1}, {"wk_t3_reset", (DL_FUNC)&wk_t3_reset, 1}, {"wk_tail_ratio_new", (DL_FUNC)&wk_tail_ratio_new, 1}, {"wk_tail_ratio_update", (DL_FUNC)&wk_tail_ratio_update, 2}, {"wk_tail_ratio_batch", (DL_FUNC)&wk_tail_ratio_batch, 2}, + {"wk_tail_ratio_warmup_period", (DL_FUNC)&wk_tail_ratio_warmup_period, 1}, + {"wk_tail_ratio_is_ready", (DL_FUNC)&wk_tail_ratio_is_ready, 1}, {"wk_tail_ratio_reset", (DL_FUNC)&wk_tail_ratio_reset, 1}, {"wk_taker_buy_sell_ratio_new", (DL_FUNC)&wk_taker_buy_sell_ratio_new, 0}, {"wk_taker_buy_sell_ratio_update", (DL_FUNC)&wk_taker_buy_sell_ratio_update, 13}, + {"wk_taker_buy_sell_ratio_warmup_period", (DL_FUNC)&wk_taker_buy_sell_ratio_warmup_period, 1}, + {"wk_taker_buy_sell_ratio_is_ready", (DL_FUNC)&wk_taker_buy_sell_ratio_is_ready, 1}, {"wk_taker_buy_sell_ratio_reset", (DL_FUNC)&wk_taker_buy_sell_ratio_reset, 1}, {"wk_takuri_new", (DL_FUNC)&wk_takuri_new, 0}, {"wk_takuri_update", (DL_FUNC)&wk_takuri_update, 7}, {"wk_takuri_batch", (DL_FUNC)&wk_takuri_batch, 7}, + {"wk_takuri_warmup_period", (DL_FUNC)&wk_takuri_warmup_period, 1}, + {"wk_takuri_is_ready", (DL_FUNC)&wk_takuri_is_ready, 1}, {"wk_takuri_reset", (DL_FUNC)&wk_takuri_reset, 1}, {"wk_tasuki_gap_new", (DL_FUNC)&wk_tasuki_gap_new, 0}, {"wk_tasuki_gap_update", (DL_FUNC)&wk_tasuki_gap_update, 7}, {"wk_tasuki_gap_batch", (DL_FUNC)&wk_tasuki_gap_batch, 7}, + {"wk_tasuki_gap_warmup_period", (DL_FUNC)&wk_tasuki_gap_warmup_period, 1}, + {"wk_tasuki_gap_is_ready", (DL_FUNC)&wk_tasuki_gap_is_ready, 1}, {"wk_tasuki_gap_reset", (DL_FUNC)&wk_tasuki_gap_reset, 1}, {"wk_td_camouflage_new", (DL_FUNC)&wk_td_camouflage_new, 0}, {"wk_td_camouflage_update", (DL_FUNC)&wk_td_camouflage_update, 7}, {"wk_td_camouflage_batch", (DL_FUNC)&wk_td_camouflage_batch, 7}, + {"wk_td_camouflage_warmup_period", (DL_FUNC)&wk_td_camouflage_warmup_period, 1}, + {"wk_td_camouflage_is_ready", (DL_FUNC)&wk_td_camouflage_is_ready, 1}, {"wk_td_camouflage_reset", (DL_FUNC)&wk_td_camouflage_reset, 1}, {"wk_td_clop_new", (DL_FUNC)&wk_td_clop_new, 0}, {"wk_td_clop_update", (DL_FUNC)&wk_td_clop_update, 7}, {"wk_td_clop_batch", (DL_FUNC)&wk_td_clop_batch, 7}, + {"wk_td_clop_warmup_period", (DL_FUNC)&wk_td_clop_warmup_period, 1}, + {"wk_td_clop_is_ready", (DL_FUNC)&wk_td_clop_is_ready, 1}, {"wk_td_clop_reset", (DL_FUNC)&wk_td_clop_reset, 1}, {"wk_td_clopwin_new", (DL_FUNC)&wk_td_clopwin_new, 0}, {"wk_td_clopwin_update", (DL_FUNC)&wk_td_clopwin_update, 7}, {"wk_td_clopwin_batch", (DL_FUNC)&wk_td_clopwin_batch, 7}, + {"wk_td_clopwin_warmup_period", (DL_FUNC)&wk_td_clopwin_warmup_period, 1}, + {"wk_td_clopwin_is_ready", (DL_FUNC)&wk_td_clopwin_is_ready, 1}, {"wk_td_clopwin_reset", (DL_FUNC)&wk_td_clopwin_reset, 1}, {"wk_td_combo_new", (DL_FUNC)&wk_td_combo_new, 4}, {"wk_td_combo_update", (DL_FUNC)&wk_td_combo_update, 7}, {"wk_td_combo_batch", (DL_FUNC)&wk_td_combo_batch, 7}, + {"wk_td_combo_warmup_period", (DL_FUNC)&wk_td_combo_warmup_period, 1}, + {"wk_td_combo_is_ready", (DL_FUNC)&wk_td_combo_is_ready, 1}, {"wk_td_combo_reset", (DL_FUNC)&wk_td_combo_reset, 1}, {"wk_td_countdown_new", (DL_FUNC)&wk_td_countdown_new, 4}, {"wk_td_countdown_update", (DL_FUNC)&wk_td_countdown_update, 7}, {"wk_td_countdown_batch", (DL_FUNC)&wk_td_countdown_batch, 7}, + {"wk_td_countdown_warmup_period", (DL_FUNC)&wk_td_countdown_warmup_period, 1}, + {"wk_td_countdown_is_ready", (DL_FUNC)&wk_td_countdown_is_ready, 1}, {"wk_td_countdown_reset", (DL_FUNC)&wk_td_countdown_reset, 1}, {"wk_td_d_wave_new", (DL_FUNC)&wk_td_d_wave_new, 1}, {"wk_td_d_wave_update", (DL_FUNC)&wk_td_d_wave_update, 7}, {"wk_td_d_wave_batch", (DL_FUNC)&wk_td_d_wave_batch, 7}, + {"wk_td_d_wave_warmup_period", (DL_FUNC)&wk_td_d_wave_warmup_period, 1}, + {"wk_td_d_wave_is_ready", (DL_FUNC)&wk_td_d_wave_is_ready, 1}, {"wk_td_d_wave_reset", (DL_FUNC)&wk_td_d_wave_reset, 1}, {"wk_td_de_marker_new", (DL_FUNC)&wk_td_de_marker_new, 1}, {"wk_td_de_marker_update", (DL_FUNC)&wk_td_de_marker_update, 7}, {"wk_td_de_marker_batch", (DL_FUNC)&wk_td_de_marker_batch, 7}, + {"wk_td_de_marker_warmup_period", (DL_FUNC)&wk_td_de_marker_warmup_period, 1}, + {"wk_td_de_marker_is_ready", (DL_FUNC)&wk_td_de_marker_is_ready, 1}, {"wk_td_de_marker_reset", (DL_FUNC)&wk_td_de_marker_reset, 1}, {"wk_td_differential_new", (DL_FUNC)&wk_td_differential_new, 0}, {"wk_td_differential_update", (DL_FUNC)&wk_td_differential_update, 7}, {"wk_td_differential_batch", (DL_FUNC)&wk_td_differential_batch, 7}, + {"wk_td_differential_warmup_period", (DL_FUNC)&wk_td_differential_warmup_period, 1}, + {"wk_td_differential_is_ready", (DL_FUNC)&wk_td_differential_is_ready, 1}, {"wk_td_differential_reset", (DL_FUNC)&wk_td_differential_reset, 1}, {"wk_td_lines_new", (DL_FUNC)&wk_td_lines_new, 2}, {"wk_td_lines_update", (DL_FUNC)&wk_td_lines_update, 7}, + {"wk_td_lines_warmup_period", (DL_FUNC)&wk_td_lines_warmup_period, 1}, + {"wk_td_lines_is_ready", (DL_FUNC)&wk_td_lines_is_ready, 1}, {"wk_td_lines_reset", (DL_FUNC)&wk_td_lines_reset, 1}, {"wk_td_moving_average_new", (DL_FUNC)&wk_td_moving_average_new, 2}, {"wk_td_moving_average_update", (DL_FUNC)&wk_td_moving_average_update, 7}, + {"wk_td_moving_average_warmup_period", (DL_FUNC)&wk_td_moving_average_warmup_period, 1}, + {"wk_td_moving_average_is_ready", (DL_FUNC)&wk_td_moving_average_is_ready, 1}, {"wk_td_moving_average_reset", (DL_FUNC)&wk_td_moving_average_reset, 1}, {"wk_td_open_new", (DL_FUNC)&wk_td_open_new, 0}, {"wk_td_open_update", (DL_FUNC)&wk_td_open_update, 7}, {"wk_td_open_batch", (DL_FUNC)&wk_td_open_batch, 7}, + {"wk_td_open_warmup_period", (DL_FUNC)&wk_td_open_warmup_period, 1}, + {"wk_td_open_is_ready", (DL_FUNC)&wk_td_open_is_ready, 1}, {"wk_td_open_reset", (DL_FUNC)&wk_td_open_reset, 1}, {"wk_td_pressure_new", (DL_FUNC)&wk_td_pressure_new, 1}, {"wk_td_pressure_update", (DL_FUNC)&wk_td_pressure_update, 7}, {"wk_td_pressure_batch", (DL_FUNC)&wk_td_pressure_batch, 7}, + {"wk_td_pressure_warmup_period", (DL_FUNC)&wk_td_pressure_warmup_period, 1}, + {"wk_td_pressure_is_ready", (DL_FUNC)&wk_td_pressure_is_ready, 1}, {"wk_td_pressure_reset", (DL_FUNC)&wk_td_pressure_reset, 1}, {"wk_td_propulsion_new", (DL_FUNC)&wk_td_propulsion_new, 0}, {"wk_td_propulsion_update", (DL_FUNC)&wk_td_propulsion_update, 7}, {"wk_td_propulsion_batch", (DL_FUNC)&wk_td_propulsion_batch, 7}, + {"wk_td_propulsion_warmup_period", (DL_FUNC)&wk_td_propulsion_warmup_period, 1}, + {"wk_td_propulsion_is_ready", (DL_FUNC)&wk_td_propulsion_is_ready, 1}, {"wk_td_propulsion_reset", (DL_FUNC)&wk_td_propulsion_reset, 1}, {"wk_td_range_projection_new", (DL_FUNC)&wk_td_range_projection_new, 0}, {"wk_td_range_projection_update", (DL_FUNC)&wk_td_range_projection_update, 7}, + {"wk_td_range_projection_warmup_period", (DL_FUNC)&wk_td_range_projection_warmup_period, 1}, + {"wk_td_range_projection_is_ready", (DL_FUNC)&wk_td_range_projection_is_ready, 1}, {"wk_td_range_projection_reset", (DL_FUNC)&wk_td_range_projection_reset, 1}, {"wk_td_rei_new", (DL_FUNC)&wk_td_rei_new, 1}, {"wk_td_rei_update", (DL_FUNC)&wk_td_rei_update, 7}, {"wk_td_rei_batch", (DL_FUNC)&wk_td_rei_batch, 7}, + {"wk_td_rei_warmup_period", (DL_FUNC)&wk_td_rei_warmup_period, 1}, + {"wk_td_rei_is_ready", (DL_FUNC)&wk_td_rei_is_ready, 1}, {"wk_td_rei_reset", (DL_FUNC)&wk_td_rei_reset, 1}, {"wk_td_risk_level_new", (DL_FUNC)&wk_td_risk_level_new, 2}, {"wk_td_risk_level_update", (DL_FUNC)&wk_td_risk_level_update, 7}, + {"wk_td_risk_level_warmup_period", (DL_FUNC)&wk_td_risk_level_warmup_period, 1}, + {"wk_td_risk_level_is_ready", (DL_FUNC)&wk_td_risk_level_is_ready, 1}, {"wk_td_risk_level_reset", (DL_FUNC)&wk_td_risk_level_reset, 1}, {"wk_td_sequential_new", (DL_FUNC)&wk_td_sequential_new, 4}, {"wk_td_sequential_update", (DL_FUNC)&wk_td_sequential_update, 7}, + {"wk_td_sequential_warmup_period", (DL_FUNC)&wk_td_sequential_warmup_period, 1}, + {"wk_td_sequential_is_ready", (DL_FUNC)&wk_td_sequential_is_ready, 1}, {"wk_td_sequential_reset", (DL_FUNC)&wk_td_sequential_reset, 1}, {"wk_td_setup_new", (DL_FUNC)&wk_td_setup_new, 2}, {"wk_td_setup_update", (DL_FUNC)&wk_td_setup_update, 7}, {"wk_td_setup_batch", (DL_FUNC)&wk_td_setup_batch, 7}, + {"wk_td_setup_warmup_period", (DL_FUNC)&wk_td_setup_warmup_period, 1}, + {"wk_td_setup_is_ready", (DL_FUNC)&wk_td_setup_is_ready, 1}, {"wk_td_setup_reset", (DL_FUNC)&wk_td_setup_reset, 1}, {"wk_td_trap_new", (DL_FUNC)&wk_td_trap_new, 0}, {"wk_td_trap_update", (DL_FUNC)&wk_td_trap_update, 7}, {"wk_td_trap_batch", (DL_FUNC)&wk_td_trap_batch, 7}, + {"wk_td_trap_warmup_period", (DL_FUNC)&wk_td_trap_warmup_period, 1}, + {"wk_td_trap_is_ready", (DL_FUNC)&wk_td_trap_is_ready, 1}, {"wk_td_trap_reset", (DL_FUNC)&wk_td_trap_reset, 1}, {"wk_tema_new", (DL_FUNC)&wk_tema_new, 1}, {"wk_tema_update", (DL_FUNC)&wk_tema_update, 2}, {"wk_tema_batch", (DL_FUNC)&wk_tema_batch, 2}, + {"wk_tema_warmup_period", (DL_FUNC)&wk_tema_warmup_period, 1}, + {"wk_tema_is_ready", (DL_FUNC)&wk_tema_is_ready, 1}, {"wk_tema_reset", (DL_FUNC)&wk_tema_reset, 1}, {"wk_term_structure_basis_new", (DL_FUNC)&wk_term_structure_basis_new, 0}, {"wk_term_structure_basis_update", (DL_FUNC)&wk_term_structure_basis_update, 13}, + {"wk_term_structure_basis_warmup_period", (DL_FUNC)&wk_term_structure_basis_warmup_period, 1}, + {"wk_term_structure_basis_is_ready", (DL_FUNC)&wk_term_structure_basis_is_ready, 1}, {"wk_term_structure_basis_reset", (DL_FUNC)&wk_term_structure_basis_reset, 1}, {"wk_three_drives_new", (DL_FUNC)&wk_three_drives_new, 0}, {"wk_three_drives_update", (DL_FUNC)&wk_three_drives_update, 7}, {"wk_three_drives_batch", (DL_FUNC)&wk_three_drives_batch, 7}, + {"wk_three_drives_warmup_period", (DL_FUNC)&wk_three_drives_warmup_period, 1}, + {"wk_three_drives_is_ready", (DL_FUNC)&wk_three_drives_is_ready, 1}, {"wk_three_drives_reset", (DL_FUNC)&wk_three_drives_reset, 1}, {"wk_three_inside_new", (DL_FUNC)&wk_three_inside_new, 0}, {"wk_three_inside_update", (DL_FUNC)&wk_three_inside_update, 7}, {"wk_three_inside_batch", (DL_FUNC)&wk_three_inside_batch, 7}, + {"wk_three_inside_warmup_period", (DL_FUNC)&wk_three_inside_warmup_period, 1}, + {"wk_three_inside_is_ready", (DL_FUNC)&wk_three_inside_is_ready, 1}, {"wk_three_inside_reset", (DL_FUNC)&wk_three_inside_reset, 1}, {"wk_three_line_break_new", (DL_FUNC)&wk_three_line_break_new, 1}, {"wk_three_line_break_update", (DL_FUNC)&wk_three_line_break_update, 7}, {"wk_three_line_break_batch", (DL_FUNC)&wk_three_line_break_batch, 7}, + {"wk_three_line_break_warmup_period", (DL_FUNC)&wk_three_line_break_warmup_period, 1}, + {"wk_three_line_break_is_ready", (DL_FUNC)&wk_three_line_break_is_ready, 1}, {"wk_three_line_break_reset", (DL_FUNC)&wk_three_line_break_reset, 1}, {"wk_three_line_break_bars_new", (DL_FUNC)&wk_three_line_break_bars_new, 1}, {"wk_three_line_break_bars_update", (DL_FUNC)&wk_three_line_break_bars_update, 7}, @@ -18015,322 +22887,490 @@ static const R_CallMethodDef CallEntries[] = { {"wk_three_line_strike_new", (DL_FUNC)&wk_three_line_strike_new, 0}, {"wk_three_line_strike_update", (DL_FUNC)&wk_three_line_strike_update, 7}, {"wk_three_line_strike_batch", (DL_FUNC)&wk_three_line_strike_batch, 7}, + {"wk_three_line_strike_warmup_period", (DL_FUNC)&wk_three_line_strike_warmup_period, 1}, + {"wk_three_line_strike_is_ready", (DL_FUNC)&wk_three_line_strike_is_ready, 1}, {"wk_three_line_strike_reset", (DL_FUNC)&wk_three_line_strike_reset, 1}, {"wk_three_outside_new", (DL_FUNC)&wk_three_outside_new, 0}, {"wk_three_outside_update", (DL_FUNC)&wk_three_outside_update, 7}, {"wk_three_outside_batch", (DL_FUNC)&wk_three_outside_batch, 7}, + {"wk_three_outside_warmup_period", (DL_FUNC)&wk_three_outside_warmup_period, 1}, + {"wk_three_outside_is_ready", (DL_FUNC)&wk_three_outside_is_ready, 1}, {"wk_three_outside_reset", (DL_FUNC)&wk_three_outside_reset, 1}, {"wk_three_soldiers_or_crows_new", (DL_FUNC)&wk_three_soldiers_or_crows_new, 0}, {"wk_three_soldiers_or_crows_update", (DL_FUNC)&wk_three_soldiers_or_crows_update, 7}, {"wk_three_soldiers_or_crows_batch", (DL_FUNC)&wk_three_soldiers_or_crows_batch, 7}, + {"wk_three_soldiers_or_crows_warmup_period", (DL_FUNC)&wk_three_soldiers_or_crows_warmup_period, 1}, + {"wk_three_soldiers_or_crows_is_ready", (DL_FUNC)&wk_three_soldiers_or_crows_is_ready, 1}, {"wk_three_soldiers_or_crows_reset", (DL_FUNC)&wk_three_soldiers_or_crows_reset, 1}, {"wk_three_stars_in_south_new", (DL_FUNC)&wk_three_stars_in_south_new, 0}, {"wk_three_stars_in_south_update", (DL_FUNC)&wk_three_stars_in_south_update, 7}, {"wk_three_stars_in_south_batch", (DL_FUNC)&wk_three_stars_in_south_batch, 7}, + {"wk_three_stars_in_south_warmup_period", (DL_FUNC)&wk_three_stars_in_south_warmup_period, 1}, + {"wk_three_stars_in_south_is_ready", (DL_FUNC)&wk_three_stars_in_south_is_ready, 1}, {"wk_three_stars_in_south_reset", (DL_FUNC)&wk_three_stars_in_south_reset, 1}, {"wk_thrusting_new", (DL_FUNC)&wk_thrusting_new, 0}, {"wk_thrusting_update", (DL_FUNC)&wk_thrusting_update, 7}, {"wk_thrusting_batch", (DL_FUNC)&wk_thrusting_batch, 7}, + {"wk_thrusting_warmup_period", (DL_FUNC)&wk_thrusting_warmup_period, 1}, + {"wk_thrusting_is_ready", (DL_FUNC)&wk_thrusting_is_ready, 1}, {"wk_thrusting_reset", (DL_FUNC)&wk_thrusting_reset, 1}, {"wk_tick_bars_new", (DL_FUNC)&wk_tick_bars_new, 1}, {"wk_tick_bars_update", (DL_FUNC)&wk_tick_bars_update, 7}, {"wk_tick_bars_reset", (DL_FUNC)&wk_tick_bars_reset, 1}, {"wk_tick_index_new", (DL_FUNC)&wk_tick_index_new, 0}, {"wk_tick_index_update", (DL_FUNC)&wk_tick_index_update, 8}, + {"wk_tick_index_warmup_period", (DL_FUNC)&wk_tick_index_warmup_period, 1}, + {"wk_tick_index_is_ready", (DL_FUNC)&wk_tick_index_is_ready, 1}, {"wk_tick_index_reset", (DL_FUNC)&wk_tick_index_reset, 1}, {"wk_tii_new", (DL_FUNC)&wk_tii_new, 2}, {"wk_tii_update", (DL_FUNC)&wk_tii_update, 2}, {"wk_tii_batch", (DL_FUNC)&wk_tii_batch, 2}, + {"wk_tii_warmup_period", (DL_FUNC)&wk_tii_warmup_period, 1}, + {"wk_tii_is_ready", (DL_FUNC)&wk_tii_is_ready, 1}, {"wk_tii_reset", (DL_FUNC)&wk_tii_reset, 1}, {"wk_time_based_stop_new", (DL_FUNC)&wk_time_based_stop_new, 1}, {"wk_time_based_stop_update", (DL_FUNC)&wk_time_based_stop_update, 7}, {"wk_time_based_stop_batch", (DL_FUNC)&wk_time_based_stop_batch, 7}, + {"wk_time_based_stop_warmup_period", (DL_FUNC)&wk_time_based_stop_warmup_period, 1}, + {"wk_time_based_stop_is_ready", (DL_FUNC)&wk_time_based_stop_is_ready, 1}, {"wk_time_based_stop_reset", (DL_FUNC)&wk_time_based_stop_reset, 1}, {"wk_time_of_day_return_profile_new", (DL_FUNC)&wk_time_of_day_return_profile_new, 2}, {"wk_time_of_day_return_profile_update", (DL_FUNC)&wk_time_of_day_return_profile_update, 8}, + {"wk_time_of_day_return_profile_warmup_period", (DL_FUNC)&wk_time_of_day_return_profile_warmup_period, 1}, + {"wk_time_of_day_return_profile_is_ready", (DL_FUNC)&wk_time_of_day_return_profile_is_ready, 1}, {"wk_time_of_day_return_profile_reset", (DL_FUNC)&wk_time_of_day_return_profile_reset, 1}, {"wk_tower_top_bottom_new", (DL_FUNC)&wk_tower_top_bottom_new, 0}, {"wk_tower_top_bottom_update", (DL_FUNC)&wk_tower_top_bottom_update, 7}, {"wk_tower_top_bottom_batch", (DL_FUNC)&wk_tower_top_bottom_batch, 7}, + {"wk_tower_top_bottom_warmup_period", (DL_FUNC)&wk_tower_top_bottom_warmup_period, 1}, + {"wk_tower_top_bottom_is_ready", (DL_FUNC)&wk_tower_top_bottom_is_ready, 1}, {"wk_tower_top_bottom_reset", (DL_FUNC)&wk_tower_top_bottom_reset, 1}, {"wk_tpo_profile_new", (DL_FUNC)&wk_tpo_profile_new, 2}, {"wk_tpo_profile_update", (DL_FUNC)&wk_tpo_profile_update, 8}, + {"wk_tpo_profile_warmup_period", (DL_FUNC)&wk_tpo_profile_warmup_period, 1}, + {"wk_tpo_profile_is_ready", (DL_FUNC)&wk_tpo_profile_is_ready, 1}, {"wk_tpo_profile_reset", (DL_FUNC)&wk_tpo_profile_reset, 1}, {"wk_trade_imbalance_new", (DL_FUNC)&wk_trade_imbalance_new, 1}, {"wk_trade_imbalance_update", (DL_FUNC)&wk_trade_imbalance_update, 5}, + {"wk_trade_imbalance_warmup_period", (DL_FUNC)&wk_trade_imbalance_warmup_period, 1}, + {"wk_trade_imbalance_is_ready", (DL_FUNC)&wk_trade_imbalance_is_ready, 1}, {"wk_trade_imbalance_reset", (DL_FUNC)&wk_trade_imbalance_reset, 1}, {"wk_trade_sign_autocorrelation_new", (DL_FUNC)&wk_trade_sign_autocorrelation_new, 1}, {"wk_trade_sign_autocorrelation_update", (DL_FUNC)&wk_trade_sign_autocorrelation_update, 5}, + {"wk_trade_sign_autocorrelation_warmup_period", (DL_FUNC)&wk_trade_sign_autocorrelation_warmup_period, 1}, + {"wk_trade_sign_autocorrelation_is_ready", (DL_FUNC)&wk_trade_sign_autocorrelation_is_ready, 1}, {"wk_trade_sign_autocorrelation_reset", (DL_FUNC)&wk_trade_sign_autocorrelation_reset, 1}, {"wk_trade_volume_index_new", (DL_FUNC)&wk_trade_volume_index_new, 1}, {"wk_trade_volume_index_update", (DL_FUNC)&wk_trade_volume_index_update, 7}, {"wk_trade_volume_index_batch", (DL_FUNC)&wk_trade_volume_index_batch, 7}, + {"wk_trade_volume_index_warmup_period", (DL_FUNC)&wk_trade_volume_index_warmup_period, 1}, + {"wk_trade_volume_index_is_ready", (DL_FUNC)&wk_trade_volume_index_is_ready, 1}, {"wk_trade_volume_index_reset", (DL_FUNC)&wk_trade_volume_index_reset, 1}, {"wk_trend_label_new", (DL_FUNC)&wk_trend_label_new, 1}, {"wk_trend_label_update", (DL_FUNC)&wk_trend_label_update, 2}, {"wk_trend_label_batch", (DL_FUNC)&wk_trend_label_batch, 2}, + {"wk_trend_label_warmup_period", (DL_FUNC)&wk_trend_label_warmup_period, 1}, + {"wk_trend_label_is_ready", (DL_FUNC)&wk_trend_label_is_ready, 1}, {"wk_trend_label_reset", (DL_FUNC)&wk_trend_label_reset, 1}, {"wk_trend_strength_index_new", (DL_FUNC)&wk_trend_strength_index_new, 1}, {"wk_trend_strength_index_update", (DL_FUNC)&wk_trend_strength_index_update, 2}, {"wk_trend_strength_index_batch", (DL_FUNC)&wk_trend_strength_index_batch, 2}, + {"wk_trend_strength_index_warmup_period", (DL_FUNC)&wk_trend_strength_index_warmup_period, 1}, + {"wk_trend_strength_index_is_ready", (DL_FUNC)&wk_trend_strength_index_is_ready, 1}, {"wk_trend_strength_index_reset", (DL_FUNC)&wk_trend_strength_index_reset, 1}, {"wk_trendflex_new", (DL_FUNC)&wk_trendflex_new, 1}, {"wk_trendflex_update", (DL_FUNC)&wk_trendflex_update, 2}, {"wk_trendflex_batch", (DL_FUNC)&wk_trendflex_batch, 2}, + {"wk_trendflex_warmup_period", (DL_FUNC)&wk_trendflex_warmup_period, 1}, + {"wk_trendflex_is_ready", (DL_FUNC)&wk_trendflex_is_ready, 1}, {"wk_trendflex_reset", (DL_FUNC)&wk_trendflex_reset, 1}, {"wk_treynor_ratio_new", (DL_FUNC)&wk_treynor_ratio_new, 2}, {"wk_treynor_ratio_update", (DL_FUNC)&wk_treynor_ratio_update, 3}, {"wk_treynor_ratio_batch", (DL_FUNC)&wk_treynor_ratio_batch, 3}, + {"wk_treynor_ratio_warmup_period", (DL_FUNC)&wk_treynor_ratio_warmup_period, 1}, + {"wk_treynor_ratio_is_ready", (DL_FUNC)&wk_treynor_ratio_is_ready, 1}, {"wk_treynor_ratio_reset", (DL_FUNC)&wk_treynor_ratio_reset, 1}, {"wk_triangle_new", (DL_FUNC)&wk_triangle_new, 0}, {"wk_triangle_update", (DL_FUNC)&wk_triangle_update, 7}, {"wk_triangle_batch", (DL_FUNC)&wk_triangle_batch, 7}, + {"wk_triangle_warmup_period", (DL_FUNC)&wk_triangle_warmup_period, 1}, + {"wk_triangle_is_ready", (DL_FUNC)&wk_triangle_is_ready, 1}, {"wk_triangle_reset", (DL_FUNC)&wk_triangle_reset, 1}, {"wk_trima_new", (DL_FUNC)&wk_trima_new, 1}, {"wk_trima_update", (DL_FUNC)&wk_trima_update, 2}, {"wk_trima_batch", (DL_FUNC)&wk_trima_batch, 2}, + {"wk_trima_warmup_period", (DL_FUNC)&wk_trima_warmup_period, 1}, + {"wk_trima_is_ready", (DL_FUNC)&wk_trima_is_ready, 1}, {"wk_trima_reset", (DL_FUNC)&wk_trima_reset, 1}, {"wk_trin_new", (DL_FUNC)&wk_trin_new, 0}, {"wk_trin_update", (DL_FUNC)&wk_trin_update, 8}, + {"wk_trin_warmup_period", (DL_FUNC)&wk_trin_warmup_period, 1}, + {"wk_trin_is_ready", (DL_FUNC)&wk_trin_is_ready, 1}, {"wk_trin_reset", (DL_FUNC)&wk_trin_reset, 1}, {"wk_triple_top_bottom_new", (DL_FUNC)&wk_triple_top_bottom_new, 0}, {"wk_triple_top_bottom_update", (DL_FUNC)&wk_triple_top_bottom_update, 7}, {"wk_triple_top_bottom_batch", (DL_FUNC)&wk_triple_top_bottom_batch, 7}, + {"wk_triple_top_bottom_warmup_period", (DL_FUNC)&wk_triple_top_bottom_warmup_period, 1}, + {"wk_triple_top_bottom_is_ready", (DL_FUNC)&wk_triple_top_bottom_is_ready, 1}, {"wk_triple_top_bottom_reset", (DL_FUNC)&wk_triple_top_bottom_reset, 1}, {"wk_tristar_new", (DL_FUNC)&wk_tristar_new, 0}, {"wk_tristar_update", (DL_FUNC)&wk_tristar_update, 7}, {"wk_tristar_batch", (DL_FUNC)&wk_tristar_batch, 7}, + {"wk_tristar_warmup_period", (DL_FUNC)&wk_tristar_warmup_period, 1}, + {"wk_tristar_is_ready", (DL_FUNC)&wk_tristar_is_ready, 1}, {"wk_tristar_reset", (DL_FUNC)&wk_tristar_reset, 1}, {"wk_trix_new", (DL_FUNC)&wk_trix_new, 1}, {"wk_trix_update", (DL_FUNC)&wk_trix_update, 2}, {"wk_trix_batch", (DL_FUNC)&wk_trix_batch, 2}, + {"wk_trix_warmup_period", (DL_FUNC)&wk_trix_warmup_period, 1}, + {"wk_trix_is_ready", (DL_FUNC)&wk_trix_is_ready, 1}, {"wk_trix_reset", (DL_FUNC)&wk_trix_reset, 1}, {"wk_true_range_new", (DL_FUNC)&wk_true_range_new, 0}, {"wk_true_range_update", (DL_FUNC)&wk_true_range_update, 7}, {"wk_true_range_batch", (DL_FUNC)&wk_true_range_batch, 7}, + {"wk_true_range_warmup_period", (DL_FUNC)&wk_true_range_warmup_period, 1}, + {"wk_true_range_is_ready", (DL_FUNC)&wk_true_range_is_ready, 1}, {"wk_true_range_reset", (DL_FUNC)&wk_true_range_reset, 1}, {"wk_tsf_new", (DL_FUNC)&wk_tsf_new, 1}, {"wk_tsf_update", (DL_FUNC)&wk_tsf_update, 2}, {"wk_tsf_batch", (DL_FUNC)&wk_tsf_batch, 2}, + {"wk_tsf_warmup_period", (DL_FUNC)&wk_tsf_warmup_period, 1}, + {"wk_tsf_is_ready", (DL_FUNC)&wk_tsf_is_ready, 1}, {"wk_tsf_reset", (DL_FUNC)&wk_tsf_reset, 1}, {"wk_tsf_oscillator_new", (DL_FUNC)&wk_tsf_oscillator_new, 1}, {"wk_tsf_oscillator_update", (DL_FUNC)&wk_tsf_oscillator_update, 2}, {"wk_tsf_oscillator_batch", (DL_FUNC)&wk_tsf_oscillator_batch, 2}, + {"wk_tsf_oscillator_warmup_period", (DL_FUNC)&wk_tsf_oscillator_warmup_period, 1}, + {"wk_tsf_oscillator_is_ready", (DL_FUNC)&wk_tsf_oscillator_is_ready, 1}, {"wk_tsf_oscillator_reset", (DL_FUNC)&wk_tsf_oscillator_reset, 1}, {"wk_tsi_new", (DL_FUNC)&wk_tsi_new, 2}, {"wk_tsi_update", (DL_FUNC)&wk_tsi_update, 2}, {"wk_tsi_batch", (DL_FUNC)&wk_tsi_batch, 2}, + {"wk_tsi_warmup_period", (DL_FUNC)&wk_tsi_warmup_period, 1}, + {"wk_tsi_is_ready", (DL_FUNC)&wk_tsi_is_ready, 1}, {"wk_tsi_reset", (DL_FUNC)&wk_tsi_reset, 1}, {"wk_tsv_new", (DL_FUNC)&wk_tsv_new, 1}, {"wk_tsv_update", (DL_FUNC)&wk_tsv_update, 7}, {"wk_tsv_batch", (DL_FUNC)&wk_tsv_batch, 7}, + {"wk_tsv_warmup_period", (DL_FUNC)&wk_tsv_warmup_period, 1}, + {"wk_tsv_is_ready", (DL_FUNC)&wk_tsv_is_ready, 1}, {"wk_tsv_reset", (DL_FUNC)&wk_tsv_reset, 1}, {"wk_ttm_squeeze_new", (DL_FUNC)&wk_ttm_squeeze_new, 3}, {"wk_ttm_squeeze_update", (DL_FUNC)&wk_ttm_squeeze_update, 7}, + {"wk_ttm_squeeze_warmup_period", (DL_FUNC)&wk_ttm_squeeze_warmup_period, 1}, + {"wk_ttm_squeeze_is_ready", (DL_FUNC)&wk_ttm_squeeze_is_ready, 1}, {"wk_ttm_squeeze_reset", (DL_FUNC)&wk_ttm_squeeze_reset, 1}, {"wk_ttm_trend_new", (DL_FUNC)&wk_ttm_trend_new, 1}, {"wk_ttm_trend_update", (DL_FUNC)&wk_ttm_trend_update, 7}, {"wk_ttm_trend_batch", (DL_FUNC)&wk_ttm_trend_batch, 7}, + {"wk_ttm_trend_warmup_period", (DL_FUNC)&wk_ttm_trend_warmup_period, 1}, + {"wk_ttm_trend_is_ready", (DL_FUNC)&wk_ttm_trend_is_ready, 1}, {"wk_ttm_trend_reset", (DL_FUNC)&wk_ttm_trend_reset, 1}, {"wk_turn_of_month_new", (DL_FUNC)&wk_turn_of_month_new, 3}, {"wk_turn_of_month_update", (DL_FUNC)&wk_turn_of_month_update, 7}, {"wk_turn_of_month_batch", (DL_FUNC)&wk_turn_of_month_batch, 7}, + {"wk_turn_of_month_warmup_period", (DL_FUNC)&wk_turn_of_month_warmup_period, 1}, + {"wk_turn_of_month_is_ready", (DL_FUNC)&wk_turn_of_month_is_ready, 1}, {"wk_turn_of_month_reset", (DL_FUNC)&wk_turn_of_month_reset, 1}, {"wk_tweezer_new", (DL_FUNC)&wk_tweezer_new, 0}, {"wk_tweezer_update", (DL_FUNC)&wk_tweezer_update, 7}, {"wk_tweezer_batch", (DL_FUNC)&wk_tweezer_batch, 7}, + {"wk_tweezer_warmup_period", (DL_FUNC)&wk_tweezer_warmup_period, 1}, + {"wk_tweezer_is_ready", (DL_FUNC)&wk_tweezer_is_ready, 1}, {"wk_tweezer_reset", (DL_FUNC)&wk_tweezer_reset, 1}, {"wk_twiggs_money_flow_new", (DL_FUNC)&wk_twiggs_money_flow_new, 1}, {"wk_twiggs_money_flow_update", (DL_FUNC)&wk_twiggs_money_flow_update, 7}, {"wk_twiggs_money_flow_batch", (DL_FUNC)&wk_twiggs_money_flow_batch, 7}, + {"wk_twiggs_money_flow_warmup_period", (DL_FUNC)&wk_twiggs_money_flow_warmup_period, 1}, + {"wk_twiggs_money_flow_is_ready", (DL_FUNC)&wk_twiggs_money_flow_is_ready, 1}, {"wk_twiggs_money_flow_reset", (DL_FUNC)&wk_twiggs_money_flow_reset, 1}, {"wk_two_crows_new", (DL_FUNC)&wk_two_crows_new, 0}, {"wk_two_crows_update", (DL_FUNC)&wk_two_crows_update, 7}, {"wk_two_crows_batch", (DL_FUNC)&wk_two_crows_batch, 7}, + {"wk_two_crows_warmup_period", (DL_FUNC)&wk_two_crows_warmup_period, 1}, + {"wk_two_crows_is_ready", (DL_FUNC)&wk_two_crows_is_ready, 1}, {"wk_two_crows_reset", (DL_FUNC)&wk_two_crows_reset, 1}, {"wk_typical_price_new", (DL_FUNC)&wk_typical_price_new, 0}, {"wk_typical_price_update", (DL_FUNC)&wk_typical_price_update, 7}, {"wk_typical_price_batch", (DL_FUNC)&wk_typical_price_batch, 7}, + {"wk_typical_price_warmup_period", (DL_FUNC)&wk_typical_price_warmup_period, 1}, + {"wk_typical_price_is_ready", (DL_FUNC)&wk_typical_price_is_ready, 1}, {"wk_typical_price_reset", (DL_FUNC)&wk_typical_price_reset, 1}, {"wk_ulcer_index_new", (DL_FUNC)&wk_ulcer_index_new, 1}, {"wk_ulcer_index_update", (DL_FUNC)&wk_ulcer_index_update, 2}, {"wk_ulcer_index_batch", (DL_FUNC)&wk_ulcer_index_batch, 2}, + {"wk_ulcer_index_warmup_period", (DL_FUNC)&wk_ulcer_index_warmup_period, 1}, + {"wk_ulcer_index_is_ready", (DL_FUNC)&wk_ulcer_index_is_ready, 1}, {"wk_ulcer_index_reset", (DL_FUNC)&wk_ulcer_index_reset, 1}, {"wk_ultimate_oscillator_new", (DL_FUNC)&wk_ultimate_oscillator_new, 3}, {"wk_ultimate_oscillator_update", (DL_FUNC)&wk_ultimate_oscillator_update, 7}, {"wk_ultimate_oscillator_batch", (DL_FUNC)&wk_ultimate_oscillator_batch, 7}, + {"wk_ultimate_oscillator_warmup_period", (DL_FUNC)&wk_ultimate_oscillator_warmup_period, 1}, + {"wk_ultimate_oscillator_is_ready", (DL_FUNC)&wk_ultimate_oscillator_is_ready, 1}, {"wk_ultimate_oscillator_reset", (DL_FUNC)&wk_ultimate_oscillator_reset, 1}, {"wk_unique_three_river_new", (DL_FUNC)&wk_unique_three_river_new, 0}, {"wk_unique_three_river_update", (DL_FUNC)&wk_unique_three_river_update, 7}, {"wk_unique_three_river_batch", (DL_FUNC)&wk_unique_three_river_batch, 7}, + {"wk_unique_three_river_warmup_period", (DL_FUNC)&wk_unique_three_river_warmup_period, 1}, + {"wk_unique_three_river_is_ready", (DL_FUNC)&wk_unique_three_river_is_ready, 1}, {"wk_unique_three_river_reset", (DL_FUNC)&wk_unique_three_river_reset, 1}, {"wk_universal_oscillator_new", (DL_FUNC)&wk_universal_oscillator_new, 1}, {"wk_universal_oscillator_update", (DL_FUNC)&wk_universal_oscillator_update, 2}, {"wk_universal_oscillator_batch", (DL_FUNC)&wk_universal_oscillator_batch, 2}, + {"wk_universal_oscillator_warmup_period", (DL_FUNC)&wk_universal_oscillator_warmup_period, 1}, + {"wk_universal_oscillator_is_ready", (DL_FUNC)&wk_universal_oscillator_is_ready, 1}, {"wk_universal_oscillator_reset", (DL_FUNC)&wk_universal_oscillator_reset, 1}, {"wk_up_down_volume_ratio_new", (DL_FUNC)&wk_up_down_volume_ratio_new, 0}, {"wk_up_down_volume_ratio_update", (DL_FUNC)&wk_up_down_volume_ratio_update, 8}, + {"wk_up_down_volume_ratio_warmup_period", (DL_FUNC)&wk_up_down_volume_ratio_warmup_period, 1}, + {"wk_up_down_volume_ratio_is_ready", (DL_FUNC)&wk_up_down_volume_ratio_is_ready, 1}, {"wk_up_down_volume_ratio_reset", (DL_FUNC)&wk_up_down_volume_ratio_reset, 1}, {"wk_upside_gap_three_methods_new", (DL_FUNC)&wk_upside_gap_three_methods_new, 0}, {"wk_upside_gap_three_methods_update", (DL_FUNC)&wk_upside_gap_three_methods_update, 7}, {"wk_upside_gap_three_methods_batch", (DL_FUNC)&wk_upside_gap_three_methods_batch, 7}, + {"wk_upside_gap_three_methods_warmup_period", (DL_FUNC)&wk_upside_gap_three_methods_warmup_period, 1}, + {"wk_upside_gap_three_methods_is_ready", (DL_FUNC)&wk_upside_gap_three_methods_is_ready, 1}, {"wk_upside_gap_three_methods_reset", (DL_FUNC)&wk_upside_gap_three_methods_reset, 1}, {"wk_upside_gap_two_crows_new", (DL_FUNC)&wk_upside_gap_two_crows_new, 0}, {"wk_upside_gap_two_crows_update", (DL_FUNC)&wk_upside_gap_two_crows_update, 7}, {"wk_upside_gap_two_crows_batch", (DL_FUNC)&wk_upside_gap_two_crows_batch, 7}, + {"wk_upside_gap_two_crows_warmup_period", (DL_FUNC)&wk_upside_gap_two_crows_warmup_period, 1}, + {"wk_upside_gap_two_crows_is_ready", (DL_FUNC)&wk_upside_gap_two_crows_is_ready, 1}, {"wk_upside_gap_two_crows_reset", (DL_FUNC)&wk_upside_gap_two_crows_reset, 1}, {"wk_upside_potential_ratio_new", (DL_FUNC)&wk_upside_potential_ratio_new, 2}, {"wk_upside_potential_ratio_update", (DL_FUNC)&wk_upside_potential_ratio_update, 2}, {"wk_upside_potential_ratio_batch", (DL_FUNC)&wk_upside_potential_ratio_batch, 2}, + {"wk_upside_potential_ratio_warmup_period", (DL_FUNC)&wk_upside_potential_ratio_warmup_period, 1}, + {"wk_upside_potential_ratio_is_ready", (DL_FUNC)&wk_upside_potential_ratio_is_ready, 1}, {"wk_upside_potential_ratio_reset", (DL_FUNC)&wk_upside_potential_ratio_reset, 1}, {"wk_value_area_new", (DL_FUNC)&wk_value_area_new, 3}, {"wk_value_area_update", (DL_FUNC)&wk_value_area_update, 7}, + {"wk_value_area_warmup_period", (DL_FUNC)&wk_value_area_warmup_period, 1}, + {"wk_value_area_is_ready", (DL_FUNC)&wk_value_area_is_ready, 1}, {"wk_value_area_reset", (DL_FUNC)&wk_value_area_reset, 1}, {"wk_value_at_risk_new", (DL_FUNC)&wk_value_at_risk_new, 2}, {"wk_value_at_risk_update", (DL_FUNC)&wk_value_at_risk_update, 2}, {"wk_value_at_risk_batch", (DL_FUNC)&wk_value_at_risk_batch, 2}, + {"wk_value_at_risk_warmup_period", (DL_FUNC)&wk_value_at_risk_warmup_period, 1}, + {"wk_value_at_risk_is_ready", (DL_FUNC)&wk_value_at_risk_is_ready, 1}, {"wk_value_at_risk_reset", (DL_FUNC)&wk_value_at_risk_reset, 1}, {"wk_variance_new", (DL_FUNC)&wk_variance_new, 1}, {"wk_variance_update", (DL_FUNC)&wk_variance_update, 2}, {"wk_variance_batch", (DL_FUNC)&wk_variance_batch, 2}, + {"wk_variance_warmup_period", (DL_FUNC)&wk_variance_warmup_period, 1}, + {"wk_variance_is_ready", (DL_FUNC)&wk_variance_is_ready, 1}, {"wk_variance_reset", (DL_FUNC)&wk_variance_reset, 1}, {"wk_variance_ratio_new", (DL_FUNC)&wk_variance_ratio_new, 2}, {"wk_variance_ratio_update", (DL_FUNC)&wk_variance_ratio_update, 3}, {"wk_variance_ratio_batch", (DL_FUNC)&wk_variance_ratio_batch, 3}, + {"wk_variance_ratio_warmup_period", (DL_FUNC)&wk_variance_ratio_warmup_period, 1}, + {"wk_variance_ratio_is_ready", (DL_FUNC)&wk_variance_ratio_is_ready, 1}, {"wk_variance_ratio_reset", (DL_FUNC)&wk_variance_ratio_reset, 1}, {"wk_vertical_horizontal_filter_new", (DL_FUNC)&wk_vertical_horizontal_filter_new, 1}, {"wk_vertical_horizontal_filter_update", (DL_FUNC)&wk_vertical_horizontal_filter_update, 2}, {"wk_vertical_horizontal_filter_batch", (DL_FUNC)&wk_vertical_horizontal_filter_batch, 2}, + {"wk_vertical_horizontal_filter_warmup_period", (DL_FUNC)&wk_vertical_horizontal_filter_warmup_period, 1}, + {"wk_vertical_horizontal_filter_is_ready", (DL_FUNC)&wk_vertical_horizontal_filter_is_ready, 1}, {"wk_vertical_horizontal_filter_reset", (DL_FUNC)&wk_vertical_horizontal_filter_reset, 1}, {"wk_vidya_new", (DL_FUNC)&wk_vidya_new, 2}, {"wk_vidya_update", (DL_FUNC)&wk_vidya_update, 2}, {"wk_vidya_batch", (DL_FUNC)&wk_vidya_batch, 2}, + {"wk_vidya_warmup_period", (DL_FUNC)&wk_vidya_warmup_period, 1}, + {"wk_vidya_is_ready", (DL_FUNC)&wk_vidya_is_ready, 1}, {"wk_vidya_reset", (DL_FUNC)&wk_vidya_reset, 1}, {"wk_volatility_cone_new", (DL_FUNC)&wk_volatility_cone_new, 2}, {"wk_volatility_cone_update", (DL_FUNC)&wk_volatility_cone_update, 7}, + {"wk_volatility_cone_warmup_period", (DL_FUNC)&wk_volatility_cone_warmup_period, 1}, + {"wk_volatility_cone_is_ready", (DL_FUNC)&wk_volatility_cone_is_ready, 1}, {"wk_volatility_cone_reset", (DL_FUNC)&wk_volatility_cone_reset, 1}, {"wk_volatility_of_volatility_new", (DL_FUNC)&wk_volatility_of_volatility_new, 2}, {"wk_volatility_of_volatility_update", (DL_FUNC)&wk_volatility_of_volatility_update, 2}, {"wk_volatility_of_volatility_batch", (DL_FUNC)&wk_volatility_of_volatility_batch, 2}, + {"wk_volatility_of_volatility_warmup_period", (DL_FUNC)&wk_volatility_of_volatility_warmup_period, 1}, + {"wk_volatility_of_volatility_is_ready", (DL_FUNC)&wk_volatility_of_volatility_is_ready, 1}, {"wk_volatility_of_volatility_reset", (DL_FUNC)&wk_volatility_of_volatility_reset, 1}, {"wk_volatility_ratio_new", (DL_FUNC)&wk_volatility_ratio_new, 1}, {"wk_volatility_ratio_update", (DL_FUNC)&wk_volatility_ratio_update, 7}, {"wk_volatility_ratio_batch", (DL_FUNC)&wk_volatility_ratio_batch, 7}, + {"wk_volatility_ratio_warmup_period", (DL_FUNC)&wk_volatility_ratio_warmup_period, 1}, + {"wk_volatility_ratio_is_ready", (DL_FUNC)&wk_volatility_ratio_is_ready, 1}, {"wk_volatility_ratio_reset", (DL_FUNC)&wk_volatility_ratio_reset, 1}, {"wk_volty_stop_new", (DL_FUNC)&wk_volty_stop_new, 2}, {"wk_volty_stop_update", (DL_FUNC)&wk_volty_stop_update, 7}, {"wk_volty_stop_batch", (DL_FUNC)&wk_volty_stop_batch, 7}, + {"wk_volty_stop_warmup_period", (DL_FUNC)&wk_volty_stop_warmup_period, 1}, + {"wk_volty_stop_is_ready", (DL_FUNC)&wk_volty_stop_is_ready, 1}, {"wk_volty_stop_reset", (DL_FUNC)&wk_volty_stop_reset, 1}, {"wk_volume_bars_new", (DL_FUNC)&wk_volume_bars_new, 1}, {"wk_volume_bars_update", (DL_FUNC)&wk_volume_bars_update, 7}, {"wk_volume_bars_reset", (DL_FUNC)&wk_volume_bars_reset, 1}, {"wk_volume_by_time_profile_new", (DL_FUNC)&wk_volume_by_time_profile_new, 2}, {"wk_volume_by_time_profile_update", (DL_FUNC)&wk_volume_by_time_profile_update, 8}, + {"wk_volume_by_time_profile_warmup_period", (DL_FUNC)&wk_volume_by_time_profile_warmup_period, 1}, + {"wk_volume_by_time_profile_is_ready", (DL_FUNC)&wk_volume_by_time_profile_is_ready, 1}, {"wk_volume_by_time_profile_reset", (DL_FUNC)&wk_volume_by_time_profile_reset, 1}, {"wk_volume_oscillator_new", (DL_FUNC)&wk_volume_oscillator_new, 2}, {"wk_volume_oscillator_update", (DL_FUNC)&wk_volume_oscillator_update, 7}, {"wk_volume_oscillator_batch", (DL_FUNC)&wk_volume_oscillator_batch, 7}, + {"wk_volume_oscillator_warmup_period", (DL_FUNC)&wk_volume_oscillator_warmup_period, 1}, + {"wk_volume_oscillator_is_ready", (DL_FUNC)&wk_volume_oscillator_is_ready, 1}, {"wk_volume_oscillator_reset", (DL_FUNC)&wk_volume_oscillator_reset, 1}, {"wk_volume_price_trend_new", (DL_FUNC)&wk_volume_price_trend_new, 0}, {"wk_volume_price_trend_update", (DL_FUNC)&wk_volume_price_trend_update, 7}, {"wk_volume_price_trend_batch", (DL_FUNC)&wk_volume_price_trend_batch, 7}, + {"wk_volume_price_trend_warmup_period", (DL_FUNC)&wk_volume_price_trend_warmup_period, 1}, + {"wk_volume_price_trend_is_ready", (DL_FUNC)&wk_volume_price_trend_is_ready, 1}, {"wk_volume_price_trend_reset", (DL_FUNC)&wk_volume_price_trend_reset, 1}, {"wk_volume_profile_new", (DL_FUNC)&wk_volume_profile_new, 2}, {"wk_volume_profile_update", (DL_FUNC)&wk_volume_profile_update, 8}, + {"wk_volume_profile_warmup_period", (DL_FUNC)&wk_volume_profile_warmup_period, 1}, + {"wk_volume_profile_is_ready", (DL_FUNC)&wk_volume_profile_is_ready, 1}, {"wk_volume_profile_reset", (DL_FUNC)&wk_volume_profile_reset, 1}, {"wk_volume_rsi_new", (DL_FUNC)&wk_volume_rsi_new, 1}, {"wk_volume_rsi_update", (DL_FUNC)&wk_volume_rsi_update, 7}, {"wk_volume_rsi_batch", (DL_FUNC)&wk_volume_rsi_batch, 7}, + {"wk_volume_rsi_warmup_period", (DL_FUNC)&wk_volume_rsi_warmup_period, 1}, + {"wk_volume_rsi_is_ready", (DL_FUNC)&wk_volume_rsi_is_ready, 1}, {"wk_volume_rsi_reset", (DL_FUNC)&wk_volume_rsi_reset, 1}, {"wk_volume_weighted_macd_new", (DL_FUNC)&wk_volume_weighted_macd_new, 3}, {"wk_volume_weighted_macd_update", (DL_FUNC)&wk_volume_weighted_macd_update, 7}, + {"wk_volume_weighted_macd_warmup_period", (DL_FUNC)&wk_volume_weighted_macd_warmup_period, 1}, + {"wk_volume_weighted_macd_is_ready", (DL_FUNC)&wk_volume_weighted_macd_is_ready, 1}, {"wk_volume_weighted_macd_reset", (DL_FUNC)&wk_volume_weighted_macd_reset, 1}, {"wk_volume_weighted_sr_new", (DL_FUNC)&wk_volume_weighted_sr_new, 1}, {"wk_volume_weighted_sr_update", (DL_FUNC)&wk_volume_weighted_sr_update, 7}, + {"wk_volume_weighted_sr_warmup_period", (DL_FUNC)&wk_volume_weighted_sr_warmup_period, 1}, + {"wk_volume_weighted_sr_is_ready", (DL_FUNC)&wk_volume_weighted_sr_is_ready, 1}, {"wk_volume_weighted_sr_reset", (DL_FUNC)&wk_volume_weighted_sr_reset, 1}, {"wk_vortex_new", (DL_FUNC)&wk_vortex_new, 1}, {"wk_vortex_update", (DL_FUNC)&wk_vortex_update, 7}, + {"wk_vortex_warmup_period", (DL_FUNC)&wk_vortex_warmup_period, 1}, + {"wk_vortex_is_ready", (DL_FUNC)&wk_vortex_is_ready, 1}, {"wk_vortex_reset", (DL_FUNC)&wk_vortex_reset, 1}, {"wk_vpin_new", (DL_FUNC)&wk_vpin_new, 2}, {"wk_vpin_update", (DL_FUNC)&wk_vpin_update, 5}, + {"wk_vpin_warmup_period", (DL_FUNC)&wk_vpin_warmup_period, 1}, + {"wk_vpin_is_ready", (DL_FUNC)&wk_vpin_is_ready, 1}, {"wk_vpin_reset", (DL_FUNC)&wk_vpin_reset, 1}, {"wk_vwap_new", (DL_FUNC)&wk_vwap_new, 0}, {"wk_vwap_update", (DL_FUNC)&wk_vwap_update, 7}, {"wk_vwap_batch", (DL_FUNC)&wk_vwap_batch, 7}, + {"wk_vwap_warmup_period", (DL_FUNC)&wk_vwap_warmup_period, 1}, + {"wk_vwap_is_ready", (DL_FUNC)&wk_vwap_is_ready, 1}, {"wk_vwap_reset", (DL_FUNC)&wk_vwap_reset, 1}, {"wk_vwap_std_dev_bands_new", (DL_FUNC)&wk_vwap_std_dev_bands_new, 1}, {"wk_vwap_std_dev_bands_update", (DL_FUNC)&wk_vwap_std_dev_bands_update, 7}, + {"wk_vwap_std_dev_bands_warmup_period", (DL_FUNC)&wk_vwap_std_dev_bands_warmup_period, 1}, + {"wk_vwap_std_dev_bands_is_ready", (DL_FUNC)&wk_vwap_std_dev_bands_is_ready, 1}, {"wk_vwap_std_dev_bands_reset", (DL_FUNC)&wk_vwap_std_dev_bands_reset, 1}, {"wk_vwma_new", (DL_FUNC)&wk_vwma_new, 1}, {"wk_vwma_update", (DL_FUNC)&wk_vwma_update, 7}, {"wk_vwma_batch", (DL_FUNC)&wk_vwma_batch, 7}, + {"wk_vwma_warmup_period", (DL_FUNC)&wk_vwma_warmup_period, 1}, + {"wk_vwma_is_ready", (DL_FUNC)&wk_vwma_is_ready, 1}, {"wk_vwma_reset", (DL_FUNC)&wk_vwma_reset, 1}, {"wk_vzo_new", (DL_FUNC)&wk_vzo_new, 1}, {"wk_vzo_update", (DL_FUNC)&wk_vzo_update, 7}, {"wk_vzo_batch", (DL_FUNC)&wk_vzo_batch, 7}, + {"wk_vzo_warmup_period", (DL_FUNC)&wk_vzo_warmup_period, 1}, + {"wk_vzo_is_ready", (DL_FUNC)&wk_vzo_is_ready, 1}, {"wk_vzo_reset", (DL_FUNC)&wk_vzo_reset, 1}, {"wk_wad_new", (DL_FUNC)&wk_wad_new, 0}, {"wk_wad_update", (DL_FUNC)&wk_wad_update, 7}, {"wk_wad_batch", (DL_FUNC)&wk_wad_batch, 7}, + {"wk_wad_warmup_period", (DL_FUNC)&wk_wad_warmup_period, 1}, + {"wk_wad_is_ready", (DL_FUNC)&wk_wad_is_ready, 1}, {"wk_wad_reset", (DL_FUNC)&wk_wad_reset, 1}, {"wk_wave_pm_new", (DL_FUNC)&wk_wave_pm_new, 2}, {"wk_wave_pm_update", (DL_FUNC)&wk_wave_pm_update, 2}, {"wk_wave_pm_batch", (DL_FUNC)&wk_wave_pm_batch, 2}, + {"wk_wave_pm_warmup_period", (DL_FUNC)&wk_wave_pm_warmup_period, 1}, + {"wk_wave_pm_is_ready", (DL_FUNC)&wk_wave_pm_is_ready, 1}, {"wk_wave_pm_reset", (DL_FUNC)&wk_wave_pm_reset, 1}, {"wk_wave_trend_new", (DL_FUNC)&wk_wave_trend_new, 3}, {"wk_wave_trend_update", (DL_FUNC)&wk_wave_trend_update, 7}, + {"wk_wave_trend_warmup_period", (DL_FUNC)&wk_wave_trend_warmup_period, 1}, + {"wk_wave_trend_is_ready", (DL_FUNC)&wk_wave_trend_is_ready, 1}, {"wk_wave_trend_reset", (DL_FUNC)&wk_wave_trend_reset, 1}, {"wk_wedge_new", (DL_FUNC)&wk_wedge_new, 0}, {"wk_wedge_update", (DL_FUNC)&wk_wedge_update, 7}, {"wk_wedge_batch", (DL_FUNC)&wk_wedge_batch, 7}, + {"wk_wedge_warmup_period", (DL_FUNC)&wk_wedge_warmup_period, 1}, + {"wk_wedge_is_ready", (DL_FUNC)&wk_wedge_is_ready, 1}, {"wk_wedge_reset", (DL_FUNC)&wk_wedge_reset, 1}, {"wk_weighted_close_new", (DL_FUNC)&wk_weighted_close_new, 0}, {"wk_weighted_close_update", (DL_FUNC)&wk_weighted_close_update, 7}, {"wk_weighted_close_batch", (DL_FUNC)&wk_weighted_close_batch, 7}, + {"wk_weighted_close_warmup_period", (DL_FUNC)&wk_weighted_close_warmup_period, 1}, + {"wk_weighted_close_is_ready", (DL_FUNC)&wk_weighted_close_is_ready, 1}, {"wk_weighted_close_reset", (DL_FUNC)&wk_weighted_close_reset, 1}, {"wk_wick_ratio_new", (DL_FUNC)&wk_wick_ratio_new, 0}, {"wk_wick_ratio_update", (DL_FUNC)&wk_wick_ratio_update, 7}, {"wk_wick_ratio_batch", (DL_FUNC)&wk_wick_ratio_batch, 7}, + {"wk_wick_ratio_warmup_period", (DL_FUNC)&wk_wick_ratio_warmup_period, 1}, + {"wk_wick_ratio_is_ready", (DL_FUNC)&wk_wick_ratio_is_ready, 1}, {"wk_wick_ratio_reset", (DL_FUNC)&wk_wick_ratio_reset, 1}, {"wk_williams_fractals_new", (DL_FUNC)&wk_williams_fractals_new, 0}, {"wk_williams_fractals_update", (DL_FUNC)&wk_williams_fractals_update, 7}, + {"wk_williams_fractals_warmup_period", (DL_FUNC)&wk_williams_fractals_warmup_period, 1}, + {"wk_williams_fractals_is_ready", (DL_FUNC)&wk_williams_fractals_is_ready, 1}, {"wk_williams_fractals_reset", (DL_FUNC)&wk_williams_fractals_reset, 1}, {"wk_williams_r_new", (DL_FUNC)&wk_williams_r_new, 1}, {"wk_williams_r_update", (DL_FUNC)&wk_williams_r_update, 7}, {"wk_williams_r_batch", (DL_FUNC)&wk_williams_r_batch, 7}, + {"wk_williams_r_warmup_period", (DL_FUNC)&wk_williams_r_warmup_period, 1}, + {"wk_williams_r_is_ready", (DL_FUNC)&wk_williams_r_is_ready, 1}, {"wk_williams_r_reset", (DL_FUNC)&wk_williams_r_reset, 1}, {"wk_win_rate_new", (DL_FUNC)&wk_win_rate_new, 1}, {"wk_win_rate_update", (DL_FUNC)&wk_win_rate_update, 2}, {"wk_win_rate_batch", (DL_FUNC)&wk_win_rate_batch, 2}, + {"wk_win_rate_warmup_period", (DL_FUNC)&wk_win_rate_warmup_period, 1}, + {"wk_win_rate_is_ready", (DL_FUNC)&wk_win_rate_is_ready, 1}, {"wk_win_rate_reset", (DL_FUNC)&wk_win_rate_reset, 1}, {"wk_wma_new", (DL_FUNC)&wk_wma_new, 1}, {"wk_wma_update", (DL_FUNC)&wk_wma_update, 2}, {"wk_wma_batch", (DL_FUNC)&wk_wma_batch, 2}, + {"wk_wma_warmup_period", (DL_FUNC)&wk_wma_warmup_period, 1}, + {"wk_wma_is_ready", (DL_FUNC)&wk_wma_is_ready, 1}, {"wk_wma_reset", (DL_FUNC)&wk_wma_reset, 1}, {"wk_woodie_pivots_new", (DL_FUNC)&wk_woodie_pivots_new, 0}, {"wk_woodie_pivots_update", (DL_FUNC)&wk_woodie_pivots_update, 7}, + {"wk_woodie_pivots_warmup_period", (DL_FUNC)&wk_woodie_pivots_warmup_period, 1}, + {"wk_woodie_pivots_is_ready", (DL_FUNC)&wk_woodie_pivots_is_ready, 1}, {"wk_woodie_pivots_reset", (DL_FUNC)&wk_woodie_pivots_reset, 1}, {"wk_yang_zhang_volatility_new", (DL_FUNC)&wk_yang_zhang_volatility_new, 2}, {"wk_yang_zhang_volatility_update", (DL_FUNC)&wk_yang_zhang_volatility_update, 7}, {"wk_yang_zhang_volatility_batch", (DL_FUNC)&wk_yang_zhang_volatility_batch, 7}, + {"wk_yang_zhang_volatility_warmup_period", (DL_FUNC)&wk_yang_zhang_volatility_warmup_period, 1}, + {"wk_yang_zhang_volatility_is_ready", (DL_FUNC)&wk_yang_zhang_volatility_is_ready, 1}, {"wk_yang_zhang_volatility_reset", (DL_FUNC)&wk_yang_zhang_volatility_reset, 1}, {"wk_yoyo_exit_new", (DL_FUNC)&wk_yoyo_exit_new, 2}, {"wk_yoyo_exit_update", (DL_FUNC)&wk_yoyo_exit_update, 7}, {"wk_yoyo_exit_batch", (DL_FUNC)&wk_yoyo_exit_batch, 7}, + {"wk_yoyo_exit_warmup_period", (DL_FUNC)&wk_yoyo_exit_warmup_period, 1}, + {"wk_yoyo_exit_is_ready", (DL_FUNC)&wk_yoyo_exit_is_ready, 1}, {"wk_yoyo_exit_reset", (DL_FUNC)&wk_yoyo_exit_reset, 1}, {"wk_z_score_new", (DL_FUNC)&wk_z_score_new, 1}, {"wk_z_score_update", (DL_FUNC)&wk_z_score_update, 2}, {"wk_z_score_batch", (DL_FUNC)&wk_z_score_batch, 2}, + {"wk_z_score_warmup_period", (DL_FUNC)&wk_z_score_warmup_period, 1}, + {"wk_z_score_is_ready", (DL_FUNC)&wk_z_score_is_ready, 1}, {"wk_z_score_reset", (DL_FUNC)&wk_z_score_reset, 1}, {"wk_zero_lag_macd_new", (DL_FUNC)&wk_zero_lag_macd_new, 3}, {"wk_zero_lag_macd_update", (DL_FUNC)&wk_zero_lag_macd_update, 2}, + {"wk_zero_lag_macd_warmup_period", (DL_FUNC)&wk_zero_lag_macd_warmup_period, 1}, + {"wk_zero_lag_macd_is_ready", (DL_FUNC)&wk_zero_lag_macd_is_ready, 1}, {"wk_zero_lag_macd_reset", (DL_FUNC)&wk_zero_lag_macd_reset, 1}, {"wk_zig_zag_new", (DL_FUNC)&wk_zig_zag_new, 1}, {"wk_zig_zag_update", (DL_FUNC)&wk_zig_zag_update, 7}, + {"wk_zig_zag_warmup_period", (DL_FUNC)&wk_zig_zag_warmup_period, 1}, + {"wk_zig_zag_is_ready", (DL_FUNC)&wk_zig_zag_is_ready, 1}, {"wk_zig_zag_reset", (DL_FUNC)&wk_zig_zag_reset, 1}, {"wk_zlema_new", (DL_FUNC)&wk_zlema_new, 1}, {"wk_zlema_update", (DL_FUNC)&wk_zlema_update, 2}, {"wk_zlema_batch", (DL_FUNC)&wk_zlema_batch, 2}, + {"wk_zlema_warmup_period", (DL_FUNC)&wk_zlema_warmup_period, 1}, + {"wk_zlema_is_ready", (DL_FUNC)&wk_zlema_is_ready, 1}, {"wk_zlema_reset", (DL_FUNC)&wk_zlema_reset, 1}, {NULL, NULL, 0} }; diff --git a/bindings/r/tests/testthat/test-archetypes.R b/bindings/r/tests/testthat/test-archetypes.R index b7b149a7..f6e36f56 100644 --- a/bindings/r/tests/testthat/test-archetypes.R +++ b/bindings/r/tests/testthat/test-archetypes.R @@ -7,6 +7,19 @@ test_that("scalar update returns the textbook value", { expect_equal(v, 4) }) +test_that("warmup_period and is_ready report the warmup transition", { + s <- Sma(3) + expect_equal(warmup_period(s), 3L) + expect_false(is_ready(s)) + update(s, 1) + update(s, 2) + expect_false(is_ready(s)) + update(s, 3) + expect_true(is_ready(s)) + reset(s) + expect_false(is_ready(s)) +}) + test_that("batch matches streaming", { input <- c(1, 2, 3, 4, 5, 6, 7, 8) stream <- Sma(3) diff --git a/examples/c/archetypes.c b/examples/c/archetypes.c index f95ec940..fb0d592b 100644 --- a/examples/c/archetypes.c +++ b/examples/c/archetypes.c @@ -151,6 +151,23 @@ int main(void) { /* 9. A NULL handle update is a no-op returning NaN, never a crash. */ CHECK(is_nan(wickra_sma_update(NULL, 1.0)), "update(NULL) should return NaN"); + CHECK(wickra_sma_warmup_period(NULL) == 0, "warmup_period(NULL) should be 0"); + CHECK(!wickra_sma_is_ready(NULL), "is_ready(NULL) should be false"); + + /* 10. warmup_period / is_ready report the warmup transition. */ + { + struct Sma *sma = wickra_sma_new(3); + CHECK(wickra_sma_warmup_period(sma) == 3, "SMA(3) warmup_period should be 3"); + CHECK(!wickra_sma_is_ready(sma), "SMA is not ready before any update"); + wickra_sma_update(sma, 1.0); + wickra_sma_update(sma, 2.0); + CHECK(!wickra_sma_is_ready(sma), "SMA is not ready mid-warmup"); + wickra_sma_update(sma, 3.0); + CHECK(wickra_sma_is_ready(sma), "SMA is ready after the warmup period"); + wickra_sma_reset(sma); + CHECK(!wickra_sma_is_ready(sma), "SMA is not ready after reset"); + wickra_sma_free(sma); + } if (failures == 0) { printf("all archetypes passed\n");