From b06ce2678abc18ddbb1d3e243c69c092144a411a Mon Sep 17 00:00:00 2001 From: kingchenc Date: Tue, 9 Jun 2026 23:06:16 +0200 Subject: [PATCH] Restructure the Go binding for self-contained distribution (#236) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Problem Plain `go get` + `go build` of the Go binding never worked **as a dependency**: - cgo `CFLAGS` pointed at `${SRCDIR}/../c/include` — the parent dir is **outside** the Go module, so a proxy-fetched module has no header. - the library under `./lib` was git-ignored and never shipped; the README told users to `cargo build` it from the workspace, which only works inside a clone, not from the read-only module cache. cgo has no build hook and Go has no registry, so the only way a consumer's `go get`+build can find the lib is for it to be committed **inside the module the consumer pulls**. Per the design decision, that module is a separate **`wickra-go`** repo (keeps this repo free of committed binaries), populated by the release pipeline — this PR is the in-repo restructure that makes that possible. ## Changes - **Vendor the header** at `bindings/go/include/wickra.h` (committed copy of `bindings/c/include/wickra.h`); `CFLAGS` → `-I${SRCDIR}/include`. A **CI drift check** fails if the copy goes stale. - **Per-platform libraries**: cgo `LDFLAGS` become per `GOOS`/`GOARCH`, linking `${SRCDIR}/lib/_/`. - **CI** stages the host library into `lib/_/` (`RUNNER_OS`/`RUNNER_ARCH` — note `macos-latest` is arm64) and exports `WICKRA_GO_LIBDIR` for the Windows PATH; libraries stay git-ignored here. - **README**: install via the `wickra-go` module + a contributor build section. ## Validation - Local **windows/amd64**: `gofmt` clean, `go vet`, `go build`, `go test` all green against the staged library + vendored header. - Linux/macOS arches → the 3-OS `Go on …` CI job. Follow-up (Stage 2, separate): create `wickra-lib/wickra-go` + a `release.yml` mirror job (source + 6 platform libs → `lib/_/`, commit + tag), and point the docs at the new import path. Part of the self-contained gap (`todo-11`). --- .gitattributes | 5 +- .github/workflows/ci.yml | 41 +- bindings/go/README.md | 34 +- bindings/go/include/wickra.h | 10658 +++++++++++++++++++++++++++++++++ bindings/go/wickra.go | 19 +- 5 files changed, 10730 insertions(+), 27 deletions(-) create mode 100644 bindings/go/include/wickra.h diff --git a/.gitattributes b/.gitattributes index 4a2c705f..903f572e 100644 --- a/.gitattributes +++ b/.gitattributes @@ -11,10 +11,13 @@ bindings/c/include/wickra.h text eol=lf *.cs text eol=lf # Go sources (including the generated binding) are pinned to LF so gofmt's CI -# check never trips on a CRLF checkout on Windows. +# check never trips on a CRLF checkout on Windows. The vendored C ABI header is +# a committed copy of bindings/c/include/wickra.h (the parent dir is outside the +# Go module), pinned to LF so the drift check never trips on CRLF. *.go text eol=lf go.mod text eol=lf go.sum text eol=lf +bindings/go/include/wickra.h text eol=lf # Java sources (including the generated binding) are pinned to LF so the # committed files stay stable regardless of the committer's autocrlf setting. diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c32dd04c..951bf23f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -778,15 +778,36 @@ jobs: - name: Build the C ABI library run: cargo build -p wickra-c --release + - name: Vendored header in sync with the C ABI + shell: bash + # bindings/go/include/wickra.h is a committed copy of the cbindgen header + # (the parent ../c/include is outside the Go module, so it must be + # vendored). Fail if it drifts from the source of truth. + run: | + if ! diff -u bindings/c/include/wickra.h bindings/go/include/wickra.h; then + echo "::error::bindings/go/include/wickra.h is stale — copy bindings/c/include/wickra.h over it" + exit 1 + fi + - name: Stage the native library shell: bash + # Stage into lib/_/ to match the per-platform cgo LDFLAGS. + # CI builds the host target, so RUNNER_OS/ARCH give the right directory + # (note macos-latest is arm64). run: | - mkdir -p bindings/go/lib - case "$RUNNER_OS" in - Linux) cp target/release/libwickra.so bindings/go/lib/ ;; - macOS) cp target/release/libwickra.dylib bindings/go/lib/ ;; - Windows) cp target/release/wickra.dll bindings/go/lib/ ;; + case "$RUNNER_ARCH" in + X64) arch=amd64 ;; + ARM64) arch=arm64 ;; + *) echo "::error::unsupported RUNNER_ARCH '$RUNNER_ARCH'"; exit 1 ;; esac + case "$RUNNER_OS" in + Linux) dir="linux_$arch"; lib=target/release/libwickra.so ;; + macOS) dir="darwin_$arch"; lib=target/release/libwickra.dylib ;; + Windows) dir="windows_$arch"; lib=target/release/wickra.dll ;; + esac + mkdir -p "bindings/go/lib/$dir" + cp "$lib" "bindings/go/lib/$dir/" + echo "WICKRA_GO_LIBDIR=$PWD/bindings/go/lib/$dir" >> "$GITHUB_ENV" - name: Go info run: go version @@ -801,9 +822,11 @@ jobs: - name: Vet and test the Go binding shell: bash - # On Windows there is no rpath; the loader resolves wickra.dll via PATH. + # On Windows there is no rpath; the loader resolves wickra.dll via PATH + # (WICKRA_GO_LIBDIR is the per-platform staged lib dir). Linux/macOS use + # the rpath baked by the per-platform cgo LDFLAGS. run: | - export PATH="$PWD/bindings/go/lib:$PATH" + export PATH="$WICKRA_GO_LIBDIR:$PATH" cd bindings/go go vet ./... go test ./... @@ -811,7 +834,7 @@ jobs: - name: Build the Go examples shell: bash run: | - export PATH="$PWD/bindings/go/lib:$PATH" + export PATH="$WICKRA_GO_LIBDIR:$PATH" cd examples/go go build ./... @@ -819,7 +842,7 @@ jobs: - name: Run the offline Go examples shell: bash run: | - export PATH="$PWD/bindings/go/lib:$PATH" + export PATH="$WICKRA_GO_LIBDIR:$PATH" cd examples/go for d in streaming backtest multi_timeframe parallel_assets \ strategy_rsi_mean_reversion strategy_macd_adx strategy_bollinger_squeeze; do diff --git a/bindings/go/README.md b/bindings/go/README.md index 3ce730ea..cfb20751 100644 --- a/bindings/go/README.md +++ b/bindings/go/README.md @@ -16,24 +16,38 @@ cgo and exposes all 514 streaming-first indicators as idiomatic types. ## Install +Use the published **`wickra-go`** module, which bundles the prebuilt C ABI +library for every platform, so `go get` + `go build` works with no extra steps +(a C compiler is still required, as the binding uses cgo): + ```bash -go get github.com/wickra-lib/wickra/bindings/go +go get github.com/wickra-lib/wickra-go ``` -The binding uses cgo, so a C compiler is required, and it links against the -prebuilt Wickra C ABI library. Build that library from the workspace and stage -it under this package's `lib/` directory: +```go +import wickra "github.com/wickra-lib/wickra-go" +``` + +`wickra-go` is generated from this directory by the release pipeline: it mirrors +the Go sources, the vendored C ABI header (`include/wickra.h`) and the prebuilt +libraries under `lib/_/`. On Linux/macOS the library path is baked +in via rpath; on Windows the DLL must be discoverable at run time (next to the +executable or on `PATH`). + +### Building from this repository (contributors) + +This `bindings/go` directory is the development source. To build it directly, +compile the C ABI and stage the library into the per-platform directory cgo +links against: ```bash cargo build -p wickra-c --release -cp target/release/libwickra.so bindings/go/lib/ # Linux -cp target/release/libwickra.dylib bindings/go/lib/ # macOS -cp target/release/wickra.dll bindings/go/lib/ # Windows (also on PATH at run time) +mkdir -p bindings/go/lib/linux_amd64 # match your GOOS_GOARCH +cp target/release/libwickra.so bindings/go/lib/linux_amd64/ # Linux +cp target/release/libwickra.dylib bindings/go/lib/darwin_arm64/ # macOS (arm64) +cp target/release/wickra.dll bindings/go/lib/windows_amd64/ # Windows ``` -On Linux and macOS the library path is baked in via rpath; on Windows the DLL -must be discoverable at run time (next to the executable or on `PATH`). - ## Quick start ```go diff --git a/bindings/go/include/wickra.h b/bindings/go/include/wickra.h new file mode 100644 index 00000000..0c4ca4e9 --- /dev/null +++ b/bindings/go/include/wickra.h @@ -0,0 +1,10658 @@ +/* Wickra C ABI — generated by cbindgen. Do not edit by hand. */ + +#ifndef WICKRA_H +#define WICKRA_H + +#pragma once + +#include +#include +#include +#include + +typedef struct AbandonedBaby AbandonedBaby; + +typedef struct Abcd Abcd; + +typedef struct AbsoluteBreadthIndex AbsoluteBreadthIndex; + +typedef struct AccelerationBands AccelerationBands; + +typedef struct AcceleratorOscillator AcceleratorOscillator; + +typedef struct AdOscillator AdOscillator; + +typedef struct AdVolumeLine AdVolumeLine; + +typedef struct AdaptiveCci AdaptiveCci; + +typedef struct AdaptiveCycle AdaptiveCycle; + +typedef struct AdaptiveLaguerreFilter AdaptiveLaguerreFilter; + +typedef struct AdaptiveRsi AdaptiveRsi; + +typedef struct Adl Adl; + +typedef struct AdvanceBlock AdvanceBlock; + +typedef struct AdvanceDecline AdvanceDecline; + +typedef struct AdvanceDeclineRatio AdvanceDeclineRatio; + +typedef struct Adx Adx; + +typedef struct Adxr Adxr; + +typedef struct Alligator Alligator; + +typedef struct Alma Alma; + +typedef struct Alpha Alpha; + +typedef struct AmihudIlliquidity AmihudIlliquidity; + +typedef struct AnchoredRsi AnchoredRsi; + +typedef struct AnchoredVwap AnchoredVwap; + +typedef struct AndrewsPitchfork AndrewsPitchfork; + +typedef struct Apo Apo; + +typedef struct Aroon Aroon; + +typedef struct AroonOscillator AroonOscillator; + +typedef struct Atr Atr; + +typedef struct AtrBands AtrBands; + +typedef struct AtrRatchet AtrRatchet; + +typedef struct AtrTrailingStop AtrTrailingStop; + +typedef struct AutoFib AutoFib; + +typedef struct Autocorrelation Autocorrelation; + +typedef struct AutocorrelationPeriodogram AutocorrelationPeriodogram; + +typedef struct AverageDailyRange AverageDailyRange; + +typedef struct AverageDrawdown AverageDrawdown; + +typedef struct AvgPrice AvgPrice; + +typedef struct AwesomeOscillator AwesomeOscillator; + +typedef struct AwesomeOscillatorHistogram AwesomeOscillatorHistogram; + +typedef struct BalanceOfPower BalanceOfPower; + +typedef struct BandpassFilter BandpassFilter; + +typedef struct Bat Bat; + +typedef struct BeltHold BeltHold; + +typedef struct Beta Beta; + +typedef struct BetaNeutralSpread BetaNeutralSpread; + +typedef struct BetterVolume BetterVolume; + +typedef struct BipowerVariation BipowerVariation; + +typedef struct BodySizePct BodySizePct; + +typedef struct BollingerBands BollingerBands; + +typedef struct BollingerBandwidth BollingerBandwidth; + +typedef struct BomarBands BomarBands; + +typedef struct BreadthThrust BreadthThrust; + +typedef struct Breakaway Breakaway; + +typedef struct BullishPercentIndex BullishPercentIndex; + +typedef struct BurkeRatio BurkeRatio; + +typedef struct Butterfly Butterfly; + +typedef struct CalendarSpread CalendarSpread; + +typedef struct CalmarRatio CalmarRatio; + +typedef struct Camarilla Camarilla; + +typedef struct CandleVolume CandleVolume; + +typedef struct Cci Cci; + +typedef struct CenterOfGravity CenterOfGravity; + +typedef struct CentralPivotRange CentralPivotRange; + +typedef struct Cfo Cfo; + +typedef struct ChaikinMoneyFlow ChaikinMoneyFlow; + +typedef struct ChaikinOscillator ChaikinOscillator; + +typedef struct ChaikinVolatility ChaikinVolatility; + +typedef struct ChandeKrollStop ChandeKrollStop; + +typedef struct ChandelierExit ChandelierExit; + +typedef struct ChoppinessIndex ChoppinessIndex; + +typedef struct ClassicPivots ClassicPivots; + +typedef struct CloseVsOpen CloseVsOpen; + +typedef struct ClosingMarubozu ClosingMarubozu; + +typedef struct Cmo Cmo; + +typedef struct CoefficientOfVariation CoefficientOfVariation; + +typedef struct Cointegration Cointegration; + +typedef struct CommonSenseRatio CommonSenseRatio; + +typedef struct CompositeProfile CompositeProfile; + +typedef struct ConcealingBabySwallow ConcealingBabySwallow; + +typedef struct ConditionalValueAtRisk ConditionalValueAtRisk; + +typedef struct ConnorsRsi ConnorsRsi; + +typedef struct Coppock Coppock; + +typedef struct CorrelationTrendIndicator CorrelationTrendIndicator; + +typedef struct Counterattack Counterattack; + +typedef struct Crab Crab; + +typedef struct CumulativeVolumeDelta CumulativeVolumeDelta; + +typedef struct CumulativeVolumeIndex CumulativeVolumeIndex; + +typedef struct CupAndHandle CupAndHandle; + +typedef struct CyberneticCycle CyberneticCycle; + +typedef struct Cypher Cypher; + +typedef struct DayOfWeekProfile DayOfWeekProfile; + +typedef struct Decycler Decycler; + +typedef struct DecyclerOscillator DecyclerOscillator; + +typedef struct Dema Dema; + +typedef struct DemandIndex DemandIndex; + +typedef struct DemarkPivots DemarkPivots; + +typedef struct DepthSlope DepthSlope; + +typedef struct DerivativeOscillator DerivativeOscillator; + +typedef struct DetrendedStdDev DetrendedStdDev; + +typedef struct DisparityIndex DisparityIndex; + +typedef struct DistanceSsd DistanceSsd; + +typedef struct Doji Doji; + +typedef struct DojiStar DojiStar; + +typedef struct DollarBars DollarBars; + +typedef struct Donchian Donchian; + +typedef struct DonchianStop DonchianStop; + +typedef struct DoubleBollinger DoubleBollinger; + +typedef struct DoubleTopBottom DoubleTopBottom; + +typedef struct DownsideGapThreeMethods DownsideGapThreeMethods; + +typedef struct Dpo Dpo; + +typedef struct DragonflyDoji DragonflyDoji; + +typedef struct DrawdownDuration DrawdownDuration; + +typedef struct DumplingTop DumplingTop; + +typedef struct Dx Dx; + +typedef struct DynamicMomentumIndex DynamicMomentumIndex; + +typedef struct EaseOfMovement EaseOfMovement; + +typedef struct EffectiveSpread EffectiveSpread; + +typedef struct EhlersStochastic EhlersStochastic; + +typedef struct Ehma Ehma; + +typedef struct ElderImpulse ElderImpulse; + +typedef struct ElderRay ElderRay; + +typedef struct ElderSafeZone ElderSafeZone; + +typedef struct Ema Ema; + +typedef struct EmpiricalModeDecomposition EmpiricalModeDecomposition; + +typedef struct Engulfing Engulfing; + +typedef struct Equivolume Equivolume; + +typedef struct EstimatedLeverageRatio EstimatedLeverageRatio; + +typedef struct EvenBetterSinewave EvenBetterSinewave; + +typedef struct EveningDojiStar EveningDojiStar; + +typedef struct Evwma Evwma; + +typedef struct EwmaVolatility EwmaVolatility; + +typedef struct Expectancy Expectancy; + +typedef struct FallingThreeMethods FallingThreeMethods; + +typedef struct Fama Fama; + +typedef struct FibArcs FibArcs; + +typedef struct FibChannel FibChannel; + +typedef struct FibConfluence FibConfluence; + +typedef struct FibExtension FibExtension; + +typedef struct FibFan FibFan; + +typedef struct FibProjection FibProjection; + +typedef struct FibRetracement FibRetracement; + +typedef struct FibTimeZones FibTimeZones; + +typedef struct FibonacciPivots FibonacciPivots; + +typedef struct FisherRsi FisherRsi; + +typedef struct FisherTransform FisherTransform; + +typedef struct FlagPennant FlagPennant; + +typedef struct Footprint Footprint; + +typedef struct ForceIndex ForceIndex; + +typedef struct FractalChaosBands FractalChaosBands; + +typedef struct Frama Frama; + +typedef struct FryPanBottom FryPanBottom; + +typedef struct FundingBasis FundingBasis; + +typedef struct FundingImpliedApr FundingImpliedApr; + +typedef struct FundingRate FundingRate; + +typedef struct FundingRateMean FundingRateMean; + +typedef struct FundingRateZScore FundingRateZScore; + +typedef struct GainLossRatio GainLossRatio; + +typedef struct GainToPainRatio GainToPainRatio; + +typedef struct GapSideBySideWhite GapSideBySideWhite; + +typedef struct Garch11 Garch11; + +typedef struct GarmanKlassVolatility GarmanKlassVolatility; + +typedef struct Gartley Gartley; + +typedef struct GatorOscillator GatorOscillator; + +typedef struct GeneralizedDema GeneralizedDema; + +typedef struct GeometricMa GeometricMa; + +typedef struct GoldenPocket GoldenPocket; + +typedef struct GrangerCausality GrangerCausality; + +typedef struct GravestoneDoji GravestoneDoji; + +typedef struct Hammer Hammer; + +typedef struct HangingMan HangingMan; + +typedef struct Harami Harami; + +typedef struct HaramiCross HaramiCross; + +typedef struct HasbrouckInformationShare HasbrouckInformationShare; + +typedef struct HeadAndShoulders HeadAndShoulders; + +typedef struct HeikinAshi HeikinAshi; + +typedef struct HeikinAshiOscillator HeikinAshiOscillator; + +typedef struct HiLoActivator HiLoActivator; + +typedef struct HighLowIndex HighLowIndex; + +typedef struct HighLowRange HighLowRange; + +typedef struct HighLowVolumeNodes HighLowVolumeNodes; + +typedef struct HighWave HighWave; + +typedef struct HighpassFilter HighpassFilter; + +typedef struct Hikkake Hikkake; + +typedef struct HikkakeModified HikkakeModified; + +typedef struct HilbertDominantCycle HilbertDominantCycle; + +typedef struct HistoricalVolatility HistoricalVolatility; + +typedef struct Hma Hma; + +typedef struct HoltWinters HoltWinters; + +typedef struct HomingPigeon HomingPigeon; + +typedef struct HtDcPhase HtDcPhase; + +typedef struct HtPhasor HtPhasor; + +typedef struct HtTrendMode HtTrendMode; + +typedef struct HurstChannel HurstChannel; + +typedef struct HurstExponent HurstExponent; + +typedef struct Ichimoku Ichimoku; + +typedef struct IdenticalThreeCrows IdenticalThreeCrows; + +typedef struct ImbalanceBars ImbalanceBars; + +typedef struct InNeck InNeck; + +typedef struct Inertia Inertia; + +typedef struct InformationRatio InformationRatio; + +typedef struct InitialBalance InitialBalance; + +typedef struct InstantaneousTrendline InstantaneousTrendline; + +typedef struct IntradayIntensity IntradayIntensity; + +typedef struct IntradayMomentumIndex IntradayMomentumIndex; + +typedef struct IntradayVolatilityProfile IntradayVolatilityProfile; + +typedef struct InverseFisherTransform InverseFisherTransform; + +typedef struct InvertedHammer InvertedHammer; + +typedef struct JarqueBera JarqueBera; + +typedef struct Jma Jma; + +typedef struct JumpIndicator JumpIndicator; + +typedef struct KRatio KRatio; + +typedef struct KagiBars KagiBars; + +typedef struct KalmanHedgeRatio KalmanHedgeRatio; + +typedef struct Kama Kama; + +typedef struct KaseDevStop KaseDevStop; + +typedef struct KasePermissionStochastic KasePermissionStochastic; + +typedef struct KellyCriterion KellyCriterion; + +typedef struct Keltner Keltner; + +typedef struct KendallTau KendallTau; + +typedef struct Kicking Kicking; + +typedef struct KickingByLength KickingByLength; + +typedef struct Kst Kst; + +typedef struct Kurtosis Kurtosis; + +typedef struct Kvo Kvo; + +typedef struct KylesLambda KylesLambda; + +typedef struct LadderBottom LadderBottom; + +typedef struct LaguerreRsi LaguerreRsi; + +typedef struct LeadLagCrossCorrelation LeadLagCrossCorrelation; + +typedef struct LinRegAngle LinRegAngle; + +typedef struct LinRegChannel LinRegChannel; + +typedef struct LinRegIntercept LinRegIntercept; + +typedef struct LinRegSlope LinRegSlope; + +typedef struct LinearRegression LinearRegression; + +typedef struct LiquidationFeatures LiquidationFeatures; + +typedef struct LogReturn LogReturn; + +typedef struct LongLeggedDoji LongLeggedDoji; + +typedef struct LongLine LongLine; + +typedef struct LongShortRatio LongShortRatio; + +typedef struct M2Measure M2Measure; + +typedef struct MaEnvelope MaEnvelope; + +typedef struct MacdExt MacdExt; + +typedef struct MacdFix MacdFix; + +typedef struct MacdHistogram MacdHistogram; + +typedef struct MacdIndicator MacdIndicator; + +typedef struct Mama Mama; + +typedef struct MarketFacilitationIndex MarketFacilitationIndex; + +typedef struct MartinRatio MartinRatio; + +typedef struct Marubozu Marubozu; + +typedef struct MassIndex MassIndex; + +typedef struct MatHold MatHold; + +typedef struct MatchingLow MatchingLow; + +typedef struct MaxDrawdown MaxDrawdown; + +typedef struct McClellanOscillator McClellanOscillator; + +typedef struct McClellanSummationIndex McClellanSummationIndex; + +typedef struct McGinleyDynamic McGinleyDynamic; + +typedef struct MedianAbsoluteDeviation MedianAbsoluteDeviation; + +typedef struct MedianChannel MedianChannel; + +typedef struct MedianMa MedianMa; + +typedef struct MedianPrice MedianPrice; + +typedef struct Mfi Mfi; + +typedef struct Microprice Microprice; + +typedef struct MidPoint MidPoint; + +typedef struct MidPrice MidPrice; + +typedef struct MinusDi MinusDi; + +typedef struct MinusDm MinusDm; + +typedef struct ModifiedMaStop ModifiedMaStop; + +typedef struct Mom Mom; + +typedef struct MorningDojiStar MorningDojiStar; + +typedef struct MorningEveningStar MorningEveningStar; + +typedef struct MurreyMathLines MurreyMathLines; + +typedef struct NakedPoc NakedPoc; + +typedef struct Natr Natr; + +typedef struct NewHighsNewLows NewHighsNewLows; + +typedef struct NewPriceLines NewPriceLines; + +typedef struct Nrtr Nrtr; + +typedef struct Nvi Nvi; + +typedef struct OIPriceDivergence OIPriceDivergence; + +typedef struct OIWeighted OIWeighted; + +typedef struct Obv Obv; + +typedef struct OiToVolumeRatio OiToVolumeRatio; + +typedef struct OmegaRatio OmegaRatio; + +typedef struct OnNeck OnNeck; + +typedef struct OpenInterestDelta OpenInterestDelta; + +typedef struct OpenInterestMomentum OpenInterestMomentum; + +typedef struct OpeningMarubozu OpeningMarubozu; + +typedef struct OpeningRange OpeningRange; + +typedef struct OrderBookImbalanceFull OrderBookImbalanceFull; + +typedef struct OrderBookImbalanceTop1 OrderBookImbalanceTop1; + +typedef struct OrderBookImbalanceTopN OrderBookImbalanceTopN; + +typedef struct OrderFlowImbalance OrderFlowImbalance; + +typedef struct OuHalfLife OuHalfLife; + +typedef struct OvernightGap OvernightGap; + +typedef struct OvernightIntradayReturn OvernightIntradayReturn; + +typedef struct PainIndex PainIndex; + +typedef struct PairSpreadZScore PairSpreadZScore; + +typedef struct PairwiseBeta PairwiseBeta; + +typedef struct ParkinsonVolatility ParkinsonVolatility; + +typedef struct PearsonCorrelation PearsonCorrelation; + +typedef struct PercentAboveMa PercentAboveMa; + +typedef struct PercentB PercentB; + +typedef struct PercentageTrailingStop PercentageTrailingStop; + +typedef struct PerpetualPremiumIndex PerpetualPremiumIndex; + +typedef struct Pgo Pgo; + +typedef struct PiercingDarkCloud PiercingDarkCloud; + +typedef struct Pin Pin; + +typedef struct PivotReversal PivotReversal; + +typedef struct PlusDi PlusDi; + +typedef struct PlusDm PlusDm; + +typedef struct Pmo Pmo; + +typedef struct PointAndFigureBars PointAndFigureBars; + +typedef struct PolarizedFractalEfficiency PolarizedFractalEfficiency; + +typedef struct Ppo Ppo; + +typedef struct PpoHistogram PpoHistogram; + +typedef struct ProfileShape ProfileShape; + +typedef struct ProfitFactor ProfitFactor; + +typedef struct ProjectionBands ProjectionBands; + +typedef struct ProjectionOscillator ProjectionOscillator; + +typedef struct Psar Psar; + +typedef struct Pvi Pvi; + +typedef struct Qqe Qqe; + +typedef struct Qstick Qstick; + +typedef struct QuartileBands QuartileBands; + +typedef struct QuotedSpread QuotedSpread; + +typedef struct RSquared RSquared; + +typedef struct RangeBars RangeBars; + +typedef struct RealizedSpread RealizedSpread; + +typedef struct RealizedVolatility RealizedVolatility; + +typedef struct RecoveryFactor RecoveryFactor; + +typedef struct RectangleRange RectangleRange; + +typedef struct Reflex Reflex; + +typedef struct RegimeLabel RegimeLabel; + +typedef struct RelativeStrengthAB RelativeStrengthAB; + +typedef struct RenkoBars RenkoBars; + +typedef struct RenkoTrailingStop RenkoTrailingStop; + +typedef struct RickshawMan RickshawMan; + +typedef struct RisingThreeMethods RisingThreeMethods; + +typedef struct Rmi Rmi; + +typedef struct Roc Roc; + +typedef struct Rocp Rocp; + +typedef struct Rocr Rocr; + +typedef struct Rocr100 Rocr100; + +typedef struct RogersSatchellVolatility RogersSatchellVolatility; + +typedef struct RollMeasure RollMeasure; + +typedef struct RollingCorrelation RollingCorrelation; + +typedef struct RollingCovariance RollingCovariance; + +typedef struct RollingIqr RollingIqr; + +typedef struct RollingMinMaxScaler RollingMinMaxScaler; + +typedef struct RollingPercentileRank RollingPercentileRank; + +typedef struct RollingQuantile RollingQuantile; + +typedef struct RollingVwap RollingVwap; + +typedef struct RoofingFilter RoofingFilter; + +typedef struct Rsi Rsi; + +typedef struct Rsx Rsx; + +typedef struct RunBars RunBars; + +typedef struct Rvi Rvi; + +typedef struct RviVolatility RviVolatility; + +typedef struct Rwi Rwi; + +typedef struct SampleEntropy SampleEntropy; + +typedef struct SarExt SarExt; + +typedef struct SeasonalZScore SeasonalZScore; + +typedef struct SeparatingLines SeparatingLines; + +typedef struct SessionHighLow SessionHighLow; + +typedef struct SessionRange SessionRange; + +typedef struct SessionVwap SessionVwap; + +typedef struct ShannonEntropy ShannonEntropy; + +typedef struct Shark Shark; + +typedef struct SharpeRatio SharpeRatio; + +typedef struct ShootingStar ShootingStar; + +typedef struct ShortLine ShortLine; + +typedef struct SignedVolume SignedVolume; + +typedef struct SineWave SineWave; + +typedef struct SineWeightedMa SineWeightedMa; + +typedef struct SinglePrints SinglePrints; + +typedef struct Skewness Skewness; + +typedef struct Sma Sma; + +typedef struct Smi Smi; + +typedef struct Smma Smma; + +typedef struct SmoothedHeikinAshi SmoothedHeikinAshi; + +typedef struct SortinoRatio SortinoRatio; + +typedef struct SpearmanCorrelation SpearmanCorrelation; + +typedef struct SpinningTop SpinningTop; + +typedef struct SpreadAr1Coefficient SpreadAr1Coefficient; + +typedef struct SpreadBollingerBands SpreadBollingerBands; + +typedef struct SpreadHurst SpreadHurst; + +typedef struct StalledPattern StalledPattern; + +typedef struct StandardError StandardError; + +typedef struct StandardErrorBands StandardErrorBands; + +typedef struct StarcBands StarcBands; + +typedef struct Stc Stc; + +typedef struct StdDev StdDev; + +typedef struct StepTrailingStop StepTrailingStop; + +typedef struct SterlingRatio SterlingRatio; + +typedef struct StickSandwich StickSandwich; + +typedef struct StochRsi StochRsi; + +typedef struct Stochastic Stochastic; + +typedef struct StochasticCci StochasticCci; + +typedef struct SuperSmoother SuperSmoother; + +typedef struct SuperTrend SuperTrend; + +typedef struct T3 T3; + +typedef struct TailRatio TailRatio; + +typedef struct TakerBuySellRatio TakerBuySellRatio; + +typedef struct Takuri Takuri; + +typedef struct TasukiGap TasukiGap; + +typedef struct TdCamouflage TdCamouflage; + +typedef struct TdClop TdClop; + +typedef struct TdClopwin TdClopwin; + +typedef struct TdCombo TdCombo; + +typedef struct TdCountdown TdCountdown; + +typedef struct TdDWave TdDWave; + +typedef struct TdDeMarker TdDeMarker; + +typedef struct TdDifferential TdDifferential; + +typedef struct TdLines TdLines; + +typedef struct TdMovingAverage TdMovingAverage; + +typedef struct TdOpen TdOpen; + +typedef struct TdPressure TdPressure; + +typedef struct TdPropulsion TdPropulsion; + +typedef struct TdRangeProjection TdRangeProjection; + +typedef struct TdRei TdRei; + +typedef struct TdRiskLevel TdRiskLevel; + +typedef struct TdSequential TdSequential; + +typedef struct TdSetup TdSetup; + +typedef struct TdTrap TdTrap; + +typedef struct Tema Tema; + +typedef struct TermStructureBasis TermStructureBasis; + +typedef struct ThreeDrives ThreeDrives; + +typedef struct ThreeInside ThreeInside; + +typedef struct ThreeLineBreak ThreeLineBreak; + +typedef struct ThreeLineBreakBars ThreeLineBreakBars; + +typedef struct ThreeLineStrike ThreeLineStrike; + +typedef struct ThreeOutside ThreeOutside; + +typedef struct ThreeSoldiersOrCrows ThreeSoldiersOrCrows; + +typedef struct ThreeStarsInSouth ThreeStarsInSouth; + +typedef struct Thrusting Thrusting; + +typedef struct TickBars TickBars; + +typedef struct TickIndex TickIndex; + +typedef struct Tii Tii; + +typedef struct TimeBasedStop TimeBasedStop; + +typedef struct TimeOfDayReturnProfile TimeOfDayReturnProfile; + +typedef struct TowerTopBottom TowerTopBottom; + +typedef struct TpoProfile TpoProfile; + +typedef struct TradeImbalance TradeImbalance; + +typedef struct TradeSignAutocorrelation TradeSignAutocorrelation; + +typedef struct TradeVolumeIndex TradeVolumeIndex; + +typedef struct TrendLabel TrendLabel; + +typedef struct TrendStrengthIndex TrendStrengthIndex; + +typedef struct Trendflex Trendflex; + +typedef struct TreynorRatio TreynorRatio; + +typedef struct Triangle Triangle; + +typedef struct Trima Trima; + +typedef struct Trin Trin; + +typedef struct TripleTopBottom TripleTopBottom; + +typedef struct Tristar Tristar; + +typedef struct Trix Trix; + +typedef struct TrueRange TrueRange; + +typedef struct Tsf Tsf; + +typedef struct TsfOscillator TsfOscillator; + +typedef struct Tsi Tsi; + +typedef struct Tsv Tsv; + +typedef struct TtmSqueeze TtmSqueeze; + +typedef struct TtmTrend TtmTrend; + +typedef struct TurnOfMonth TurnOfMonth; + +typedef struct Tweezer Tweezer; + +typedef struct TwiggsMoneyFlow TwiggsMoneyFlow; + +typedef struct TwoCrows TwoCrows; + +typedef struct TypicalPrice TypicalPrice; + +typedef struct UlcerIndex UlcerIndex; + +typedef struct UltimateOscillator UltimateOscillator; + +typedef struct UniqueThreeRiver UniqueThreeRiver; + +typedef struct UniversalOscillator UniversalOscillator; + +typedef struct UpDownVolumeRatio UpDownVolumeRatio; + +typedef struct UpsideGapThreeMethods UpsideGapThreeMethods; + +typedef struct UpsideGapTwoCrows UpsideGapTwoCrows; + +typedef struct UpsidePotentialRatio UpsidePotentialRatio; + +typedef struct ValueArea ValueArea; + +typedef struct ValueAtRisk ValueAtRisk; + +typedef struct Variance Variance; + +typedef struct VarianceRatio VarianceRatio; + +typedef struct VerticalHorizontalFilter VerticalHorizontalFilter; + +typedef struct Vidya Vidya; + +typedef struct VolatilityCone VolatilityCone; + +typedef struct VolatilityOfVolatility VolatilityOfVolatility; + +typedef struct VolatilityRatio VolatilityRatio; + +typedef struct VoltyStop VoltyStop; + +typedef struct VolumeBars VolumeBars; + +typedef struct VolumeByTimeProfile VolumeByTimeProfile; + +typedef struct VolumeOscillator VolumeOscillator; + +typedef struct VolumePriceTrend VolumePriceTrend; + +typedef struct VolumeProfile VolumeProfile; + +typedef struct VolumeRsi VolumeRsi; + +typedef struct VolumeWeightedMacd VolumeWeightedMacd; + +typedef struct VolumeWeightedSr VolumeWeightedSr; + +typedef struct Vortex Vortex; + +typedef struct Vpin Vpin; + +typedef struct Vwap Vwap; + +typedef struct VwapStdDevBands VwapStdDevBands; + +typedef struct Vwma Vwma; + +typedef struct Vzo Vzo; + +typedef struct Wad Wad; + +typedef struct WavePm WavePm; + +typedef struct WaveTrend WaveTrend; + +typedef struct Wedge Wedge; + +typedef struct WeightedClose WeightedClose; + +typedef struct WickRatio WickRatio; + +typedef struct WilliamsFractals WilliamsFractals; + +typedef struct WilliamsR WilliamsR; + +typedef struct WinRate WinRate; + +typedef struct Wma Wma; + +typedef struct WoodiePivots WoodiePivots; + +typedef struct YangZhangVolatility YangZhangVolatility; + +typedef struct YoyoExit YoyoExit; + +typedef struct ZScore ZScore; + +typedef struct ZeroLagMacd ZeroLagMacd; + +typedef struct ZigZag ZigZag; + +typedef struct Zlema Zlema; + +typedef struct WickraAccelerationBandsOutput { + double upper; + double middle; + double lower; +} WickraAccelerationBandsOutput; + +typedef struct WickraAdxOutput { + double plus_di; + double minus_di; + double adx; +} WickraAdxOutput; + +typedef struct WickraAlligatorOutput { + double jaw; + double teeth; + double lips; +} WickraAlligatorOutput; + +typedef struct WickraAndrewsPitchforkOutput { + double median; + double upper; + double lower; +} WickraAndrewsPitchforkOutput; + +typedef struct WickraAroonOutput { + double up; + double down; +} WickraAroonOutput; + +typedef struct WickraAtrBandsOutput { + double upper; + double middle; + double lower; +} WickraAtrBandsOutput; + +typedef struct WickraAtrRatchetOutput { + double value; + double direction; +} WickraAtrRatchetOutput; + +typedef struct WickraAutoFibOutput { + double level_0; + double level_236; + double level_382; + double level_500; + double level_618; + double level_786; + double level_1000; +} WickraAutoFibOutput; + +typedef struct WickraBollingerOutput { + double upper; + double middle; + double lower; + double stddev; +} WickraBollingerOutput; + +typedef struct WickraBomarBandsOutput { + double upper; + double middle; + double lower; +} WickraBomarBandsOutput; + +typedef struct WickraCamarillaPivotsOutput { + double pp; + double r1; + double r2; + double r3; + double r4; + double s1; + double s2; + double s3; + double s4; +} WickraCamarillaPivotsOutput; + +typedef struct WickraCandleVolumeOutput { + double body; + double width; +} WickraCandleVolumeOutput; + +typedef struct WickraCentralPivotRangeOutput { + double pivot; + double tc; + double bc; +} WickraCentralPivotRangeOutput; + +typedef struct WickraChandeKrollStopOutput { + double stop_long; + double stop_short; +} WickraChandeKrollStopOutput; + +typedef struct WickraChandelierExitOutput { + double long_stop; + double short_stop; +} WickraChandelierExitOutput; + +typedef struct WickraClassicPivotsOutput { + double pp; + double r1; + double r2; + double r3; + double s1; + double s2; + double s3; +} WickraClassicPivotsOutput; + +typedef struct WickraCointegrationOutput { + double hedge_ratio; + double spread; + double adf_stat; +} WickraCointegrationOutput; + +typedef struct WickraCompositeProfileOutput { + double poc; + double vah; + double val; +} WickraCompositeProfileOutput; + +typedef struct WickraDemarkPivotsOutput { + double pp; + double r1; + double s1; +} WickraDemarkPivotsOutput; + +typedef struct WickraDonchianOutput { + double upper; + double middle; + double lower; +} WickraDonchianOutput; + +typedef struct WickraDonchianStopOutput { + double stop_long; + double stop_short; +} WickraDonchianStopOutput; + +typedef struct WickraDoubleBollingerOutput { + double upper_outer; + double upper_inner; + double middle; + double lower_inner; + double lower_outer; +} WickraDoubleBollingerOutput; + +typedef struct WickraElderRayOutput { + double bull_power; + double bear_power; +} WickraElderRayOutput; + +typedef struct WickraElderSafeZoneOutput { + double value; + double direction; +} WickraElderSafeZoneOutput; + +typedef struct WickraEquivolumeOutput { + double height; + double width; +} WickraEquivolumeOutput; + +typedef struct WickraFibArcsOutput { + double arc_382; + double arc_500; + double arc_618; +} WickraFibArcsOutput; + +typedef struct WickraFibChannelOutput { + double base; + double level_618; + double level_1000; + double level_1618; +} WickraFibChannelOutput; + +typedef struct WickraFibConfluenceOutput { + double price; + double strength; +} WickraFibConfluenceOutput; + +typedef struct WickraFibExtensionOutput { + double level_1272; + double level_1414; + double level_1618; + double level_2000; + double level_2618; +} WickraFibExtensionOutput; + +typedef struct WickraFibFanOutput { + double fan_382; + double fan_500; + double fan_618; +} WickraFibFanOutput; + +typedef struct WickraFibProjectionOutput { + double level_618; + double level_1000; + double level_1618; + double level_2618; +} WickraFibProjectionOutput; + +typedef struct WickraFibRetracementOutput { + double level_0; + double level_236; + double level_382; + double level_500; + double level_618; + double level_786; + double level_1000; +} WickraFibRetracementOutput; + +typedef struct WickraFibTimeZonesOutput { + double on_zone; + double bars_to_next; +} WickraFibTimeZonesOutput; + +typedef struct WickraFibonacciPivotsOutput { + double pp; + double r1; + double r2; + double r3; + double s1; + double s2; + double s3; +} WickraFibonacciPivotsOutput; + +typedef struct WickraFractalChaosBandsOutput { + double upper; + double lower; +} WickraFractalChaosBandsOutput; + +typedef struct WickraGatorOscillatorOutput { + double upper; + double lower; +} WickraGatorOscillatorOutput; + +typedef struct WickraGoldenPocketOutput { + double low; + double mid; + double high; +} WickraGoldenPocketOutput; + +typedef struct WickraHeikinAshiOutput { + double open; + double high; + double low; + double close; +} WickraHeikinAshiOutput; + +typedef struct WickraHighLowVolumeNodesOutput { + double hvn; + double lvn; +} WickraHighLowVolumeNodesOutput; + +typedef struct WickraHtPhasorOutput { + double inphase; + double quadrature; +} WickraHtPhasorOutput; + +typedef struct WickraHurstChannelOutput { + double upper; + double middle; + double lower; +} WickraHurstChannelOutput; + +typedef struct WickraIchimokuOutput { + double tenkan; + double kijun; + double senkou_a; + double senkou_b; + double chikou; +} WickraIchimokuOutput; + +typedef struct WickraInitialBalanceOutput { + double high; + double low; +} WickraInitialBalanceOutput; + +typedef struct WickraKalmanHedgeRatioOutput { + double hedge_ratio; + double intercept; + double spread; +} WickraKalmanHedgeRatioOutput; + +typedef struct WickraKaseDevStopOutput { + double value; + double direction; +} WickraKaseDevStopOutput; + +typedef struct WickraKasePermissionStochasticOutput { + double fast; + double slow; +} WickraKasePermissionStochasticOutput; + +typedef struct WickraKeltnerOutput { + double upper; + double middle; + double lower; +} WickraKeltnerOutput; + +typedef struct WickraKstOutput { + double kst; + double signal; +} WickraKstOutput; + +typedef struct WickraLeadLagCrossCorrelationOutput { + int64_t lag; + double correlation; +} WickraLeadLagCrossCorrelationOutput; + +typedef struct WickraLinRegChannelOutput { + double upper; + double middle; + double lower; +} WickraLinRegChannelOutput; + +typedef struct WickraLiquidationFeaturesOutput { + double long_; + double short_; + double net; + double total; + double imbalance; +} WickraLiquidationFeaturesOutput; + +typedef struct WickraMaEnvelopeOutput { + double upper; + double middle; + double lower; +} WickraMaEnvelopeOutput; + +typedef struct WickraMacdOutput { + double macd; + double signal; + double histogram; +} WickraMacdOutput; + +typedef struct WickraMamaOutput { + double mama; + double fama; +} WickraMamaOutput; + +typedef struct WickraMedianChannelOutput { + double upper; + double middle; + double lower; +} WickraMedianChannelOutput; + +typedef struct WickraModifiedMaStopOutput { + double value; + double direction; +} WickraModifiedMaStopOutput; + +typedef struct WickraMurreyMathLinesOutput { + double mm8_8; + double mm7_8; + double mm6_8; + double mm5_8; + double mm4_8; + double mm3_8; + double mm2_8; + double mm1_8; + double mm0_8; +} WickraMurreyMathLinesOutput; + +typedef struct WickraNrtrOutput { + double value; + double direction; +} WickraNrtrOutput; + +typedef struct WickraOpeningRangeOutput { + double high; + double low; + double breakout_distance; +} WickraOpeningRangeOutput; + +typedef struct WickraOvernightIntradayReturnOutput { + double overnight; + double intraday; +} WickraOvernightIntradayReturnOutput; + +typedef struct WickraProjectionBandsOutput { + double upper; + double middle; + double lower; +} WickraProjectionBandsOutput; + +typedef struct WickraQqeOutput { + double rsi_ma; + double trailing_line; +} WickraQqeOutput; + +typedef struct WickraQuartileBandsOutput { + double upper; + double middle; + double lower; +} WickraQuartileBandsOutput; + +typedef struct WickraRelativeStrengthOutput { + double ratio; + double ratio_ma; + double ratio_rsi; +} WickraRelativeStrengthOutput; + +typedef struct WickraRwiOutput { + double high; + double low; +} WickraRwiOutput; + +typedef struct WickraSessionHighLowOutput { + double high; + double low; +} WickraSessionHighLowOutput; + +typedef struct WickraSessionRangeOutput { + double asia; + double eu; + double us; +} WickraSessionRangeOutput; + +typedef struct WickraSmoothedHeikinAshiOutput { + double open; + double high; + double low; + double close; +} WickraSmoothedHeikinAshiOutput; + +typedef struct WickraSpreadBollingerBandsOutput { + double middle; + double upper; + double lower; + double percent_b; +} WickraSpreadBollingerBandsOutput; + +typedef struct WickraStandardErrorBandsOutput { + double upper; + double middle; + double lower; +} WickraStandardErrorBandsOutput; + +typedef struct WickraStarcBandsOutput { + double upper; + double middle; + double lower; +} WickraStarcBandsOutput; + +typedef struct WickraStochasticOutput { + double k; + double d; +} WickraStochasticOutput; + +typedef struct WickraSuperTrendOutput { + double value; + double direction; +} WickraSuperTrendOutput; + +typedef struct WickraTdLinesOutput { + double resistance; + double support; +} WickraTdLinesOutput; + +typedef struct WickraTdMovingAverageOutput { + double st1; + double st2; +} WickraTdMovingAverageOutput; + +typedef struct WickraTdRangeProjectionOutput { + double high; + double low; +} WickraTdRangeProjectionOutput; + +typedef struct WickraTdRiskLevelOutput { + double buy_risk; + double sell_risk; +} WickraTdRiskLevelOutput; + +typedef struct WickraTdSequentialOutput { + double setup; + double countdown; + double direction; +} WickraTdSequentialOutput; + +typedef struct WickraTtmSqueezeOutput { + double squeeze; + double momentum; +} WickraTtmSqueezeOutput; + +typedef struct WickraValueAreaOutput { + double poc; + double vah; + double val; +} WickraValueAreaOutput; + +typedef struct WickraVolatilityConeOutput { + double current; + double min; + double median; + double max; + double percentile; +} WickraVolatilityConeOutput; + +typedef struct WickraVolumeWeightedMacdOutput { + double macd; + double signal; + double histogram; +} WickraVolumeWeightedMacdOutput; + +typedef struct WickraVolumeWeightedSrOutput { + double support; + double resistance; +} WickraVolumeWeightedSrOutput; + +typedef struct WickraVortexOutput { + double plus; + double minus; +} WickraVortexOutput; + +typedef struct WickraVwapStdDevBandsOutput { + double upper; + double middle; + double lower; + double stddev; +} WickraVwapStdDevBandsOutput; + +typedef struct WickraWaveTrendOutput { + double wt1; + double wt2; +} WickraWaveTrendOutput; + +typedef struct WickraWilliamsFractalsOutput { + double up; + double down; +} WickraWilliamsFractalsOutput; + +typedef struct WickraWoodiePivotsOutput { + double pp; + double r1; + double r2; + double s1; + double s2; +} WickraWoodiePivotsOutput; + +typedef struct WickraZeroLagMacdOutput { + double macd; + double signal; + double histogram; +} WickraZeroLagMacdOutput; + +typedef struct WickraZigZagOutput { + double swing; + double direction; +} WickraZigZagOutput; + +typedef struct WickraTpoProfileOutputScalars { + double price_low; + double price_high; +} WickraTpoProfileOutputScalars; + +typedef struct WickraVolumeProfileOutputScalars { + double price_low; + double price_high; +} WickraVolumeProfileOutputScalars; + +typedef struct WickraDollarBar { + double open; + double high; + double low; + double close; + double volume; + double dollar; +} WickraDollarBar; + +typedef struct WickraImbalanceBar { + double open; + double high; + double low; + double close; + double imbalance; + int8_t direction; +} WickraImbalanceBar; + +typedef struct WickraKagiBar { + double start; + double end; + int8_t direction; +} WickraKagiBar; + +typedef struct WickraPnfColumn { + int8_t direction; + double high; + double low; +} WickraPnfColumn; + +typedef struct WickraRangeBar { + double open; + double close; + int8_t direction; +} WickraRangeBar; + +typedef struct WickraRenkoBrick { + double open; + double close; + int8_t direction; +} WickraRenkoBrick; + +typedef struct WickraRunBar { + double open; + double high; + double low; + double close; + uintptr_t length; + int8_t direction; +} WickraRunBar; + +typedef struct WickraLineBreakBar { + double open; + double close; + int8_t direction; +} WickraLineBreakBar; + +typedef struct WickraTickBar { + double open; + double high; + double low; + double close; + double volume; +} WickraTickBar; + +typedef struct WickraVolumeBar { + double open; + double high; + double low; + double close; + double volume; +} WickraVolumeBar; + +typedef struct WickraFootprintLevel { + double price; + double bid_vol; + double ask_vol; +} WickraFootprintLevel; + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +struct AdaptiveCycle *wickra_adaptive_cycle_new(void); + +double wickra_adaptive_cycle_update(struct AdaptiveCycle *handle, double value); + +void wickra_adaptive_cycle_batch(struct AdaptiveCycle *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_adaptive_cycle_reset(struct AdaptiveCycle *handle); + +void wickra_adaptive_cycle_free(struct AdaptiveCycle *handle); + +struct AdaptiveLaguerreFilter *wickra_adaptive_laguerre_filter_new(uintptr_t period); + +double wickra_adaptive_laguerre_filter_update(struct AdaptiveLaguerreFilter *handle, double value); + +void wickra_adaptive_laguerre_filter_batch(struct AdaptiveLaguerreFilter *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_adaptive_laguerre_filter_reset(struct AdaptiveLaguerreFilter *handle); + +void wickra_adaptive_laguerre_filter_free(struct AdaptiveLaguerreFilter *handle); + +struct AdaptiveRsi *wickra_adaptive_rsi_new(uintptr_t period); + +double wickra_adaptive_rsi_update(struct AdaptiveRsi *handle, double value); + +void wickra_adaptive_rsi_batch(struct AdaptiveRsi *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_adaptive_rsi_reset(struct AdaptiveRsi *handle); + +void wickra_adaptive_rsi_free(struct AdaptiveRsi *handle); + +struct Alma *wickra_alma_new(uintptr_t period, double offset, double sigma); + +double wickra_alma_update(struct Alma *handle, double value); + +void wickra_alma_batch(struct Alma *handle, const double *input, double *out, uintptr_t n); + +void wickra_alma_reset(struct Alma *handle); + +void wickra_alma_free(struct Alma *handle); + +struct AnchoredRsi *wickra_anchored_rsi_new(void); + +double wickra_anchored_rsi_update(struct AnchoredRsi *handle, double value); + +void wickra_anchored_rsi_batch(struct AnchoredRsi *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_anchored_rsi_reset(struct AnchoredRsi *handle); + +void wickra_anchored_rsi_free(struct AnchoredRsi *handle); + +struct Apo *wickra_apo_new(uintptr_t fast, uintptr_t slow); + +double wickra_apo_update(struct Apo *handle, double value); + +void wickra_apo_batch(struct Apo *handle, const double *input, double *out, uintptr_t n); + +void wickra_apo_reset(struct Apo *handle); + +void wickra_apo_free(struct Apo *handle); + +struct Autocorrelation *wickra_autocorrelation_new(uintptr_t period, uintptr_t lag); + +double wickra_autocorrelation_update(struct Autocorrelation *handle, double value); + +void wickra_autocorrelation_batch(struct Autocorrelation *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_autocorrelation_reset(struct Autocorrelation *handle); + +void wickra_autocorrelation_free(struct Autocorrelation *handle); + +struct AutocorrelationPeriodogram *wickra_autocorrelation_periodogram_new(uintptr_t min_period, + uintptr_t max_period); + +double wickra_autocorrelation_periodogram_update(struct AutocorrelationPeriodogram *handle, + double value); + +void wickra_autocorrelation_periodogram_batch(struct AutocorrelationPeriodogram *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_autocorrelation_periodogram_reset(struct AutocorrelationPeriodogram *handle); + +void wickra_autocorrelation_periodogram_free(struct AutocorrelationPeriodogram *handle); + +struct AverageDrawdown *wickra_average_drawdown_new(uintptr_t period); + +double wickra_average_drawdown_update(struct AverageDrawdown *handle, double value); + +void wickra_average_drawdown_batch(struct AverageDrawdown *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_average_drawdown_reset(struct AverageDrawdown *handle); + +void wickra_average_drawdown_free(struct AverageDrawdown *handle); + +struct BandpassFilter *wickra_bandpass_filter_new(uintptr_t period, double bandwidth); + +double wickra_bandpass_filter_update(struct BandpassFilter *handle, double value); + +void wickra_bandpass_filter_batch(struct BandpassFilter *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_bandpass_filter_reset(struct BandpassFilter *handle); + +void wickra_bandpass_filter_free(struct BandpassFilter *handle); + +struct BipowerVariation *wickra_bipower_variation_new(uintptr_t period); + +double wickra_bipower_variation_update(struct BipowerVariation *handle, double value); + +void wickra_bipower_variation_batch(struct BipowerVariation *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_bipower_variation_reset(struct BipowerVariation *handle); + +void wickra_bipower_variation_free(struct BipowerVariation *handle); + +struct BollingerBandwidth *wickra_bollinger_bandwidth_new(uintptr_t period, double multiplier); + +double wickra_bollinger_bandwidth_update(struct BollingerBandwidth *handle, double value); + +void wickra_bollinger_bandwidth_batch(struct BollingerBandwidth *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_bollinger_bandwidth_reset(struct BollingerBandwidth *handle); + +void wickra_bollinger_bandwidth_free(struct BollingerBandwidth *handle); + +struct BurkeRatio *wickra_burke_ratio_new(uintptr_t period); + +double wickra_burke_ratio_update(struct BurkeRatio *handle, double value); + +void wickra_burke_ratio_batch(struct BurkeRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_burke_ratio_reset(struct BurkeRatio *handle); + +void wickra_burke_ratio_free(struct BurkeRatio *handle); + +struct CalmarRatio *wickra_calmar_ratio_new(uintptr_t period); + +double wickra_calmar_ratio_update(struct CalmarRatio *handle, double value); + +void wickra_calmar_ratio_batch(struct CalmarRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_calmar_ratio_reset(struct CalmarRatio *handle); + +void wickra_calmar_ratio_free(struct CalmarRatio *handle); + +struct CenterOfGravity *wickra_center_of_gravity_new(uintptr_t period); + +double wickra_center_of_gravity_update(struct CenterOfGravity *handle, double value); + +void wickra_center_of_gravity_batch(struct CenterOfGravity *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_center_of_gravity_reset(struct CenterOfGravity *handle); + +void wickra_center_of_gravity_free(struct CenterOfGravity *handle); + +struct Cfo *wickra_cfo_new(uintptr_t period); + +double wickra_cfo_update(struct Cfo *handle, double value); + +void wickra_cfo_batch(struct Cfo *handle, const double *input, double *out, uintptr_t n); + +void wickra_cfo_reset(struct Cfo *handle); + +void wickra_cfo_free(struct Cfo *handle); + +struct Cmo *wickra_cmo_new(uintptr_t period); + +double wickra_cmo_update(struct Cmo *handle, double value); + +void wickra_cmo_batch(struct Cmo *handle, const double *input, double *out, uintptr_t n); + +void wickra_cmo_reset(struct Cmo *handle); + +void wickra_cmo_free(struct Cmo *handle); + +struct CoefficientOfVariation *wickra_coefficient_of_variation_new(uintptr_t period); + +double wickra_coefficient_of_variation_update(struct CoefficientOfVariation *handle, double value); + +void wickra_coefficient_of_variation_batch(struct CoefficientOfVariation *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_coefficient_of_variation_reset(struct CoefficientOfVariation *handle); + +void wickra_coefficient_of_variation_free(struct CoefficientOfVariation *handle); + +struct CommonSenseRatio *wickra_common_sense_ratio_new(uintptr_t period); + +double wickra_common_sense_ratio_update(struct CommonSenseRatio *handle, double value); + +void wickra_common_sense_ratio_batch(struct CommonSenseRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_common_sense_ratio_reset(struct CommonSenseRatio *handle); + +void wickra_common_sense_ratio_free(struct CommonSenseRatio *handle); + +struct ConditionalValueAtRisk *wickra_conditional_value_at_risk_new(uintptr_t period, + double confidence); + +double wickra_conditional_value_at_risk_update(struct ConditionalValueAtRisk *handle, double value); + +void wickra_conditional_value_at_risk_batch(struct ConditionalValueAtRisk *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_conditional_value_at_risk_reset(struct ConditionalValueAtRisk *handle); + +void wickra_conditional_value_at_risk_free(struct ConditionalValueAtRisk *handle); + +struct ConnorsRsi *wickra_connors_rsi_new(uintptr_t period_rsi, + uintptr_t period_streak, + uintptr_t period_rank); + +double wickra_connors_rsi_update(struct ConnorsRsi *handle, double value); + +void wickra_connors_rsi_batch(struct ConnorsRsi *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_connors_rsi_reset(struct ConnorsRsi *handle); + +void wickra_connors_rsi_free(struct ConnorsRsi *handle); + +struct Coppock *wickra_coppock_new(uintptr_t roc_long_period, + uintptr_t roc_short_period, + uintptr_t wma_period); + +double wickra_coppock_update(struct Coppock *handle, double value); + +void wickra_coppock_batch(struct Coppock *handle, const double *input, double *out, uintptr_t n); + +void wickra_coppock_reset(struct Coppock *handle); + +void wickra_coppock_free(struct Coppock *handle); + +struct CorrelationTrendIndicator *wickra_correlation_trend_indicator_new(uintptr_t period); + +double wickra_correlation_trend_indicator_update(struct CorrelationTrendIndicator *handle, + double value); + +void wickra_correlation_trend_indicator_batch(struct CorrelationTrendIndicator *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_correlation_trend_indicator_reset(struct CorrelationTrendIndicator *handle); + +void wickra_correlation_trend_indicator_free(struct CorrelationTrendIndicator *handle); + +struct CyberneticCycle *wickra_cybernetic_cycle_new(uintptr_t period); + +double wickra_cybernetic_cycle_update(struct CyberneticCycle *handle, double value); + +void wickra_cybernetic_cycle_batch(struct CyberneticCycle *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_cybernetic_cycle_reset(struct CyberneticCycle *handle); + +void wickra_cybernetic_cycle_free(struct CyberneticCycle *handle); + +struct Decycler *wickra_decycler_new(uintptr_t period); + +double wickra_decycler_update(struct Decycler *handle, double value); + +void wickra_decycler_batch(struct Decycler *handle, const double *input, double *out, uintptr_t n); + +void wickra_decycler_reset(struct Decycler *handle); + +void wickra_decycler_free(struct Decycler *handle); + +struct DecyclerOscillator *wickra_decycler_oscillator_new(uintptr_t fast, uintptr_t slow); + +double wickra_decycler_oscillator_update(struct DecyclerOscillator *handle, double value); + +void wickra_decycler_oscillator_batch(struct DecyclerOscillator *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_decycler_oscillator_reset(struct DecyclerOscillator *handle); + +void wickra_decycler_oscillator_free(struct DecyclerOscillator *handle); + +struct Dema *wickra_dema_new(uintptr_t period); + +double wickra_dema_update(struct Dema *handle, double value); + +void wickra_dema_batch(struct Dema *handle, const double *input, double *out, uintptr_t n); + +void wickra_dema_reset(struct Dema *handle); + +void wickra_dema_free(struct Dema *handle); + +struct DerivativeOscillator *wickra_derivative_oscillator_new(uintptr_t rsi_period, + uintptr_t smooth1, + uintptr_t smooth2, + uintptr_t signal_period); + +double wickra_derivative_oscillator_update(struct DerivativeOscillator *handle, double value); + +void wickra_derivative_oscillator_batch(struct DerivativeOscillator *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_derivative_oscillator_reset(struct DerivativeOscillator *handle); + +void wickra_derivative_oscillator_free(struct DerivativeOscillator *handle); + +struct DetrendedStdDev *wickra_detrended_std_dev_new(uintptr_t period); + +double wickra_detrended_std_dev_update(struct DetrendedStdDev *handle, double value); + +void wickra_detrended_std_dev_batch(struct DetrendedStdDev *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_detrended_std_dev_reset(struct DetrendedStdDev *handle); + +void wickra_detrended_std_dev_free(struct DetrendedStdDev *handle); + +struct DisparityIndex *wickra_disparity_index_new(uintptr_t period); + +double wickra_disparity_index_update(struct DisparityIndex *handle, double value); + +void wickra_disparity_index_batch(struct DisparityIndex *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_disparity_index_reset(struct DisparityIndex *handle); + +void wickra_disparity_index_free(struct DisparityIndex *handle); + +struct Dpo *wickra_dpo_new(uintptr_t period); + +double wickra_dpo_update(struct Dpo *handle, double value); + +void wickra_dpo_batch(struct Dpo *handle, const double *input, double *out, uintptr_t n); + +void wickra_dpo_reset(struct Dpo *handle); + +void wickra_dpo_free(struct Dpo *handle); + +struct DrawdownDuration *wickra_drawdown_duration_new(void); + +double wickra_drawdown_duration_update(struct DrawdownDuration *handle, double value); + +void wickra_drawdown_duration_batch(struct DrawdownDuration *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_drawdown_duration_reset(struct DrawdownDuration *handle); + +void wickra_drawdown_duration_free(struct DrawdownDuration *handle); + +struct DynamicMomentumIndex *wickra_dynamic_momentum_index_new(uintptr_t period); + +double wickra_dynamic_momentum_index_update(struct DynamicMomentumIndex *handle, double value); + +void wickra_dynamic_momentum_index_batch(struct DynamicMomentumIndex *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_dynamic_momentum_index_reset(struct DynamicMomentumIndex *handle); + +void wickra_dynamic_momentum_index_free(struct DynamicMomentumIndex *handle); + +struct EhlersStochastic *wickra_ehlers_stochastic_new(uintptr_t period); + +double wickra_ehlers_stochastic_update(struct EhlersStochastic *handle, double value); + +void wickra_ehlers_stochastic_batch(struct EhlersStochastic *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_ehlers_stochastic_reset(struct EhlersStochastic *handle); + +void wickra_ehlers_stochastic_free(struct EhlersStochastic *handle); + +struct Ehma *wickra_ehma_new(uintptr_t period); + +double wickra_ehma_update(struct Ehma *handle, double value); + +void wickra_ehma_batch(struct Ehma *handle, const double *input, double *out, uintptr_t n); + +void wickra_ehma_reset(struct Ehma *handle); + +void wickra_ehma_free(struct Ehma *handle); + +struct ElderImpulse *wickra_elder_impulse_new(uintptr_t ema_period, + uintptr_t macd_fast, + uintptr_t macd_slow, + uintptr_t macd_signal); + +double wickra_elder_impulse_update(struct ElderImpulse *handle, double value); + +void wickra_elder_impulse_batch(struct ElderImpulse *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_elder_impulse_reset(struct ElderImpulse *handle); + +void wickra_elder_impulse_free(struct ElderImpulse *handle); + +struct Ema *wickra_ema_new(uintptr_t period); + +double wickra_ema_update(struct Ema *handle, double value); + +void wickra_ema_batch(struct Ema *handle, const double *input, double *out, uintptr_t n); + +void wickra_ema_reset(struct Ema *handle); + +void wickra_ema_free(struct Ema *handle); + +struct EmpiricalModeDecomposition *wickra_empirical_mode_decomposition_new(uintptr_t period, + double fraction); + +double wickra_empirical_mode_decomposition_update(struct EmpiricalModeDecomposition *handle, + double value); + +void wickra_empirical_mode_decomposition_batch(struct EmpiricalModeDecomposition *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_empirical_mode_decomposition_reset(struct EmpiricalModeDecomposition *handle); + +void wickra_empirical_mode_decomposition_free(struct EmpiricalModeDecomposition *handle); + +struct EvenBetterSinewave *wickra_even_better_sinewave_new(uintptr_t hp_period, + uintptr_t ssf_length); + +double wickra_even_better_sinewave_update(struct EvenBetterSinewave *handle, double value); + +void wickra_even_better_sinewave_batch(struct EvenBetterSinewave *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_even_better_sinewave_reset(struct EvenBetterSinewave *handle); + +void wickra_even_better_sinewave_free(struct EvenBetterSinewave *handle); + +struct EwmaVolatility *wickra_ewma_volatility_new(double lambda); + +double wickra_ewma_volatility_update(struct EwmaVolatility *handle, double value); + +void wickra_ewma_volatility_batch(struct EwmaVolatility *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_ewma_volatility_reset(struct EwmaVolatility *handle); + +void wickra_ewma_volatility_free(struct EwmaVolatility *handle); + +struct Expectancy *wickra_expectancy_new(uintptr_t period); + +double wickra_expectancy_update(struct Expectancy *handle, double value); + +void wickra_expectancy_batch(struct Expectancy *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_expectancy_reset(struct Expectancy *handle); + +void wickra_expectancy_free(struct Expectancy *handle); + +struct Fama *wickra_fama_new(double fast_limit, double slow_limit); + +double wickra_fama_update(struct Fama *handle, double value); + +void wickra_fama_batch(struct Fama *handle, const double *input, double *out, uintptr_t n); + +void wickra_fama_reset(struct Fama *handle); + +void wickra_fama_free(struct Fama *handle); + +struct FisherRsi *wickra_fisher_rsi_new(uintptr_t period); + +double wickra_fisher_rsi_update(struct FisherRsi *handle, double value); + +void wickra_fisher_rsi_batch(struct FisherRsi *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_fisher_rsi_reset(struct FisherRsi *handle); + +void wickra_fisher_rsi_free(struct FisherRsi *handle); + +struct FisherTransform *wickra_fisher_transform_new(uintptr_t period); + +double wickra_fisher_transform_update(struct FisherTransform *handle, double value); + +void wickra_fisher_transform_batch(struct FisherTransform *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_fisher_transform_reset(struct FisherTransform *handle); + +void wickra_fisher_transform_free(struct FisherTransform *handle); + +struct Frama *wickra_frama_new(uintptr_t period); + +double wickra_frama_update(struct Frama *handle, double value); + +void wickra_frama_batch(struct Frama *handle, const double *input, double *out, uintptr_t n); + +void wickra_frama_reset(struct Frama *handle); + +void wickra_frama_free(struct Frama *handle); + +struct GainLossRatio *wickra_gain_loss_ratio_new(uintptr_t period); + +double wickra_gain_loss_ratio_update(struct GainLossRatio *handle, double value); + +void wickra_gain_loss_ratio_batch(struct GainLossRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_gain_loss_ratio_reset(struct GainLossRatio *handle); + +void wickra_gain_loss_ratio_free(struct GainLossRatio *handle); + +struct GainToPainRatio *wickra_gain_to_pain_ratio_new(uintptr_t period); + +double wickra_gain_to_pain_ratio_update(struct GainToPainRatio *handle, double value); + +void wickra_gain_to_pain_ratio_batch(struct GainToPainRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_gain_to_pain_ratio_reset(struct GainToPainRatio *handle); + +void wickra_gain_to_pain_ratio_free(struct GainToPainRatio *handle); + +struct Garch11 *wickra_garch11_new(double omega, double alpha, double beta); + +double wickra_garch11_update(struct Garch11 *handle, double value); + +void wickra_garch11_batch(struct Garch11 *handle, const double *input, double *out, uintptr_t n); + +void wickra_garch11_reset(struct Garch11 *handle); + +void wickra_garch11_free(struct Garch11 *handle); + +struct GeneralizedDema *wickra_generalized_dema_new(uintptr_t period, double v); + +double wickra_generalized_dema_update(struct GeneralizedDema *handle, double value); + +void wickra_generalized_dema_batch(struct GeneralizedDema *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_generalized_dema_reset(struct GeneralizedDema *handle); + +void wickra_generalized_dema_free(struct GeneralizedDema *handle); + +struct GeometricMa *wickra_geometric_ma_new(uintptr_t period); + +double wickra_geometric_ma_update(struct GeometricMa *handle, double value); + +void wickra_geometric_ma_batch(struct GeometricMa *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_geometric_ma_reset(struct GeometricMa *handle); + +void wickra_geometric_ma_free(struct GeometricMa *handle); + +struct HighpassFilter *wickra_highpass_filter_new(uintptr_t period); + +double wickra_highpass_filter_update(struct HighpassFilter *handle, double value); + +void wickra_highpass_filter_batch(struct HighpassFilter *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_highpass_filter_reset(struct HighpassFilter *handle); + +void wickra_highpass_filter_free(struct HighpassFilter *handle); + +struct HilbertDominantCycle *wickra_hilbert_dominant_cycle_new(void); + +double wickra_hilbert_dominant_cycle_update(struct HilbertDominantCycle *handle, double value); + +void wickra_hilbert_dominant_cycle_batch(struct HilbertDominantCycle *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_hilbert_dominant_cycle_reset(struct HilbertDominantCycle *handle); + +void wickra_hilbert_dominant_cycle_free(struct HilbertDominantCycle *handle); + +struct HistoricalVolatility *wickra_historical_volatility_new(uintptr_t period, + uintptr_t trading_periods); + +double wickra_historical_volatility_update(struct HistoricalVolatility *handle, double value); + +void wickra_historical_volatility_batch(struct HistoricalVolatility *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_historical_volatility_reset(struct HistoricalVolatility *handle); + +void wickra_historical_volatility_free(struct HistoricalVolatility *handle); + +struct Hma *wickra_hma_new(uintptr_t period); + +double wickra_hma_update(struct Hma *handle, double value); + +void wickra_hma_batch(struct Hma *handle, const double *input, double *out, uintptr_t n); + +void wickra_hma_reset(struct Hma *handle); + +void wickra_hma_free(struct Hma *handle); + +struct HoltWinters *wickra_holt_winters_new(double alpha, double beta); + +double wickra_holt_winters_update(struct HoltWinters *handle, double value); + +void wickra_holt_winters_batch(struct HoltWinters *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_holt_winters_reset(struct HoltWinters *handle); + +void wickra_holt_winters_free(struct HoltWinters *handle); + +struct HtDcPhase *wickra_ht_dc_phase_new(void); + +double wickra_ht_dc_phase_update(struct HtDcPhase *handle, double value); + +void wickra_ht_dc_phase_batch(struct HtDcPhase *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_ht_dc_phase_reset(struct HtDcPhase *handle); + +void wickra_ht_dc_phase_free(struct HtDcPhase *handle); + +struct HtTrendMode *wickra_ht_trend_mode_new(void); + +double wickra_ht_trend_mode_update(struct HtTrendMode *handle, double value); + +void wickra_ht_trend_mode_batch(struct HtTrendMode *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_ht_trend_mode_reset(struct HtTrendMode *handle); + +void wickra_ht_trend_mode_free(struct HtTrendMode *handle); + +struct HurstExponent *wickra_hurst_exponent_new(uintptr_t period, uintptr_t chunks); + +double wickra_hurst_exponent_update(struct HurstExponent *handle, double value); + +void wickra_hurst_exponent_batch(struct HurstExponent *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_hurst_exponent_reset(struct HurstExponent *handle); + +void wickra_hurst_exponent_free(struct HurstExponent *handle); + +struct InstantaneousTrendline *wickra_instantaneous_trendline_new(uintptr_t period); + +double wickra_instantaneous_trendline_update(struct InstantaneousTrendline *handle, double value); + +void wickra_instantaneous_trendline_batch(struct InstantaneousTrendline *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_instantaneous_trendline_reset(struct InstantaneousTrendline *handle); + +void wickra_instantaneous_trendline_free(struct InstantaneousTrendline *handle); + +struct InverseFisherTransform *wickra_inverse_fisher_transform_new(double scale); + +double wickra_inverse_fisher_transform_update(struct InverseFisherTransform *handle, double value); + +void wickra_inverse_fisher_transform_batch(struct InverseFisherTransform *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_inverse_fisher_transform_reset(struct InverseFisherTransform *handle); + +void wickra_inverse_fisher_transform_free(struct InverseFisherTransform *handle); + +struct JarqueBera *wickra_jarque_bera_new(uintptr_t period); + +double wickra_jarque_bera_update(struct JarqueBera *handle, double value); + +void wickra_jarque_bera_batch(struct JarqueBera *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_jarque_bera_reset(struct JarqueBera *handle); + +void wickra_jarque_bera_free(struct JarqueBera *handle); + +struct Jma *wickra_jma_new(uintptr_t period, double phase, uint32_t power); + +double wickra_jma_update(struct Jma *handle, double value); + +void wickra_jma_batch(struct Jma *handle, const double *input, double *out, uintptr_t n); + +void wickra_jma_reset(struct Jma *handle); + +void wickra_jma_free(struct Jma *handle); + +struct JumpIndicator *wickra_jump_indicator_new(uintptr_t period, double threshold); + +double wickra_jump_indicator_update(struct JumpIndicator *handle, double value); + +void wickra_jump_indicator_batch(struct JumpIndicator *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_jump_indicator_reset(struct JumpIndicator *handle); + +void wickra_jump_indicator_free(struct JumpIndicator *handle); + +struct KRatio *wickra_k_ratio_new(uintptr_t period); + +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); + +void wickra_k_ratio_reset(struct KRatio *handle); + +void wickra_k_ratio_free(struct KRatio *handle); + +struct Kama *wickra_kama_new(uintptr_t er_period, uintptr_t fast, uintptr_t slow); + +double wickra_kama_update(struct Kama *handle, double value); + +void wickra_kama_batch(struct Kama *handle, const double *input, double *out, uintptr_t n); + +void wickra_kama_reset(struct Kama *handle); + +void wickra_kama_free(struct Kama *handle); + +struct KellyCriterion *wickra_kelly_criterion_new(uintptr_t period); + +double wickra_kelly_criterion_update(struct KellyCriterion *handle, double value); + +void wickra_kelly_criterion_batch(struct KellyCriterion *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_kelly_criterion_reset(struct KellyCriterion *handle); + +void wickra_kelly_criterion_free(struct KellyCriterion *handle); + +struct Kurtosis *wickra_kurtosis_new(uintptr_t period); + +double wickra_kurtosis_update(struct Kurtosis *handle, double value); + +void wickra_kurtosis_batch(struct Kurtosis *handle, const double *input, double *out, uintptr_t n); + +void wickra_kurtosis_reset(struct Kurtosis *handle); + +void wickra_kurtosis_free(struct Kurtosis *handle); + +struct LaguerreRsi *wickra_laguerre_rsi_new(double gamma); + +double wickra_laguerre_rsi_update(struct LaguerreRsi *handle, double value); + +void wickra_laguerre_rsi_batch(struct LaguerreRsi *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_laguerre_rsi_reset(struct LaguerreRsi *handle); + +void wickra_laguerre_rsi_free(struct LaguerreRsi *handle); + +struct LinearRegression *wickra_linear_regression_new(uintptr_t period); + +double wickra_linear_regression_update(struct LinearRegression *handle, double value); + +void wickra_linear_regression_batch(struct LinearRegression *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_linear_regression_reset(struct LinearRegression *handle); + +void wickra_linear_regression_free(struct LinearRegression *handle); + +struct LinRegAngle *wickra_lin_reg_angle_new(uintptr_t period); + +double wickra_lin_reg_angle_update(struct LinRegAngle *handle, double value); + +void wickra_lin_reg_angle_batch(struct LinRegAngle *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_lin_reg_angle_reset(struct LinRegAngle *handle); + +void wickra_lin_reg_angle_free(struct LinRegAngle *handle); + +struct LinRegIntercept *wickra_lin_reg_intercept_new(uintptr_t period); + +double wickra_lin_reg_intercept_update(struct LinRegIntercept *handle, double value); + +void wickra_lin_reg_intercept_batch(struct LinRegIntercept *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_lin_reg_intercept_reset(struct LinRegIntercept *handle); + +void wickra_lin_reg_intercept_free(struct LinRegIntercept *handle); + +struct LinRegSlope *wickra_lin_reg_slope_new(uintptr_t period); + +double wickra_lin_reg_slope_update(struct LinRegSlope *handle, double value); + +void wickra_lin_reg_slope_batch(struct LinRegSlope *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_lin_reg_slope_reset(struct LinRegSlope *handle); + +void wickra_lin_reg_slope_free(struct LinRegSlope *handle); + +struct LogReturn *wickra_log_return_new(uintptr_t period); + +double wickra_log_return_update(struct LogReturn *handle, double value); + +void wickra_log_return_batch(struct LogReturn *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_log_return_reset(struct LogReturn *handle); + +void wickra_log_return_free(struct LogReturn *handle); + +struct M2Measure *wickra_m2_measure_new(uintptr_t period, + double risk_free, + double benchmark_stddev); + +double wickra_m2_measure_update(struct M2Measure *handle, double value); + +void wickra_m2_measure_batch(struct M2Measure *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_m2_measure_reset(struct M2Measure *handle); + +void wickra_m2_measure_free(struct M2Measure *handle); + +struct MacdHistogram *wickra_macd_histogram_new(uintptr_t fast, uintptr_t slow, uintptr_t signal); + +double wickra_macd_histogram_update(struct MacdHistogram *handle, double value); + +void wickra_macd_histogram_batch(struct MacdHistogram *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_macd_histogram_reset(struct MacdHistogram *handle); + +void wickra_macd_histogram_free(struct MacdHistogram *handle); + +struct MartinRatio *wickra_martin_ratio_new(uintptr_t period); + +double wickra_martin_ratio_update(struct MartinRatio *handle, double value); + +void wickra_martin_ratio_batch(struct MartinRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_martin_ratio_reset(struct MartinRatio *handle); + +void wickra_martin_ratio_free(struct MartinRatio *handle); + +struct MaxDrawdown *wickra_max_drawdown_new(uintptr_t period); + +double wickra_max_drawdown_update(struct MaxDrawdown *handle, double value); + +void wickra_max_drawdown_batch(struct MaxDrawdown *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_max_drawdown_reset(struct MaxDrawdown *handle); + +void wickra_max_drawdown_free(struct MaxDrawdown *handle); + +struct McGinleyDynamic *wickra_mc_ginley_dynamic_new(uintptr_t period); + +double wickra_mc_ginley_dynamic_update(struct McGinleyDynamic *handle, double value); + +void wickra_mc_ginley_dynamic_batch(struct McGinleyDynamic *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_mc_ginley_dynamic_reset(struct McGinleyDynamic *handle); + +void wickra_mc_ginley_dynamic_free(struct McGinleyDynamic *handle); + +struct MedianAbsoluteDeviation *wickra_median_absolute_deviation_new(uintptr_t period); + +double wickra_median_absolute_deviation_update(struct MedianAbsoluteDeviation *handle, + double value); + +void wickra_median_absolute_deviation_batch(struct MedianAbsoluteDeviation *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_median_absolute_deviation_reset(struct MedianAbsoluteDeviation *handle); + +void wickra_median_absolute_deviation_free(struct MedianAbsoluteDeviation *handle); + +struct MedianMa *wickra_median_ma_new(uintptr_t period); + +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); + +void wickra_median_ma_reset(struct MedianMa *handle); + +void wickra_median_ma_free(struct MedianMa *handle); + +struct MidPoint *wickra_mid_point_new(uintptr_t period); + +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); + +void wickra_mid_point_reset(struct MidPoint *handle); + +void wickra_mid_point_free(struct MidPoint *handle); + +struct Mom *wickra_mom_new(uintptr_t period); + +double wickra_mom_update(struct Mom *handle, double value); + +void wickra_mom_batch(struct Mom *handle, const double *input, double *out, uintptr_t n); + +void wickra_mom_reset(struct Mom *handle); + +void wickra_mom_free(struct Mom *handle); + +struct OmegaRatio *wickra_omega_ratio_new(uintptr_t period, double threshold); + +double wickra_omega_ratio_update(struct OmegaRatio *handle, double value); + +void wickra_omega_ratio_batch(struct OmegaRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_omega_ratio_reset(struct OmegaRatio *handle); + +void wickra_omega_ratio_free(struct OmegaRatio *handle); + +struct PainIndex *wickra_pain_index_new(uintptr_t period); + +double wickra_pain_index_update(struct PainIndex *handle, double value); + +void wickra_pain_index_batch(struct PainIndex *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_pain_index_reset(struct PainIndex *handle); + +void wickra_pain_index_free(struct PainIndex *handle); + +struct PercentB *wickra_percent_b_new(uintptr_t period, double multiplier); + +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); + +void wickra_percent_b_reset(struct PercentB *handle); + +void wickra_percent_b_free(struct PercentB *handle); + +struct PercentageTrailingStop *wickra_percentage_trailing_stop_new(double percent); + +double wickra_percentage_trailing_stop_update(struct PercentageTrailingStop *handle, double value); + +void wickra_percentage_trailing_stop_batch(struct PercentageTrailingStop *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_percentage_trailing_stop_reset(struct PercentageTrailingStop *handle); + +void wickra_percentage_trailing_stop_free(struct PercentageTrailingStop *handle); + +struct Pmo *wickra_pmo_new(uintptr_t smoothing1, uintptr_t smoothing2); + +double wickra_pmo_update(struct Pmo *handle, double value); + +void wickra_pmo_batch(struct Pmo *handle, const double *input, double *out, uintptr_t n); + +void wickra_pmo_reset(struct Pmo *handle); + +void wickra_pmo_free(struct Pmo *handle); + +struct PolarizedFractalEfficiency *wickra_polarized_fractal_efficiency_new(uintptr_t period, + uintptr_t smoothing); + +double wickra_polarized_fractal_efficiency_update(struct PolarizedFractalEfficiency *handle, + double value); + +void wickra_polarized_fractal_efficiency_batch(struct PolarizedFractalEfficiency *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_polarized_fractal_efficiency_reset(struct PolarizedFractalEfficiency *handle); + +void wickra_polarized_fractal_efficiency_free(struct PolarizedFractalEfficiency *handle); + +struct Ppo *wickra_ppo_new(uintptr_t fast, uintptr_t slow); + +double wickra_ppo_update(struct Ppo *handle, double value); + +void wickra_ppo_batch(struct Ppo *handle, const double *input, double *out, uintptr_t n); + +void wickra_ppo_reset(struct Ppo *handle); + +void wickra_ppo_free(struct Ppo *handle); + +struct PpoHistogram *wickra_ppo_histogram_new(uintptr_t fast, uintptr_t slow, uintptr_t signal); + +double wickra_ppo_histogram_update(struct PpoHistogram *handle, double value); + +void wickra_ppo_histogram_batch(struct PpoHistogram *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_ppo_histogram_reset(struct PpoHistogram *handle); + +void wickra_ppo_histogram_free(struct PpoHistogram *handle); + +struct ProfitFactor *wickra_profit_factor_new(uintptr_t period); + +double wickra_profit_factor_update(struct ProfitFactor *handle, double value); + +void wickra_profit_factor_batch(struct ProfitFactor *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_profit_factor_reset(struct ProfitFactor *handle); + +void wickra_profit_factor_free(struct ProfitFactor *handle); + +struct RSquared *wickra_r_squared_new(uintptr_t period); + +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); + +void wickra_r_squared_reset(struct RSquared *handle); + +void wickra_r_squared_free(struct RSquared *handle); + +struct RealizedVolatility *wickra_realized_volatility_new(uintptr_t period); + +double wickra_realized_volatility_update(struct RealizedVolatility *handle, double value); + +void wickra_realized_volatility_batch(struct RealizedVolatility *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_realized_volatility_reset(struct RealizedVolatility *handle); + +void wickra_realized_volatility_free(struct RealizedVolatility *handle); + +struct RecoveryFactor *wickra_recovery_factor_new(void); + +double wickra_recovery_factor_update(struct RecoveryFactor *handle, double value); + +void wickra_recovery_factor_batch(struct RecoveryFactor *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_recovery_factor_reset(struct RecoveryFactor *handle); + +void wickra_recovery_factor_free(struct RecoveryFactor *handle); + +struct Reflex *wickra_reflex_new(uintptr_t period); + +double wickra_reflex_update(struct Reflex *handle, double value); + +void wickra_reflex_batch(struct Reflex *handle, const double *input, double *out, uintptr_t n); + +void wickra_reflex_reset(struct Reflex *handle); + +void wickra_reflex_free(struct Reflex *handle); + +struct RegimeLabel *wickra_regime_label_new(uintptr_t vol_period, uintptr_t lookback); + +double wickra_regime_label_update(struct RegimeLabel *handle, double value); + +void wickra_regime_label_batch(struct RegimeLabel *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_regime_label_reset(struct RegimeLabel *handle); + +void wickra_regime_label_free(struct RegimeLabel *handle); + +struct RenkoTrailingStop *wickra_renko_trailing_stop_new(double block_size); + +double wickra_renko_trailing_stop_update(struct RenkoTrailingStop *handle, double value); + +void wickra_renko_trailing_stop_batch(struct RenkoTrailingStop *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_renko_trailing_stop_reset(struct RenkoTrailingStop *handle); + +void wickra_renko_trailing_stop_free(struct RenkoTrailingStop *handle); + +struct Rmi *wickra_rmi_new(uintptr_t period, uintptr_t momentum); + +double wickra_rmi_update(struct Rmi *handle, double value); + +void wickra_rmi_batch(struct Rmi *handle, const double *input, double *out, uintptr_t n); + +void wickra_rmi_reset(struct Rmi *handle); + +void wickra_rmi_free(struct Rmi *handle); + +struct Roc *wickra_roc_new(uintptr_t period); + +double wickra_roc_update(struct Roc *handle, double value); + +void wickra_roc_batch(struct Roc *handle, const double *input, double *out, uintptr_t n); + +void wickra_roc_reset(struct Roc *handle); + +void wickra_roc_free(struct Roc *handle); + +struct Rocp *wickra_rocp_new(uintptr_t period); + +double wickra_rocp_update(struct Rocp *handle, double value); + +void wickra_rocp_batch(struct Rocp *handle, const double *input, double *out, uintptr_t n); + +void wickra_rocp_reset(struct Rocp *handle); + +void wickra_rocp_free(struct Rocp *handle); + +struct Rocr *wickra_rocr_new(uintptr_t period); + +double wickra_rocr_update(struct Rocr *handle, double value); + +void wickra_rocr_batch(struct Rocr *handle, const double *input, double *out, uintptr_t n); + +void wickra_rocr_reset(struct Rocr *handle); + +void wickra_rocr_free(struct Rocr *handle); + +struct Rocr100 *wickra_rocr100_new(uintptr_t period); + +double wickra_rocr100_update(struct Rocr100 *handle, double value); + +void wickra_rocr100_batch(struct Rocr100 *handle, const double *input, double *out, uintptr_t n); + +void wickra_rocr100_reset(struct Rocr100 *handle); + +void wickra_rocr100_free(struct Rocr100 *handle); + +struct RollingIqr *wickra_rolling_iqr_new(uintptr_t period); + +double wickra_rolling_iqr_update(struct RollingIqr *handle, double value); + +void wickra_rolling_iqr_batch(struct RollingIqr *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_rolling_iqr_reset(struct RollingIqr *handle); + +void wickra_rolling_iqr_free(struct RollingIqr *handle); + +struct RollingMinMaxScaler *wickra_rolling_min_max_scaler_new(uintptr_t period); + +double wickra_rolling_min_max_scaler_update(struct RollingMinMaxScaler *handle, double value); + +void wickra_rolling_min_max_scaler_batch(struct RollingMinMaxScaler *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_rolling_min_max_scaler_reset(struct RollingMinMaxScaler *handle); + +void wickra_rolling_min_max_scaler_free(struct RollingMinMaxScaler *handle); + +struct RollingPercentileRank *wickra_rolling_percentile_rank_new(uintptr_t period); + +double wickra_rolling_percentile_rank_update(struct RollingPercentileRank *handle, double value); + +void wickra_rolling_percentile_rank_batch(struct RollingPercentileRank *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_rolling_percentile_rank_reset(struct RollingPercentileRank *handle); + +void wickra_rolling_percentile_rank_free(struct RollingPercentileRank *handle); + +struct RollingQuantile *wickra_rolling_quantile_new(uintptr_t period, double quantile); + +double wickra_rolling_quantile_update(struct RollingQuantile *handle, double value); + +void wickra_rolling_quantile_batch(struct RollingQuantile *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_rolling_quantile_reset(struct RollingQuantile *handle); + +void wickra_rolling_quantile_free(struct RollingQuantile *handle); + +struct RoofingFilter *wickra_roofing_filter_new(uintptr_t lp_period, uintptr_t hp_period); + +double wickra_roofing_filter_update(struct RoofingFilter *handle, double value); + +void wickra_roofing_filter_batch(struct RoofingFilter *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_roofing_filter_reset(struct RoofingFilter *handle); + +void wickra_roofing_filter_free(struct RoofingFilter *handle); + +struct Rsi *wickra_rsi_new(uintptr_t period); + +double wickra_rsi_update(struct Rsi *handle, double value); + +void wickra_rsi_batch(struct Rsi *handle, const double *input, double *out, uintptr_t n); + +void wickra_rsi_reset(struct Rsi *handle); + +void wickra_rsi_free(struct Rsi *handle); + +struct Rsx *wickra_rsx_new(uintptr_t length); + +double wickra_rsx_update(struct Rsx *handle, double value); + +void wickra_rsx_batch(struct Rsx *handle, const double *input, double *out, uintptr_t n); + +void wickra_rsx_reset(struct Rsx *handle); + +void wickra_rsx_free(struct Rsx *handle); + +struct RviVolatility *wickra_rvi_volatility_new(uintptr_t period); + +double wickra_rvi_volatility_update(struct RviVolatility *handle, double value); + +void wickra_rvi_volatility_batch(struct RviVolatility *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_rvi_volatility_reset(struct RviVolatility *handle); + +void wickra_rvi_volatility_free(struct RviVolatility *handle); + +struct SampleEntropy *wickra_sample_entropy_new(uintptr_t period, uintptr_t m, double r_factor); + +double wickra_sample_entropy_update(struct SampleEntropy *handle, double value); + +void wickra_sample_entropy_batch(struct SampleEntropy *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_sample_entropy_reset(struct SampleEntropy *handle); + +void wickra_sample_entropy_free(struct SampleEntropy *handle); + +struct ShannonEntropy *wickra_shannon_entropy_new(uintptr_t period, uintptr_t bins); + +double wickra_shannon_entropy_update(struct ShannonEntropy *handle, double value); + +void wickra_shannon_entropy_batch(struct ShannonEntropy *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_shannon_entropy_reset(struct ShannonEntropy *handle); + +void wickra_shannon_entropy_free(struct ShannonEntropy *handle); + +struct SharpeRatio *wickra_sharpe_ratio_new(uintptr_t period, double risk_free); + +double wickra_sharpe_ratio_update(struct SharpeRatio *handle, double value); + +void wickra_sharpe_ratio_batch(struct SharpeRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_sharpe_ratio_reset(struct SharpeRatio *handle); + +void wickra_sharpe_ratio_free(struct SharpeRatio *handle); + +struct SineWave *wickra_sine_wave_new(void); + +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); + +void wickra_sine_wave_reset(struct SineWave *handle); + +void wickra_sine_wave_free(struct SineWave *handle); + +struct SineWeightedMa *wickra_sine_weighted_ma_new(uintptr_t period); + +double wickra_sine_weighted_ma_update(struct SineWeightedMa *handle, double value); + +void wickra_sine_weighted_ma_batch(struct SineWeightedMa *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_sine_weighted_ma_reset(struct SineWeightedMa *handle); + +void wickra_sine_weighted_ma_free(struct SineWeightedMa *handle); + +struct Skewness *wickra_skewness_new(uintptr_t period); + +double wickra_skewness_update(struct Skewness *handle, double value); + +void wickra_skewness_batch(struct Skewness *handle, const double *input, double *out, uintptr_t n); + +void wickra_skewness_reset(struct Skewness *handle); + +void wickra_skewness_free(struct Skewness *handle); + +struct Sma *wickra_sma_new(uintptr_t period); + +double wickra_sma_update(struct Sma *handle, double value); + +void wickra_sma_batch(struct Sma *handle, const double *input, double *out, uintptr_t n); + +void wickra_sma_reset(struct Sma *handle); + +void wickra_sma_free(struct Sma *handle); + +struct Smma *wickra_smma_new(uintptr_t period); + +double wickra_smma_update(struct Smma *handle, double value); + +void wickra_smma_batch(struct Smma *handle, const double *input, double *out, uintptr_t n); + +void wickra_smma_reset(struct Smma *handle); + +void wickra_smma_free(struct Smma *handle); + +struct SortinoRatio *wickra_sortino_ratio_new(uintptr_t period, double mar); + +double wickra_sortino_ratio_update(struct SortinoRatio *handle, double value); + +void wickra_sortino_ratio_batch(struct SortinoRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_sortino_ratio_reset(struct SortinoRatio *handle); + +void wickra_sortino_ratio_free(struct SortinoRatio *handle); + +struct StandardError *wickra_standard_error_new(uintptr_t period); + +double wickra_standard_error_update(struct StandardError *handle, double value); + +void wickra_standard_error_batch(struct StandardError *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_standard_error_reset(struct StandardError *handle); + +void wickra_standard_error_free(struct StandardError *handle); + +struct Stc *wickra_stc_new(uintptr_t fast, uintptr_t slow, uintptr_t schaff_period, double factor); + +double wickra_stc_update(struct Stc *handle, double value); + +void wickra_stc_batch(struct Stc *handle, const double *input, double *out, uintptr_t n); + +void wickra_stc_reset(struct Stc *handle); + +void wickra_stc_free(struct Stc *handle); + +struct StdDev *wickra_std_dev_new(uintptr_t period); + +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); + +void wickra_std_dev_reset(struct StdDev *handle); + +void wickra_std_dev_free(struct StdDev *handle); + +struct StepTrailingStop *wickra_step_trailing_stop_new(double step_size); + +double wickra_step_trailing_stop_update(struct StepTrailingStop *handle, double value); + +void wickra_step_trailing_stop_batch(struct StepTrailingStop *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_step_trailing_stop_reset(struct StepTrailingStop *handle); + +void wickra_step_trailing_stop_free(struct StepTrailingStop *handle); + +struct SterlingRatio *wickra_sterling_ratio_new(uintptr_t period); + +double wickra_sterling_ratio_update(struct SterlingRatio *handle, double value); + +void wickra_sterling_ratio_batch(struct SterlingRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_sterling_ratio_reset(struct SterlingRatio *handle); + +void wickra_sterling_ratio_free(struct SterlingRatio *handle); + +struct StochRsi *wickra_stoch_rsi_new(uintptr_t rsi_period, uintptr_t stoch_period); + +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); + +void wickra_stoch_rsi_reset(struct StochRsi *handle); + +void wickra_stoch_rsi_free(struct StochRsi *handle); + +struct SuperSmoother *wickra_super_smoother_new(uintptr_t period); + +double wickra_super_smoother_update(struct SuperSmoother *handle, double value); + +void wickra_super_smoother_batch(struct SuperSmoother *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_super_smoother_reset(struct SuperSmoother *handle); + +void wickra_super_smoother_free(struct SuperSmoother *handle); + +struct T3 *wickra_t3_new(uintptr_t period, double v); + +double wickra_t3_update(struct T3 *handle, double value); + +void wickra_t3_batch(struct T3 *handle, const double *input, double *out, uintptr_t n); + +void wickra_t3_reset(struct T3 *handle); + +void wickra_t3_free(struct T3 *handle); + +struct TailRatio *wickra_tail_ratio_new(uintptr_t period); + +double wickra_tail_ratio_update(struct TailRatio *handle, double value); + +void wickra_tail_ratio_batch(struct TailRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_tail_ratio_reset(struct TailRatio *handle); + +void wickra_tail_ratio_free(struct TailRatio *handle); + +struct Tema *wickra_tema_new(uintptr_t period); + +double wickra_tema_update(struct Tema *handle, double value); + +void wickra_tema_batch(struct Tema *handle, const double *input, double *out, uintptr_t n); + +void wickra_tema_reset(struct Tema *handle); + +void wickra_tema_free(struct Tema *handle); + +struct Tii *wickra_tii_new(uintptr_t sma_period, uintptr_t dev_period); + +double wickra_tii_update(struct Tii *handle, double value); + +void wickra_tii_batch(struct Tii *handle, const double *input, double *out, uintptr_t n); + +void wickra_tii_reset(struct Tii *handle); + +void wickra_tii_free(struct Tii *handle); + +struct TrendLabel *wickra_trend_label_new(uintptr_t period); + +double wickra_trend_label_update(struct TrendLabel *handle, double value); + +void wickra_trend_label_batch(struct TrendLabel *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_trend_label_reset(struct TrendLabel *handle); + +void wickra_trend_label_free(struct TrendLabel *handle); + +struct TrendStrengthIndex *wickra_trend_strength_index_new(uintptr_t period); + +double wickra_trend_strength_index_update(struct TrendStrengthIndex *handle, double value); + +void wickra_trend_strength_index_batch(struct TrendStrengthIndex *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_trend_strength_index_reset(struct TrendStrengthIndex *handle); + +void wickra_trend_strength_index_free(struct TrendStrengthIndex *handle); + +struct Trendflex *wickra_trendflex_new(uintptr_t period); + +double wickra_trendflex_update(struct Trendflex *handle, double value); + +void wickra_trendflex_batch(struct Trendflex *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_trendflex_reset(struct Trendflex *handle); + +void wickra_trendflex_free(struct Trendflex *handle); + +struct Trima *wickra_trima_new(uintptr_t period); + +double wickra_trima_update(struct Trima *handle, double value); + +void wickra_trima_batch(struct Trima *handle, const double *input, double *out, uintptr_t n); + +void wickra_trima_reset(struct Trima *handle); + +void wickra_trima_free(struct Trima *handle); + +struct Trix *wickra_trix_new(uintptr_t period); + +double wickra_trix_update(struct Trix *handle, double value); + +void wickra_trix_batch(struct Trix *handle, const double *input, double *out, uintptr_t n); + +void wickra_trix_reset(struct Trix *handle); + +void wickra_trix_free(struct Trix *handle); + +struct Tsf *wickra_tsf_new(uintptr_t period); + +double wickra_tsf_update(struct Tsf *handle, double value); + +void wickra_tsf_batch(struct Tsf *handle, const double *input, double *out, uintptr_t n); + +void wickra_tsf_reset(struct Tsf *handle); + +void wickra_tsf_free(struct Tsf *handle); + +struct TsfOscillator *wickra_tsf_oscillator_new(uintptr_t period); + +double wickra_tsf_oscillator_update(struct TsfOscillator *handle, double value); + +void wickra_tsf_oscillator_batch(struct TsfOscillator *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_tsf_oscillator_reset(struct TsfOscillator *handle); + +void wickra_tsf_oscillator_free(struct TsfOscillator *handle); + +struct Tsi *wickra_tsi_new(uintptr_t long_, uintptr_t short_); + +double wickra_tsi_update(struct Tsi *handle, double value); + +void wickra_tsi_batch(struct Tsi *handle, const double *input, double *out, uintptr_t n); + +void wickra_tsi_reset(struct Tsi *handle); + +void wickra_tsi_free(struct Tsi *handle); + +struct UlcerIndex *wickra_ulcer_index_new(uintptr_t period); + +double wickra_ulcer_index_update(struct UlcerIndex *handle, double value); + +void wickra_ulcer_index_batch(struct UlcerIndex *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_ulcer_index_reset(struct UlcerIndex *handle); + +void wickra_ulcer_index_free(struct UlcerIndex *handle); + +struct UniversalOscillator *wickra_universal_oscillator_new(uintptr_t period); + +double wickra_universal_oscillator_update(struct UniversalOscillator *handle, double value); + +void wickra_universal_oscillator_batch(struct UniversalOscillator *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_universal_oscillator_reset(struct UniversalOscillator *handle); + +void wickra_universal_oscillator_free(struct UniversalOscillator *handle); + +struct UpsidePotentialRatio *wickra_upside_potential_ratio_new(uintptr_t period, double mar); + +double wickra_upside_potential_ratio_update(struct UpsidePotentialRatio *handle, double value); + +void wickra_upside_potential_ratio_batch(struct UpsidePotentialRatio *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_upside_potential_ratio_reset(struct UpsidePotentialRatio *handle); + +void wickra_upside_potential_ratio_free(struct UpsidePotentialRatio *handle); + +struct ValueAtRisk *wickra_value_at_risk_new(uintptr_t period, double confidence); + +double wickra_value_at_risk_update(struct ValueAtRisk *handle, double value); + +void wickra_value_at_risk_batch(struct ValueAtRisk *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_value_at_risk_reset(struct ValueAtRisk *handle); + +void wickra_value_at_risk_free(struct ValueAtRisk *handle); + +struct Variance *wickra_variance_new(uintptr_t period); + +double wickra_variance_update(struct Variance *handle, double value); + +void wickra_variance_batch(struct Variance *handle, const double *input, double *out, uintptr_t n); + +void wickra_variance_reset(struct Variance *handle); + +void wickra_variance_free(struct Variance *handle); + +struct VerticalHorizontalFilter *wickra_vertical_horizontal_filter_new(uintptr_t period); + +double wickra_vertical_horizontal_filter_update(struct VerticalHorizontalFilter *handle, + double value); + +void wickra_vertical_horizontal_filter_batch(struct VerticalHorizontalFilter *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_vertical_horizontal_filter_reset(struct VerticalHorizontalFilter *handle); + +void wickra_vertical_horizontal_filter_free(struct VerticalHorizontalFilter *handle); + +struct Vidya *wickra_vidya_new(uintptr_t period, uintptr_t cmo_period); + +double wickra_vidya_update(struct Vidya *handle, double value); + +void wickra_vidya_batch(struct Vidya *handle, const double *input, double *out, uintptr_t n); + +void wickra_vidya_reset(struct Vidya *handle); + +void wickra_vidya_free(struct Vidya *handle); + +struct VolatilityOfVolatility *wickra_volatility_of_volatility_new(uintptr_t vol_window, + uintptr_t vov_window); + +double wickra_volatility_of_volatility_update(struct VolatilityOfVolatility *handle, double value); + +void wickra_volatility_of_volatility_batch(struct VolatilityOfVolatility *handle, + const double *input, + double *out, + uintptr_t n); + +void wickra_volatility_of_volatility_reset(struct VolatilityOfVolatility *handle); + +void wickra_volatility_of_volatility_free(struct VolatilityOfVolatility *handle); + +struct WavePm *wickra_wave_pm_new(uintptr_t length, uintptr_t smoothing); + +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); + +void wickra_wave_pm_reset(struct WavePm *handle); + +void wickra_wave_pm_free(struct WavePm *handle); + +struct WinRate *wickra_win_rate_new(uintptr_t period); + +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); + +void wickra_win_rate_reset(struct WinRate *handle); + +void wickra_win_rate_free(struct WinRate *handle); + +struct Wma *wickra_wma_new(uintptr_t period); + +double wickra_wma_update(struct Wma *handle, double value); + +void wickra_wma_batch(struct Wma *handle, const double *input, double *out, uintptr_t n); + +void wickra_wma_reset(struct Wma *handle); + +void wickra_wma_free(struct Wma *handle); + +struct ZScore *wickra_z_score_new(uintptr_t period); + +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); + +void wickra_z_score_reset(struct ZScore *handle); + +void wickra_z_score_free(struct ZScore *handle); + +struct Zlema *wickra_zlema_new(uintptr_t period); + +double wickra_zlema_update(struct Zlema *handle, double value); + +void wickra_zlema_batch(struct Zlema *handle, const double *input, double *out, uintptr_t n); + +void wickra_zlema_reset(struct Zlema *handle); + +void wickra_zlema_free(struct Zlema *handle); + +struct Alpha *wickra_alpha_new(uintptr_t period, double risk_free); + +double wickra_alpha_update(struct Alpha *handle, double x, double y); + +void wickra_alpha_batch(struct Alpha *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_alpha_reset(struct Alpha *handle); + +void wickra_alpha_free(struct Alpha *handle); + +struct Beta *wickra_beta_new(uintptr_t period); + +double wickra_beta_update(struct Beta *handle, double x, double y); + +void wickra_beta_batch(struct Beta *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_beta_reset(struct Beta *handle); + +void wickra_beta_free(struct Beta *handle); + +struct BetaNeutralSpread *wickra_beta_neutral_spread_new(uintptr_t period); + +double wickra_beta_neutral_spread_update(struct BetaNeutralSpread *handle, double x, double y); + +void wickra_beta_neutral_spread_batch(struct BetaNeutralSpread *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_beta_neutral_spread_reset(struct BetaNeutralSpread *handle); + +void wickra_beta_neutral_spread_free(struct BetaNeutralSpread *handle); + +struct DistanceSsd *wickra_distance_ssd_new(uintptr_t period); + +double wickra_distance_ssd_update(struct DistanceSsd *handle, double x, double y); + +void wickra_distance_ssd_batch(struct DistanceSsd *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_distance_ssd_reset(struct DistanceSsd *handle); + +void wickra_distance_ssd_free(struct DistanceSsd *handle); + +struct GrangerCausality *wickra_granger_causality_new(uintptr_t period, uintptr_t lag); + +double wickra_granger_causality_update(struct GrangerCausality *handle, double x, double y); + +void wickra_granger_causality_batch(struct GrangerCausality *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_granger_causality_reset(struct GrangerCausality *handle); + +void wickra_granger_causality_free(struct GrangerCausality *handle); + +struct HasbrouckInformationShare *wickra_hasbrouck_information_share_new(uintptr_t period); + +double wickra_hasbrouck_information_share_update(struct HasbrouckInformationShare *handle, + double x, + double y); + +void wickra_hasbrouck_information_share_batch(struct HasbrouckInformationShare *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_hasbrouck_information_share_reset(struct HasbrouckInformationShare *handle); + +void wickra_hasbrouck_information_share_free(struct HasbrouckInformationShare *handle); + +struct InformationRatio *wickra_information_ratio_new(uintptr_t period); + +double wickra_information_ratio_update(struct InformationRatio *handle, double x, double y); + +void wickra_information_ratio_batch(struct InformationRatio *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_information_ratio_reset(struct InformationRatio *handle); + +void wickra_information_ratio_free(struct InformationRatio *handle); + +struct KendallTau *wickra_kendall_tau_new(uintptr_t period); + +double wickra_kendall_tau_update(struct KendallTau *handle, double x, double y); + +void wickra_kendall_tau_batch(struct KendallTau *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_kendall_tau_reset(struct KendallTau *handle); + +void wickra_kendall_tau_free(struct KendallTau *handle); + +struct OuHalfLife *wickra_ou_half_life_new(uintptr_t period); + +double wickra_ou_half_life_update(struct OuHalfLife *handle, double x, double y); + +void wickra_ou_half_life_batch(struct OuHalfLife *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_ou_half_life_reset(struct OuHalfLife *handle); + +void wickra_ou_half_life_free(struct OuHalfLife *handle); + +struct PairSpreadZScore *wickra_pair_spread_z_score_new(uintptr_t beta_period, uintptr_t z_period); + +double wickra_pair_spread_z_score_update(struct PairSpreadZScore *handle, double x, double y); + +void wickra_pair_spread_z_score_batch(struct PairSpreadZScore *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_pair_spread_z_score_reset(struct PairSpreadZScore *handle); + +void wickra_pair_spread_z_score_free(struct PairSpreadZScore *handle); + +struct PairwiseBeta *wickra_pairwise_beta_new(uintptr_t period); + +double wickra_pairwise_beta_update(struct PairwiseBeta *handle, double x, double y); + +void wickra_pairwise_beta_batch(struct PairwiseBeta *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_pairwise_beta_reset(struct PairwiseBeta *handle); + +void wickra_pairwise_beta_free(struct PairwiseBeta *handle); + +struct PearsonCorrelation *wickra_pearson_correlation_new(uintptr_t period); + +double wickra_pearson_correlation_update(struct PearsonCorrelation *handle, double x, double y); + +void wickra_pearson_correlation_batch(struct PearsonCorrelation *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_pearson_correlation_reset(struct PearsonCorrelation *handle); + +void wickra_pearson_correlation_free(struct PearsonCorrelation *handle); + +struct RollingCorrelation *wickra_rolling_correlation_new(uintptr_t period); + +double wickra_rolling_correlation_update(struct RollingCorrelation *handle, double x, double y); + +void wickra_rolling_correlation_batch(struct RollingCorrelation *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_rolling_correlation_reset(struct RollingCorrelation *handle); + +void wickra_rolling_correlation_free(struct RollingCorrelation *handle); + +struct RollingCovariance *wickra_rolling_covariance_new(uintptr_t period); + +double wickra_rolling_covariance_update(struct RollingCovariance *handle, double x, double y); + +void wickra_rolling_covariance_batch(struct RollingCovariance *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_rolling_covariance_reset(struct RollingCovariance *handle); + +void wickra_rolling_covariance_free(struct RollingCovariance *handle); + +struct SpearmanCorrelation *wickra_spearman_correlation_new(uintptr_t period); + +double wickra_spearman_correlation_update(struct SpearmanCorrelation *handle, double x, double y); + +void wickra_spearman_correlation_batch(struct SpearmanCorrelation *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_spearman_correlation_reset(struct SpearmanCorrelation *handle); + +void wickra_spearman_correlation_free(struct SpearmanCorrelation *handle); + +struct SpreadAr1Coefficient *wickra_spread_ar1_coefficient_new(uintptr_t period); + +double wickra_spread_ar1_coefficient_update(struct SpreadAr1Coefficient *handle, + double x, + double y); + +void wickra_spread_ar1_coefficient_batch(struct SpreadAr1Coefficient *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_spread_ar1_coefficient_reset(struct SpreadAr1Coefficient *handle); + +void wickra_spread_ar1_coefficient_free(struct SpreadAr1Coefficient *handle); + +struct SpreadHurst *wickra_spread_hurst_new(uintptr_t period); + +double wickra_spread_hurst_update(struct SpreadHurst *handle, double x, double y); + +void wickra_spread_hurst_batch(struct SpreadHurst *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_spread_hurst_reset(struct SpreadHurst *handle); + +void wickra_spread_hurst_free(struct SpreadHurst *handle); + +struct TreynorRatio *wickra_treynor_ratio_new(uintptr_t period, double risk_free); + +double wickra_treynor_ratio_update(struct TreynorRatio *handle, double x, double y); + +void wickra_treynor_ratio_batch(struct TreynorRatio *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_treynor_ratio_reset(struct TreynorRatio *handle); + +void wickra_treynor_ratio_free(struct TreynorRatio *handle); + +struct VarianceRatio *wickra_variance_ratio_new(uintptr_t period, uintptr_t q); + +double wickra_variance_ratio_update(struct VarianceRatio *handle, double x, double y); + +void wickra_variance_ratio_batch(struct VarianceRatio *handle, + const double *x, + const double *y, + double *out, + uintptr_t n); + +void wickra_variance_ratio_reset(struct VarianceRatio *handle); + +void wickra_variance_ratio_free(struct VarianceRatio *handle); + +struct AbandonedBaby *wickra_abandoned_baby_new(void); + +double wickra_abandoned_baby_update(struct AbandonedBaby *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_abandoned_baby_batch(struct AbandonedBaby *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_abandoned_baby_reset(struct AbandonedBaby *handle); + +void wickra_abandoned_baby_free(struct AbandonedBaby *handle); + +struct Abcd *wickra_abcd_new(void); + +double wickra_abcd_update(struct Abcd *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_abcd_batch(struct Abcd *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_abcd_reset(struct Abcd *handle); + +void wickra_abcd_free(struct Abcd *handle); + +struct AcceleratorOscillator *wickra_accelerator_oscillator_new(uintptr_t ao_fast, + uintptr_t ao_slow, + uintptr_t signal_period); + +double wickra_accelerator_oscillator_update(struct AcceleratorOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_accelerator_oscillator_batch(struct AcceleratorOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_accelerator_oscillator_reset(struct AcceleratorOscillator *handle); + +void wickra_accelerator_oscillator_free(struct AcceleratorOscillator *handle); + +struct AdOscillator *wickra_ad_oscillator_new(void); + +double wickra_ad_oscillator_update(struct AdOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_ad_oscillator_batch(struct AdOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_ad_oscillator_reset(struct AdOscillator *handle); + +void wickra_ad_oscillator_free(struct AdOscillator *handle); + +struct AdaptiveCci *wickra_adaptive_cci_new(uintptr_t period); + +double wickra_adaptive_cci_update(struct AdaptiveCci *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_adaptive_cci_batch(struct AdaptiveCci *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_adaptive_cci_reset(struct AdaptiveCci *handle); + +void wickra_adaptive_cci_free(struct AdaptiveCci *handle); + +struct Adl *wickra_adl_new(void); + +double wickra_adl_update(struct Adl *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_adl_batch(struct Adl *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_adl_reset(struct Adl *handle); + +void wickra_adl_free(struct Adl *handle); + +struct AdvanceBlock *wickra_advance_block_new(void); + +double wickra_advance_block_update(struct AdvanceBlock *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_advance_block_batch(struct AdvanceBlock *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_advance_block_reset(struct AdvanceBlock *handle); + +void wickra_advance_block_free(struct AdvanceBlock *handle); + +struct Adxr *wickra_adxr_new(uintptr_t period); + +double wickra_adxr_update(struct Adxr *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_adxr_batch(struct Adxr *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_adxr_reset(struct Adxr *handle); + +void wickra_adxr_free(struct Adxr *handle); + +struct AnchoredVwap *wickra_anchored_vwap_new(void); + +double wickra_anchored_vwap_update(struct AnchoredVwap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_anchored_vwap_batch(struct AnchoredVwap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_anchored_vwap_reset(struct AnchoredVwap *handle); + +void wickra_anchored_vwap_free(struct AnchoredVwap *handle); + +struct AroonOscillator *wickra_aroon_oscillator_new(uintptr_t period); + +double wickra_aroon_oscillator_update(struct AroonOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_aroon_oscillator_batch(struct AroonOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_aroon_oscillator_reset(struct AroonOscillator *handle); + +void wickra_aroon_oscillator_free(struct AroonOscillator *handle); + +struct Atr *wickra_atr_new(uintptr_t period); + +double wickra_atr_update(struct Atr *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_atr_batch(struct Atr *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_atr_reset(struct Atr *handle); + +void wickra_atr_free(struct Atr *handle); + +struct AtrTrailingStop *wickra_atr_trailing_stop_new(uintptr_t atr_period, double multiplier); + +double wickra_atr_trailing_stop_update(struct AtrTrailingStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_atr_trailing_stop_batch(struct AtrTrailingStop *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_atr_trailing_stop_reset(struct AtrTrailingStop *handle); + +void wickra_atr_trailing_stop_free(struct AtrTrailingStop *handle); + +struct AverageDailyRange *wickra_average_daily_range_new(uintptr_t period, + int32_t utc_offset_minutes); + +double wickra_average_daily_range_update(struct AverageDailyRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_average_daily_range_batch(struct AverageDailyRange *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_average_daily_range_reset(struct AverageDailyRange *handle); + +void wickra_average_daily_range_free(struct AverageDailyRange *handle); + +struct AvgPrice *wickra_avg_price_new(void); + +double wickra_avg_price_update(struct AvgPrice *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_avg_price_batch(struct AvgPrice *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_avg_price_reset(struct AvgPrice *handle); + +void wickra_avg_price_free(struct AvgPrice *handle); + +struct AwesomeOscillator *wickra_awesome_oscillator_new(uintptr_t fast, uintptr_t slow); + +double wickra_awesome_oscillator_update(struct AwesomeOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_awesome_oscillator_batch(struct AwesomeOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_awesome_oscillator_reset(struct AwesomeOscillator *handle); + +void wickra_awesome_oscillator_free(struct AwesomeOscillator *handle); + +struct AwesomeOscillatorHistogram *wickra_awesome_oscillator_histogram_new(uintptr_t fast, + uintptr_t slow, + uintptr_t sma_period); + +double wickra_awesome_oscillator_histogram_update(struct AwesomeOscillatorHistogram *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_awesome_oscillator_histogram_batch(struct AwesomeOscillatorHistogram *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_awesome_oscillator_histogram_reset(struct AwesomeOscillatorHistogram *handle); + +void wickra_awesome_oscillator_histogram_free(struct AwesomeOscillatorHistogram *handle); + +struct BalanceOfPower *wickra_balance_of_power_new(void); + +double wickra_balance_of_power_update(struct BalanceOfPower *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_balance_of_power_batch(struct BalanceOfPower *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_balance_of_power_reset(struct BalanceOfPower *handle); + +void wickra_balance_of_power_free(struct BalanceOfPower *handle); + +struct Bat *wickra_bat_new(void); + +double wickra_bat_update(struct Bat *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_bat_batch(struct Bat *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_bat_reset(struct Bat *handle); + +void wickra_bat_free(struct Bat *handle); + +struct BeltHold *wickra_belt_hold_new(void); + +double wickra_belt_hold_update(struct BeltHold *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_belt_hold_batch(struct BeltHold *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_belt_hold_reset(struct BeltHold *handle); + +void wickra_belt_hold_free(struct BeltHold *handle); + +struct BetterVolume *wickra_better_volume_new(uintptr_t period); + +double wickra_better_volume_update(struct BetterVolume *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_better_volume_batch(struct BetterVolume *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_better_volume_reset(struct BetterVolume *handle); + +void wickra_better_volume_free(struct BetterVolume *handle); + +struct BodySizePct *wickra_body_size_pct_new(void); + +double wickra_body_size_pct_update(struct BodySizePct *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_body_size_pct_batch(struct BodySizePct *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_body_size_pct_reset(struct BodySizePct *handle); + +void wickra_body_size_pct_free(struct BodySizePct *handle); + +struct Breakaway *wickra_breakaway_new(void); + +double wickra_breakaway_update(struct Breakaway *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_breakaway_batch(struct Breakaway *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_breakaway_reset(struct Breakaway *handle); + +void wickra_breakaway_free(struct Breakaway *handle); + +struct Butterfly *wickra_butterfly_new(void); + +double wickra_butterfly_update(struct Butterfly *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_butterfly_batch(struct Butterfly *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_butterfly_reset(struct Butterfly *handle); + +void wickra_butterfly_free(struct Butterfly *handle); + +struct Cci *wickra_cci_new(uintptr_t period); + +double wickra_cci_update(struct Cci *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_cci_batch(struct Cci *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_cci_reset(struct Cci *handle); + +void wickra_cci_free(struct Cci *handle); + +struct ChaikinOscillator *wickra_chaikin_oscillator_new(uintptr_t fast, uintptr_t slow); + +double wickra_chaikin_oscillator_update(struct ChaikinOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_chaikin_oscillator_batch(struct ChaikinOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_chaikin_oscillator_reset(struct ChaikinOscillator *handle); + +void wickra_chaikin_oscillator_free(struct ChaikinOscillator *handle); + +struct ChaikinVolatility *wickra_chaikin_volatility_new(uintptr_t ema_period, uintptr_t roc_period); + +double wickra_chaikin_volatility_update(struct ChaikinVolatility *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_chaikin_volatility_batch(struct ChaikinVolatility *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_chaikin_volatility_reset(struct ChaikinVolatility *handle); + +void wickra_chaikin_volatility_free(struct ChaikinVolatility *handle); + +struct ChoppinessIndex *wickra_choppiness_index_new(uintptr_t period); + +double wickra_choppiness_index_update(struct ChoppinessIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_choppiness_index_batch(struct ChoppinessIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_choppiness_index_reset(struct ChoppinessIndex *handle); + +void wickra_choppiness_index_free(struct ChoppinessIndex *handle); + +struct CloseVsOpen *wickra_close_vs_open_new(void); + +double wickra_close_vs_open_update(struct CloseVsOpen *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_close_vs_open_batch(struct CloseVsOpen *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_close_vs_open_reset(struct CloseVsOpen *handle); + +void wickra_close_vs_open_free(struct CloseVsOpen *handle); + +struct ClosingMarubozu *wickra_closing_marubozu_new(void); + +double wickra_closing_marubozu_update(struct ClosingMarubozu *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_closing_marubozu_batch(struct ClosingMarubozu *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_closing_marubozu_reset(struct ClosingMarubozu *handle); + +void wickra_closing_marubozu_free(struct ClosingMarubozu *handle); + +struct ChaikinMoneyFlow *wickra_chaikin_money_flow_new(uintptr_t period); + +double wickra_chaikin_money_flow_update(struct ChaikinMoneyFlow *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_chaikin_money_flow_batch(struct ChaikinMoneyFlow *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_chaikin_money_flow_reset(struct ChaikinMoneyFlow *handle); + +void wickra_chaikin_money_flow_free(struct ChaikinMoneyFlow *handle); + +struct ConcealingBabySwallow *wickra_concealing_baby_swallow_new(void); + +double wickra_concealing_baby_swallow_update(struct ConcealingBabySwallow *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_concealing_baby_swallow_batch(struct ConcealingBabySwallow *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_concealing_baby_swallow_reset(struct ConcealingBabySwallow *handle); + +void wickra_concealing_baby_swallow_free(struct ConcealingBabySwallow *handle); + +struct Counterattack *wickra_counterattack_new(void); + +double wickra_counterattack_update(struct Counterattack *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_counterattack_batch(struct Counterattack *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_counterattack_reset(struct Counterattack *handle); + +void wickra_counterattack_free(struct Counterattack *handle); + +struct Crab *wickra_crab_new(void); + +double wickra_crab_update(struct Crab *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_crab_batch(struct Crab *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_crab_reset(struct Crab *handle); + +void wickra_crab_free(struct Crab *handle); + +struct CupAndHandle *wickra_cup_and_handle_new(void); + +double wickra_cup_and_handle_update(struct CupAndHandle *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_cup_and_handle_batch(struct CupAndHandle *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_cup_and_handle_reset(struct CupAndHandle *handle); + +void wickra_cup_and_handle_free(struct CupAndHandle *handle); + +struct Cypher *wickra_cypher_new(void); + +double wickra_cypher_update(struct Cypher *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_cypher_batch(struct Cypher *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_cypher_reset(struct Cypher *handle); + +void wickra_cypher_free(struct Cypher *handle); + +struct DemandIndex *wickra_demand_index_new(uintptr_t period); + +double wickra_demand_index_update(struct DemandIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_demand_index_batch(struct DemandIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_demand_index_reset(struct DemandIndex *handle); + +void wickra_demand_index_free(struct DemandIndex *handle); + +struct Doji *wickra_doji_new(void); + +double wickra_doji_update(struct Doji *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_doji_batch(struct Doji *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_doji_reset(struct Doji *handle); + +void wickra_doji_free(struct Doji *handle); + +struct DojiStar *wickra_doji_star_new(void); + +double wickra_doji_star_update(struct DojiStar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_doji_star_batch(struct DojiStar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_doji_star_reset(struct DojiStar *handle); + +void wickra_doji_star_free(struct DojiStar *handle); + +struct DoubleTopBottom *wickra_double_top_bottom_new(void); + +double wickra_double_top_bottom_update(struct DoubleTopBottom *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_double_top_bottom_batch(struct DoubleTopBottom *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_double_top_bottom_reset(struct DoubleTopBottom *handle); + +void wickra_double_top_bottom_free(struct DoubleTopBottom *handle); + +struct DownsideGapThreeMethods *wickra_downside_gap_three_methods_new(void); + +double wickra_downside_gap_three_methods_update(struct DownsideGapThreeMethods *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_downside_gap_three_methods_batch(struct DownsideGapThreeMethods *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_downside_gap_three_methods_reset(struct DownsideGapThreeMethods *handle); + +void wickra_downside_gap_three_methods_free(struct DownsideGapThreeMethods *handle); + +struct DragonflyDoji *wickra_dragonfly_doji_new(void); + +double wickra_dragonfly_doji_update(struct DragonflyDoji *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_dragonfly_doji_batch(struct DragonflyDoji *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_dragonfly_doji_reset(struct DragonflyDoji *handle); + +void wickra_dragonfly_doji_free(struct DragonflyDoji *handle); + +struct DumplingTop *wickra_dumpling_top_new(uintptr_t period); + +double wickra_dumpling_top_update(struct DumplingTop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_dumpling_top_batch(struct DumplingTop *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_dumpling_top_reset(struct DumplingTop *handle); + +void wickra_dumpling_top_free(struct DumplingTop *handle); + +struct Dx *wickra_dx_new(uintptr_t period); + +double wickra_dx_update(struct Dx *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_dx_batch(struct Dx *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_dx_reset(struct Dx *handle); + +void wickra_dx_free(struct Dx *handle); + +struct EaseOfMovement *wickra_ease_of_movement_new(uintptr_t period); + +double wickra_ease_of_movement_update(struct EaseOfMovement *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_ease_of_movement_batch(struct EaseOfMovement *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_ease_of_movement_reset(struct EaseOfMovement *handle); + +void wickra_ease_of_movement_free(struct EaseOfMovement *handle); + +struct Engulfing *wickra_engulfing_new(void); + +double wickra_engulfing_update(struct Engulfing *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_engulfing_batch(struct Engulfing *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_engulfing_reset(struct Engulfing *handle); + +void wickra_engulfing_free(struct Engulfing *handle); + +struct EveningDojiStar *wickra_evening_doji_star_new(void); + +double wickra_evening_doji_star_update(struct EveningDojiStar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_evening_doji_star_batch(struct EveningDojiStar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_evening_doji_star_reset(struct EveningDojiStar *handle); + +void wickra_evening_doji_star_free(struct EveningDojiStar *handle); + +struct Evwma *wickra_evwma_new(uintptr_t period); + +double wickra_evwma_update(struct Evwma *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_evwma_batch(struct Evwma *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_evwma_reset(struct Evwma *handle); + +void wickra_evwma_free(struct Evwma *handle); + +struct FallingThreeMethods *wickra_falling_three_methods_new(void); + +double wickra_falling_three_methods_update(struct FallingThreeMethods *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_falling_three_methods_batch(struct FallingThreeMethods *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_falling_three_methods_reset(struct FallingThreeMethods *handle); + +void wickra_falling_three_methods_free(struct FallingThreeMethods *handle); + +struct FlagPennant *wickra_flag_pennant_new(void); + +double wickra_flag_pennant_update(struct FlagPennant *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_flag_pennant_batch(struct FlagPennant *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_flag_pennant_reset(struct FlagPennant *handle); + +void wickra_flag_pennant_free(struct FlagPennant *handle); + +struct ForceIndex *wickra_force_index_new(uintptr_t period); + +double wickra_force_index_update(struct ForceIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_force_index_batch(struct ForceIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_force_index_reset(struct ForceIndex *handle); + +void wickra_force_index_free(struct ForceIndex *handle); + +struct FryPanBottom *wickra_fry_pan_bottom_new(uintptr_t period); + +double wickra_fry_pan_bottom_update(struct FryPanBottom *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_fry_pan_bottom_batch(struct FryPanBottom *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_fry_pan_bottom_reset(struct FryPanBottom *handle); + +void wickra_fry_pan_bottom_free(struct FryPanBottom *handle); + +struct GapSideBySideWhite *wickra_gap_side_by_side_white_new(void); + +double wickra_gap_side_by_side_white_update(struct GapSideBySideWhite *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_gap_side_by_side_white_batch(struct GapSideBySideWhite *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_gap_side_by_side_white_reset(struct GapSideBySideWhite *handle); + +void wickra_gap_side_by_side_white_free(struct GapSideBySideWhite *handle); + +struct GarmanKlassVolatility *wickra_garman_klass_volatility_new(uintptr_t period, + uintptr_t trading_periods); + +double wickra_garman_klass_volatility_update(struct GarmanKlassVolatility *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_garman_klass_volatility_batch(struct GarmanKlassVolatility *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_garman_klass_volatility_reset(struct GarmanKlassVolatility *handle); + +void wickra_garman_klass_volatility_free(struct GarmanKlassVolatility *handle); + +struct Gartley *wickra_gartley_new(void); + +double wickra_gartley_update(struct Gartley *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_gartley_batch(struct Gartley *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_gartley_reset(struct Gartley *handle); + +void wickra_gartley_free(struct Gartley *handle); + +struct GravestoneDoji *wickra_gravestone_doji_new(void); + +double wickra_gravestone_doji_update(struct GravestoneDoji *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_gravestone_doji_batch(struct GravestoneDoji *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_gravestone_doji_reset(struct GravestoneDoji *handle); + +void wickra_gravestone_doji_free(struct GravestoneDoji *handle); + +struct Hammer *wickra_hammer_new(void); + +double wickra_hammer_update(struct Hammer *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_hammer_batch(struct Hammer *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_hammer_reset(struct Hammer *handle); + +void wickra_hammer_free(struct Hammer *handle); + +struct HangingMan *wickra_hanging_man_new(void); + +double wickra_hanging_man_update(struct HangingMan *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_hanging_man_batch(struct HangingMan *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_hanging_man_reset(struct HangingMan *handle); + +void wickra_hanging_man_free(struct HangingMan *handle); + +struct Harami *wickra_harami_new(void); + +double wickra_harami_update(struct Harami *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_harami_batch(struct Harami *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_harami_reset(struct Harami *handle); + +void wickra_harami_free(struct Harami *handle); + +struct HaramiCross *wickra_harami_cross_new(void); + +double wickra_harami_cross_update(struct HaramiCross *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_harami_cross_batch(struct HaramiCross *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_harami_cross_reset(struct HaramiCross *handle); + +void wickra_harami_cross_free(struct HaramiCross *handle); + +struct HeadAndShoulders *wickra_head_and_shoulders_new(void); + +double wickra_head_and_shoulders_update(struct HeadAndShoulders *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_head_and_shoulders_batch(struct HeadAndShoulders *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_head_and_shoulders_reset(struct HeadAndShoulders *handle); + +void wickra_head_and_shoulders_free(struct HeadAndShoulders *handle); + +struct HeikinAshiOscillator *wickra_heikin_ashi_oscillator_new(uintptr_t period); + +double wickra_heikin_ashi_oscillator_update(struct HeikinAshiOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_heikin_ashi_oscillator_batch(struct HeikinAshiOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_heikin_ashi_oscillator_reset(struct HeikinAshiOscillator *handle); + +void wickra_heikin_ashi_oscillator_free(struct HeikinAshiOscillator *handle); + +struct HighLowRange *wickra_high_low_range_new(void); + +double wickra_high_low_range_update(struct HighLowRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_high_low_range_batch(struct HighLowRange *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_high_low_range_reset(struct HighLowRange *handle); + +void wickra_high_low_range_free(struct HighLowRange *handle); + +struct HighWave *wickra_high_wave_new(void); + +double wickra_high_wave_update(struct HighWave *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_high_wave_batch(struct HighWave *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_high_wave_reset(struct HighWave *handle); + +void wickra_high_wave_free(struct HighWave *handle); + +struct Hikkake *wickra_hikkake_new(void); + +double wickra_hikkake_update(struct Hikkake *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_hikkake_batch(struct Hikkake *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_hikkake_reset(struct Hikkake *handle); + +void wickra_hikkake_free(struct Hikkake *handle); + +struct HikkakeModified *wickra_hikkake_modified_new(void); + +double wickra_hikkake_modified_update(struct HikkakeModified *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_hikkake_modified_batch(struct HikkakeModified *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_hikkake_modified_reset(struct HikkakeModified *handle); + +void wickra_hikkake_modified_free(struct HikkakeModified *handle); + +struct HiLoActivator *wickra_hi_lo_activator_new(uintptr_t period); + +double wickra_hi_lo_activator_update(struct HiLoActivator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_hi_lo_activator_batch(struct HiLoActivator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_hi_lo_activator_reset(struct HiLoActivator *handle); + +void wickra_hi_lo_activator_free(struct HiLoActivator *handle); + +struct HomingPigeon *wickra_homing_pigeon_new(void); + +double wickra_homing_pigeon_update(struct HomingPigeon *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_homing_pigeon_batch(struct HomingPigeon *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_homing_pigeon_reset(struct HomingPigeon *handle); + +void wickra_homing_pigeon_free(struct HomingPigeon *handle); + +struct IdenticalThreeCrows *wickra_identical_three_crows_new(void); + +double wickra_identical_three_crows_update(struct IdenticalThreeCrows *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_identical_three_crows_batch(struct IdenticalThreeCrows *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_identical_three_crows_reset(struct IdenticalThreeCrows *handle); + +void wickra_identical_three_crows_free(struct IdenticalThreeCrows *handle); + +struct InNeck *wickra_in_neck_new(void); + +double wickra_in_neck_update(struct InNeck *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_in_neck_batch(struct InNeck *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_in_neck_reset(struct InNeck *handle); + +void wickra_in_neck_free(struct InNeck *handle); + +struct Inertia *wickra_inertia_new(uintptr_t rvi_period, uintptr_t linreg_period); + +double wickra_inertia_update(struct Inertia *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_inertia_batch(struct Inertia *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_inertia_reset(struct Inertia *handle); + +void wickra_inertia_free(struct Inertia *handle); + +struct IntradayIntensity *wickra_intraday_intensity_new(void); + +double wickra_intraday_intensity_update(struct IntradayIntensity *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_intraday_intensity_batch(struct IntradayIntensity *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_intraday_intensity_reset(struct IntradayIntensity *handle); + +void wickra_intraday_intensity_free(struct IntradayIntensity *handle); + +struct IntradayMomentumIndex *wickra_intraday_momentum_index_new(uintptr_t period); + +double wickra_intraday_momentum_index_update(struct IntradayMomentumIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_intraday_momentum_index_batch(struct IntradayMomentumIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_intraday_momentum_index_reset(struct IntradayMomentumIndex *handle); + +void wickra_intraday_momentum_index_free(struct IntradayMomentumIndex *handle); + +struct InvertedHammer *wickra_inverted_hammer_new(void); + +double wickra_inverted_hammer_update(struct InvertedHammer *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_inverted_hammer_batch(struct InvertedHammer *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_inverted_hammer_reset(struct InvertedHammer *handle); + +void wickra_inverted_hammer_free(struct InvertedHammer *handle); + +struct Kicking *wickra_kicking_new(void); + +double wickra_kicking_update(struct Kicking *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_kicking_batch(struct Kicking *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_kicking_reset(struct Kicking *handle); + +void wickra_kicking_free(struct Kicking *handle); + +struct KickingByLength *wickra_kicking_by_length_new(void); + +double wickra_kicking_by_length_update(struct KickingByLength *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_kicking_by_length_batch(struct KickingByLength *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_kicking_by_length_reset(struct KickingByLength *handle); + +void wickra_kicking_by_length_free(struct KickingByLength *handle); + +struct Kvo *wickra_kvo_new(uintptr_t fast, uintptr_t slow); + +double wickra_kvo_update(struct Kvo *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_kvo_batch(struct Kvo *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_kvo_reset(struct Kvo *handle); + +void wickra_kvo_free(struct Kvo *handle); + +struct LadderBottom *wickra_ladder_bottom_new(void); + +double wickra_ladder_bottom_update(struct LadderBottom *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_ladder_bottom_batch(struct LadderBottom *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_ladder_bottom_reset(struct LadderBottom *handle); + +void wickra_ladder_bottom_free(struct LadderBottom *handle); + +struct LongLeggedDoji *wickra_long_legged_doji_new(void); + +double wickra_long_legged_doji_update(struct LongLeggedDoji *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_long_legged_doji_batch(struct LongLeggedDoji *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_long_legged_doji_reset(struct LongLeggedDoji *handle); + +void wickra_long_legged_doji_free(struct LongLeggedDoji *handle); + +struct LongLine *wickra_long_line_new(void); + +double wickra_long_line_update(struct LongLine *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_long_line_batch(struct LongLine *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_long_line_reset(struct LongLine *handle); + +void wickra_long_line_free(struct LongLine *handle); + +struct MarketFacilitationIndex *wickra_market_facilitation_index_new(void); + +double wickra_market_facilitation_index_update(struct MarketFacilitationIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_market_facilitation_index_batch(struct MarketFacilitationIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_market_facilitation_index_reset(struct MarketFacilitationIndex *handle); + +void wickra_market_facilitation_index_free(struct MarketFacilitationIndex *handle); + +struct Marubozu *wickra_marubozu_new(void); + +double wickra_marubozu_update(struct Marubozu *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_marubozu_batch(struct Marubozu *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_marubozu_reset(struct Marubozu *handle); + +void wickra_marubozu_free(struct Marubozu *handle); + +struct MassIndex *wickra_mass_index_new(uintptr_t ema_period, uintptr_t sum_period); + +double wickra_mass_index_update(struct MassIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_mass_index_batch(struct MassIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_mass_index_reset(struct MassIndex *handle); + +void wickra_mass_index_free(struct MassIndex *handle); + +struct MatHold *wickra_mat_hold_new(void); + +double wickra_mat_hold_update(struct MatHold *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_mat_hold_batch(struct MatHold *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_mat_hold_reset(struct MatHold *handle); + +void wickra_mat_hold_free(struct MatHold *handle); + +struct MatchingLow *wickra_matching_low_new(void); + +double wickra_matching_low_update(struct MatchingLow *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_matching_low_batch(struct MatchingLow *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_matching_low_reset(struct MatchingLow *handle); + +void wickra_matching_low_free(struct MatchingLow *handle); + +struct MedianPrice *wickra_median_price_new(void); + +double wickra_median_price_update(struct MedianPrice *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_median_price_batch(struct MedianPrice *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_median_price_reset(struct MedianPrice *handle); + +void wickra_median_price_free(struct MedianPrice *handle); + +struct Mfi *wickra_mfi_new(uintptr_t period); + +double wickra_mfi_update(struct Mfi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_mfi_batch(struct Mfi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_mfi_reset(struct Mfi *handle); + +void wickra_mfi_free(struct Mfi *handle); + +struct MidPrice *wickra_mid_price_new(uintptr_t period); + +double wickra_mid_price_update(struct MidPrice *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_mid_price_batch(struct MidPrice *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_mid_price_reset(struct MidPrice *handle); + +void wickra_mid_price_free(struct MidPrice *handle); + +struct MinusDi *wickra_minus_di_new(uintptr_t period); + +double wickra_minus_di_update(struct MinusDi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_minus_di_batch(struct MinusDi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_minus_di_reset(struct MinusDi *handle); + +void wickra_minus_di_free(struct MinusDi *handle); + +struct MinusDm *wickra_minus_dm_new(uintptr_t period); + +double wickra_minus_dm_update(struct MinusDm *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_minus_dm_batch(struct MinusDm *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_minus_dm_reset(struct MinusDm *handle); + +void wickra_minus_dm_free(struct MinusDm *handle); + +struct MorningDojiStar *wickra_morning_doji_star_new(void); + +double wickra_morning_doji_star_update(struct MorningDojiStar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_morning_doji_star_batch(struct MorningDojiStar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_morning_doji_star_reset(struct MorningDojiStar *handle); + +void wickra_morning_doji_star_free(struct MorningDojiStar *handle); + +struct MorningEveningStar *wickra_morning_evening_star_new(void); + +double wickra_morning_evening_star_update(struct MorningEveningStar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_morning_evening_star_batch(struct MorningEveningStar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_morning_evening_star_reset(struct MorningEveningStar *handle); + +void wickra_morning_evening_star_free(struct MorningEveningStar *handle); + +struct NakedPoc *wickra_naked_poc_new(uintptr_t session_len, uintptr_t bins); + +double wickra_naked_poc_update(struct NakedPoc *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_naked_poc_batch(struct NakedPoc *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_naked_poc_reset(struct NakedPoc *handle); + +void wickra_naked_poc_free(struct NakedPoc *handle); + +struct Natr *wickra_natr_new(uintptr_t period); + +double wickra_natr_update(struct Natr *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_natr_batch(struct Natr *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_natr_reset(struct Natr *handle); + +void wickra_natr_free(struct Natr *handle); + +struct NewPriceLines *wickra_new_price_lines_new(uintptr_t count); + +double wickra_new_price_lines_update(struct NewPriceLines *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_new_price_lines_batch(struct NewPriceLines *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_new_price_lines_reset(struct NewPriceLines *handle); + +void wickra_new_price_lines_free(struct NewPriceLines *handle); + +struct Nvi *wickra_nvi_new(void); + +double wickra_nvi_update(struct Nvi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_nvi_batch(struct Nvi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_nvi_reset(struct Nvi *handle); + +void wickra_nvi_free(struct Nvi *handle); + +struct Obv *wickra_obv_new(void); + +double wickra_obv_update(struct Obv *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_obv_batch(struct Obv *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_obv_reset(struct Obv *handle); + +void wickra_obv_free(struct Obv *handle); + +struct OnNeck *wickra_on_neck_new(void); + +double wickra_on_neck_update(struct OnNeck *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_on_neck_batch(struct OnNeck *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_on_neck_reset(struct OnNeck *handle); + +void wickra_on_neck_free(struct OnNeck *handle); + +struct OpeningMarubozu *wickra_opening_marubozu_new(void); + +double wickra_opening_marubozu_update(struct OpeningMarubozu *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_opening_marubozu_batch(struct OpeningMarubozu *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_opening_marubozu_reset(struct OpeningMarubozu *handle); + +void wickra_opening_marubozu_free(struct OpeningMarubozu *handle); + +struct OvernightGap *wickra_overnight_gap_new(int32_t utc_offset_minutes); + +double wickra_overnight_gap_update(struct OvernightGap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_overnight_gap_batch(struct OvernightGap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_overnight_gap_reset(struct OvernightGap *handle); + +void wickra_overnight_gap_free(struct OvernightGap *handle); + +struct ParkinsonVolatility *wickra_parkinson_volatility_new(uintptr_t period, + uintptr_t trading_periods); + +double wickra_parkinson_volatility_update(struct ParkinsonVolatility *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_parkinson_volatility_batch(struct ParkinsonVolatility *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_parkinson_volatility_reset(struct ParkinsonVolatility *handle); + +void wickra_parkinson_volatility_free(struct ParkinsonVolatility *handle); + +struct Pgo *wickra_pgo_new(uintptr_t period); + +double wickra_pgo_update(struct Pgo *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_pgo_batch(struct Pgo *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_pgo_reset(struct Pgo *handle); + +void wickra_pgo_free(struct Pgo *handle); + +struct PiercingDarkCloud *wickra_piercing_dark_cloud_new(void); + +double wickra_piercing_dark_cloud_update(struct PiercingDarkCloud *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_piercing_dark_cloud_batch(struct PiercingDarkCloud *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_piercing_dark_cloud_reset(struct PiercingDarkCloud *handle); + +void wickra_piercing_dark_cloud_free(struct PiercingDarkCloud *handle); + +struct PivotReversal *wickra_pivot_reversal_new(uintptr_t left, uintptr_t right); + +double wickra_pivot_reversal_update(struct PivotReversal *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_pivot_reversal_batch(struct PivotReversal *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_pivot_reversal_reset(struct PivotReversal *handle); + +void wickra_pivot_reversal_free(struct PivotReversal *handle); + +struct PlusDi *wickra_plus_di_new(uintptr_t period); + +double wickra_plus_di_update(struct PlusDi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_plus_di_batch(struct PlusDi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_plus_di_reset(struct PlusDi *handle); + +void wickra_plus_di_free(struct PlusDi *handle); + +struct PlusDm *wickra_plus_dm_new(uintptr_t period); + +double wickra_plus_dm_update(struct PlusDm *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_plus_dm_batch(struct PlusDm *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_plus_dm_reset(struct PlusDm *handle); + +void wickra_plus_dm_free(struct PlusDm *handle); + +struct ProfileShape *wickra_profile_shape_new(uintptr_t period, uintptr_t bins); + +double wickra_profile_shape_update(struct ProfileShape *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_profile_shape_batch(struct ProfileShape *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_profile_shape_reset(struct ProfileShape *handle); + +void wickra_profile_shape_free(struct ProfileShape *handle); + +struct ProjectionOscillator *wickra_projection_oscillator_new(uintptr_t period); + +double wickra_projection_oscillator_update(struct ProjectionOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_projection_oscillator_batch(struct ProjectionOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_projection_oscillator_reset(struct ProjectionOscillator *handle); + +void wickra_projection_oscillator_free(struct ProjectionOscillator *handle); + +struct Psar *wickra_psar_new(double af_start, double af_step, double af_max); + +double wickra_psar_update(struct Psar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_psar_batch(struct Psar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_psar_reset(struct Psar *handle); + +void wickra_psar_free(struct Psar *handle); + +struct Pvi *wickra_pvi_new(void); + +double wickra_pvi_update(struct Pvi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_pvi_batch(struct Pvi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_pvi_reset(struct Pvi *handle); + +void wickra_pvi_free(struct Pvi *handle); + +struct Qstick *wickra_qstick_new(uintptr_t period); + +double wickra_qstick_update(struct Qstick *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_qstick_batch(struct Qstick *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_qstick_reset(struct Qstick *handle); + +void wickra_qstick_free(struct Qstick *handle); + +struct RectangleRange *wickra_rectangle_range_new(void); + +double wickra_rectangle_range_update(struct RectangleRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_rectangle_range_batch(struct RectangleRange *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_rectangle_range_reset(struct RectangleRange *handle); + +void wickra_rectangle_range_free(struct RectangleRange *handle); + +struct RickshawMan *wickra_rickshaw_man_new(void); + +double wickra_rickshaw_man_update(struct RickshawMan *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_rickshaw_man_batch(struct RickshawMan *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_rickshaw_man_reset(struct RickshawMan *handle); + +void wickra_rickshaw_man_free(struct RickshawMan *handle); + +struct RisingThreeMethods *wickra_rising_three_methods_new(void); + +double wickra_rising_three_methods_update(struct RisingThreeMethods *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_rising_three_methods_batch(struct RisingThreeMethods *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_rising_three_methods_reset(struct RisingThreeMethods *handle); + +void wickra_rising_three_methods_free(struct RisingThreeMethods *handle); + +struct RogersSatchellVolatility *wickra_rogers_satchell_volatility_new(uintptr_t period, + uintptr_t trading_periods); + +double wickra_rogers_satchell_volatility_update(struct RogersSatchellVolatility *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_rogers_satchell_volatility_batch(struct RogersSatchellVolatility *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_rogers_satchell_volatility_reset(struct RogersSatchellVolatility *handle); + +void wickra_rogers_satchell_volatility_free(struct RogersSatchellVolatility *handle); + +struct Rvi *wickra_rvi_new(uintptr_t period); + +double wickra_rvi_update(struct Rvi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_rvi_batch(struct Rvi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_rvi_reset(struct Rvi *handle); + +void wickra_rvi_free(struct Rvi *handle); + +struct SarExt *wickra_sar_ext_new(double start_value, + double offset_on_reverse, + double accel_init_long, + double accel_long, + double accel_max_long, + double accel_init_short, + double accel_short, + double accel_max_short); + +double wickra_sar_ext_update(struct SarExt *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_sar_ext_batch(struct SarExt *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_sar_ext_reset(struct SarExt *handle); + +void wickra_sar_ext_free(struct SarExt *handle); + +struct SeasonalZScore *wickra_seasonal_z_score_new(int32_t utc_offset_minutes); + +double wickra_seasonal_z_score_update(struct SeasonalZScore *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_seasonal_z_score_batch(struct SeasonalZScore *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_seasonal_z_score_reset(struct SeasonalZScore *handle); + +void wickra_seasonal_z_score_free(struct SeasonalZScore *handle); + +struct SeparatingLines *wickra_separating_lines_new(void); + +double wickra_separating_lines_update(struct SeparatingLines *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_separating_lines_batch(struct SeparatingLines *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_separating_lines_reset(struct SeparatingLines *handle); + +void wickra_separating_lines_free(struct SeparatingLines *handle); + +struct SessionVwap *wickra_session_vwap_new(int32_t utc_offset_minutes); + +double wickra_session_vwap_update(struct SessionVwap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_session_vwap_batch(struct SessionVwap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_session_vwap_reset(struct SessionVwap *handle); + +void wickra_session_vwap_free(struct SessionVwap *handle); + +struct Shark *wickra_shark_new(void); + +double wickra_shark_update(struct Shark *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_shark_batch(struct Shark *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_shark_reset(struct Shark *handle); + +void wickra_shark_free(struct Shark *handle); + +struct ShootingStar *wickra_shooting_star_new(void); + +double wickra_shooting_star_update(struct ShootingStar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_shooting_star_batch(struct ShootingStar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_shooting_star_reset(struct ShootingStar *handle); + +void wickra_shooting_star_free(struct ShootingStar *handle); + +struct ShortLine *wickra_short_line_new(void); + +double wickra_short_line_update(struct ShortLine *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_short_line_batch(struct ShortLine *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_short_line_reset(struct ShortLine *handle); + +void wickra_short_line_free(struct ShortLine *handle); + +struct SinglePrints *wickra_single_prints_new(uintptr_t period, uintptr_t bins); + +double wickra_single_prints_update(struct SinglePrints *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_single_prints_batch(struct SinglePrints *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_single_prints_reset(struct SinglePrints *handle); + +void wickra_single_prints_free(struct SinglePrints *handle); + +struct Smi *wickra_smi_new(uintptr_t period, uintptr_t d_period, uintptr_t d2_period); + +double wickra_smi_update(struct Smi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_smi_batch(struct Smi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_smi_reset(struct Smi *handle); + +void wickra_smi_free(struct Smi *handle); + +struct SpinningTop *wickra_spinning_top_new(void); + +double wickra_spinning_top_update(struct SpinningTop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_spinning_top_batch(struct SpinningTop *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_spinning_top_reset(struct SpinningTop *handle); + +void wickra_spinning_top_free(struct SpinningTop *handle); + +struct StalledPattern *wickra_stalled_pattern_new(void); + +double wickra_stalled_pattern_update(struct StalledPattern *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_stalled_pattern_batch(struct StalledPattern *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_stalled_pattern_reset(struct StalledPattern *handle); + +void wickra_stalled_pattern_free(struct StalledPattern *handle); + +struct StickSandwich *wickra_stick_sandwich_new(void); + +double wickra_stick_sandwich_update(struct StickSandwich *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_stick_sandwich_batch(struct StickSandwich *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_stick_sandwich_reset(struct StickSandwich *handle); + +void wickra_stick_sandwich_free(struct StickSandwich *handle); + +struct StochasticCci *wickra_stochastic_cci_new(uintptr_t period); + +double wickra_stochastic_cci_update(struct StochasticCci *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_stochastic_cci_batch(struct StochasticCci *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_stochastic_cci_reset(struct StochasticCci *handle); + +void wickra_stochastic_cci_free(struct StochasticCci *handle); + +struct Takuri *wickra_takuri_new(void); + +double wickra_takuri_update(struct Takuri *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_takuri_batch(struct Takuri *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_takuri_reset(struct Takuri *handle); + +void wickra_takuri_free(struct Takuri *handle); + +struct TasukiGap *wickra_tasuki_gap_new(void); + +double wickra_tasuki_gap_update(struct TasukiGap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_tasuki_gap_batch(struct TasukiGap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_tasuki_gap_reset(struct TasukiGap *handle); + +void wickra_tasuki_gap_free(struct TasukiGap *handle); + +struct TdCamouflage *wickra_td_camouflage_new(void); + +double wickra_td_camouflage_update(struct TdCamouflage *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_camouflage_batch(struct TdCamouflage *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_camouflage_reset(struct TdCamouflage *handle); + +void wickra_td_camouflage_free(struct TdCamouflage *handle); + +struct TdClop *wickra_td_clop_new(void); + +double wickra_td_clop_update(struct TdClop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_clop_batch(struct TdClop *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_clop_reset(struct TdClop *handle); + +void wickra_td_clop_free(struct TdClop *handle); + +struct TdClopwin *wickra_td_clopwin_new(void); + +double wickra_td_clopwin_update(struct TdClopwin *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_clopwin_batch(struct TdClopwin *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_clopwin_reset(struct TdClopwin *handle); + +void wickra_td_clopwin_free(struct TdClopwin *handle); + +struct TdCombo *wickra_td_combo_new(uintptr_t setup_lookback, + uintptr_t setup_target, + uintptr_t countdown_lookback, + uintptr_t countdown_target); + +double wickra_td_combo_update(struct TdCombo *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_combo_batch(struct TdCombo *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_combo_reset(struct TdCombo *handle); + +void wickra_td_combo_free(struct TdCombo *handle); + +struct TdCountdown *wickra_td_countdown_new(uintptr_t setup_lookback, + uintptr_t setup_target, + uintptr_t countdown_lookback, + uintptr_t countdown_target); + +double wickra_td_countdown_update(struct TdCountdown *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_countdown_batch(struct TdCountdown *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_countdown_reset(struct TdCountdown *handle); + +void wickra_td_countdown_free(struct TdCountdown *handle); + +struct TdDeMarker *wickra_td_de_marker_new(uintptr_t period); + +double wickra_td_de_marker_update(struct TdDeMarker *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_de_marker_batch(struct TdDeMarker *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_de_marker_reset(struct TdDeMarker *handle); + +void wickra_td_de_marker_free(struct TdDeMarker *handle); + +struct TdDifferential *wickra_td_differential_new(void); + +double wickra_td_differential_update(struct TdDifferential *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_differential_batch(struct TdDifferential *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_differential_reset(struct TdDifferential *handle); + +void wickra_td_differential_free(struct TdDifferential *handle); + +struct TdDWave *wickra_td_d_wave_new(uintptr_t strength); + +double wickra_td_d_wave_update(struct TdDWave *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_d_wave_batch(struct TdDWave *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_d_wave_reset(struct TdDWave *handle); + +void wickra_td_d_wave_free(struct TdDWave *handle); + +struct TdOpen *wickra_td_open_new(void); + +double wickra_td_open_update(struct TdOpen *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_open_batch(struct TdOpen *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_open_reset(struct TdOpen *handle); + +void wickra_td_open_free(struct TdOpen *handle); + +struct TdPressure *wickra_td_pressure_new(uintptr_t period); + +double wickra_td_pressure_update(struct TdPressure *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_pressure_batch(struct TdPressure *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_pressure_reset(struct TdPressure *handle); + +void wickra_td_pressure_free(struct TdPressure *handle); + +struct TdPropulsion *wickra_td_propulsion_new(void); + +double wickra_td_propulsion_update(struct TdPropulsion *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_propulsion_batch(struct TdPropulsion *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_propulsion_reset(struct TdPropulsion *handle); + +void wickra_td_propulsion_free(struct TdPropulsion *handle); + +struct TdRei *wickra_td_rei_new(uintptr_t period); + +double wickra_td_rei_update(struct TdRei *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_rei_batch(struct TdRei *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_rei_reset(struct TdRei *handle); + +void wickra_td_rei_free(struct TdRei *handle); + +struct TdSetup *wickra_td_setup_new(uintptr_t lookback, uintptr_t target); + +double wickra_td_setup_update(struct TdSetup *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_setup_batch(struct TdSetup *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_setup_reset(struct TdSetup *handle); + +void wickra_td_setup_free(struct TdSetup *handle); + +struct TdTrap *wickra_td_trap_new(void); + +double wickra_td_trap_update(struct TdTrap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_td_trap_batch(struct TdTrap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_td_trap_reset(struct TdTrap *handle); + +void wickra_td_trap_free(struct TdTrap *handle); + +struct ThreeDrives *wickra_three_drives_new(void); + +double wickra_three_drives_update(struct ThreeDrives *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_drives_batch(struct ThreeDrives *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_drives_reset(struct ThreeDrives *handle); + +void wickra_three_drives_free(struct ThreeDrives *handle); + +struct ThreeInside *wickra_three_inside_new(void); + +double wickra_three_inside_update(struct ThreeInside *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_inside_batch(struct ThreeInside *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_inside_reset(struct ThreeInside *handle); + +void wickra_three_inside_free(struct ThreeInside *handle); + +struct ThreeLineBreak *wickra_three_line_break_new(uintptr_t lines); + +double wickra_three_line_break_update(struct ThreeLineBreak *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_line_break_batch(struct ThreeLineBreak *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_line_break_reset(struct ThreeLineBreak *handle); + +void wickra_three_line_break_free(struct ThreeLineBreak *handle); + +struct ThreeLineStrike *wickra_three_line_strike_new(void); + +double wickra_three_line_strike_update(struct ThreeLineStrike *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_line_strike_batch(struct ThreeLineStrike *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_line_strike_reset(struct ThreeLineStrike *handle); + +void wickra_three_line_strike_free(struct ThreeLineStrike *handle); + +struct ThreeOutside *wickra_three_outside_new(void); + +double wickra_three_outside_update(struct ThreeOutside *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_outside_batch(struct ThreeOutside *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_outside_reset(struct ThreeOutside *handle); + +void wickra_three_outside_free(struct ThreeOutside *handle); + +struct ThreeSoldiersOrCrows *wickra_three_soldiers_or_crows_new(void); + +double wickra_three_soldiers_or_crows_update(struct ThreeSoldiersOrCrows *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_soldiers_or_crows_batch(struct ThreeSoldiersOrCrows *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_soldiers_or_crows_reset(struct ThreeSoldiersOrCrows *handle); + +void wickra_three_soldiers_or_crows_free(struct ThreeSoldiersOrCrows *handle); + +struct ThreeStarsInSouth *wickra_three_stars_in_south_new(void); + +double wickra_three_stars_in_south_update(struct ThreeStarsInSouth *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_three_stars_in_south_batch(struct ThreeStarsInSouth *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_three_stars_in_south_reset(struct ThreeStarsInSouth *handle); + +void wickra_three_stars_in_south_free(struct ThreeStarsInSouth *handle); + +struct Thrusting *wickra_thrusting_new(void); + +double wickra_thrusting_update(struct Thrusting *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_thrusting_batch(struct Thrusting *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_thrusting_reset(struct Thrusting *handle); + +void wickra_thrusting_free(struct Thrusting *handle); + +struct TimeBasedStop *wickra_time_based_stop_new(uintptr_t max_bars); + +double wickra_time_based_stop_update(struct TimeBasedStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_time_based_stop_batch(struct TimeBasedStop *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_time_based_stop_reset(struct TimeBasedStop *handle); + +void wickra_time_based_stop_free(struct TimeBasedStop *handle); + +struct TowerTopBottom *wickra_tower_top_bottom_new(void); + +double wickra_tower_top_bottom_update(struct TowerTopBottom *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_tower_top_bottom_batch(struct TowerTopBottom *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_tower_top_bottom_reset(struct TowerTopBottom *handle); + +void wickra_tower_top_bottom_free(struct TowerTopBottom *handle); + +struct TradeVolumeIndex *wickra_trade_volume_index_new(double min_tick); + +double wickra_trade_volume_index_update(struct TradeVolumeIndex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_trade_volume_index_batch(struct TradeVolumeIndex *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_trade_volume_index_reset(struct TradeVolumeIndex *handle); + +void wickra_trade_volume_index_free(struct TradeVolumeIndex *handle); + +struct Triangle *wickra_triangle_new(void); + +double wickra_triangle_update(struct Triangle *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_triangle_batch(struct Triangle *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_triangle_reset(struct Triangle *handle); + +void wickra_triangle_free(struct Triangle *handle); + +struct TripleTopBottom *wickra_triple_top_bottom_new(void); + +double wickra_triple_top_bottom_update(struct TripleTopBottom *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_triple_top_bottom_batch(struct TripleTopBottom *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_triple_top_bottom_reset(struct TripleTopBottom *handle); + +void wickra_triple_top_bottom_free(struct TripleTopBottom *handle); + +struct Tristar *wickra_tristar_new(void); + +double wickra_tristar_update(struct Tristar *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_tristar_batch(struct Tristar *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_tristar_reset(struct Tristar *handle); + +void wickra_tristar_free(struct Tristar *handle); + +struct TrueRange *wickra_true_range_new(void); + +double wickra_true_range_update(struct TrueRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_true_range_batch(struct TrueRange *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_true_range_reset(struct TrueRange *handle); + +void wickra_true_range_free(struct TrueRange *handle); + +struct Tsv *wickra_tsv_new(uintptr_t period); + +double wickra_tsv_update(struct Tsv *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_tsv_batch(struct Tsv *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_tsv_reset(struct Tsv *handle); + +void wickra_tsv_free(struct Tsv *handle); + +struct TtmTrend *wickra_ttm_trend_new(uintptr_t period); + +double wickra_ttm_trend_update(struct TtmTrend *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_ttm_trend_batch(struct TtmTrend *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_ttm_trend_reset(struct TtmTrend *handle); + +void wickra_ttm_trend_free(struct TtmTrend *handle); + +struct TurnOfMonth *wickra_turn_of_month_new(uint32_t n_first, + uint32_t n_last, + int32_t utc_offset_minutes); + +double wickra_turn_of_month_update(struct TurnOfMonth *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_turn_of_month_batch(struct TurnOfMonth *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_turn_of_month_reset(struct TurnOfMonth *handle); + +void wickra_turn_of_month_free(struct TurnOfMonth *handle); + +struct Tweezer *wickra_tweezer_new(void); + +double wickra_tweezer_update(struct Tweezer *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_tweezer_batch(struct Tweezer *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_tweezer_reset(struct Tweezer *handle); + +void wickra_tweezer_free(struct Tweezer *handle); + +struct TwiggsMoneyFlow *wickra_twiggs_money_flow_new(uintptr_t period); + +double wickra_twiggs_money_flow_update(struct TwiggsMoneyFlow *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_twiggs_money_flow_batch(struct TwiggsMoneyFlow *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_twiggs_money_flow_reset(struct TwiggsMoneyFlow *handle); + +void wickra_twiggs_money_flow_free(struct TwiggsMoneyFlow *handle); + +struct TwoCrows *wickra_two_crows_new(void); + +double wickra_two_crows_update(struct TwoCrows *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_two_crows_batch(struct TwoCrows *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_two_crows_reset(struct TwoCrows *handle); + +void wickra_two_crows_free(struct TwoCrows *handle); + +struct TypicalPrice *wickra_typical_price_new(void); + +double wickra_typical_price_update(struct TypicalPrice *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_typical_price_batch(struct TypicalPrice *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_typical_price_reset(struct TypicalPrice *handle); + +void wickra_typical_price_free(struct TypicalPrice *handle); + +struct UltimateOscillator *wickra_ultimate_oscillator_new(uintptr_t short_, + uintptr_t mid, + uintptr_t long_); + +double wickra_ultimate_oscillator_update(struct UltimateOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_ultimate_oscillator_batch(struct UltimateOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_ultimate_oscillator_reset(struct UltimateOscillator *handle); + +void wickra_ultimate_oscillator_free(struct UltimateOscillator *handle); + +struct UniqueThreeRiver *wickra_unique_three_river_new(void); + +double wickra_unique_three_river_update(struct UniqueThreeRiver *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_unique_three_river_batch(struct UniqueThreeRiver *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_unique_three_river_reset(struct UniqueThreeRiver *handle); + +void wickra_unique_three_river_free(struct UniqueThreeRiver *handle); + +struct UpsideGapThreeMethods *wickra_upside_gap_three_methods_new(void); + +double wickra_upside_gap_three_methods_update(struct UpsideGapThreeMethods *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_upside_gap_three_methods_batch(struct UpsideGapThreeMethods *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_upside_gap_three_methods_reset(struct UpsideGapThreeMethods *handle); + +void wickra_upside_gap_three_methods_free(struct UpsideGapThreeMethods *handle); + +struct UpsideGapTwoCrows *wickra_upside_gap_two_crows_new(void); + +double wickra_upside_gap_two_crows_update(struct UpsideGapTwoCrows *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_upside_gap_two_crows_batch(struct UpsideGapTwoCrows *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_upside_gap_two_crows_reset(struct UpsideGapTwoCrows *handle); + +void wickra_upside_gap_two_crows_free(struct UpsideGapTwoCrows *handle); + +struct VolatilityRatio *wickra_volatility_ratio_new(uintptr_t period); + +double wickra_volatility_ratio_update(struct VolatilityRatio *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_volatility_ratio_batch(struct VolatilityRatio *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_volatility_ratio_reset(struct VolatilityRatio *handle); + +void wickra_volatility_ratio_free(struct VolatilityRatio *handle); + +struct VoltyStop *wickra_volty_stop_new(uintptr_t atr_period, double multiplier); + +double wickra_volty_stop_update(struct VoltyStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_volty_stop_batch(struct VoltyStop *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_volty_stop_reset(struct VoltyStop *handle); + +void wickra_volty_stop_free(struct VoltyStop *handle); + +struct VolumeOscillator *wickra_volume_oscillator_new(uintptr_t fast, uintptr_t slow); + +double wickra_volume_oscillator_update(struct VolumeOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_volume_oscillator_batch(struct VolumeOscillator *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_volume_oscillator_reset(struct VolumeOscillator *handle); + +void wickra_volume_oscillator_free(struct VolumeOscillator *handle); + +struct VolumeRsi *wickra_volume_rsi_new(uintptr_t period); + +double wickra_volume_rsi_update(struct VolumeRsi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_volume_rsi_batch(struct VolumeRsi *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_volume_rsi_reset(struct VolumeRsi *handle); + +void wickra_volume_rsi_free(struct VolumeRsi *handle); + +struct VolumePriceTrend *wickra_volume_price_trend_new(void); + +double wickra_volume_price_trend_update(struct VolumePriceTrend *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_volume_price_trend_batch(struct VolumePriceTrend *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_volume_price_trend_reset(struct VolumePriceTrend *handle); + +void wickra_volume_price_trend_free(struct VolumePriceTrend *handle); + +struct Vwap *wickra_vwap_new(void); + +double wickra_vwap_update(struct Vwap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_vwap_batch(struct Vwap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_vwap_reset(struct Vwap *handle); + +void wickra_vwap_free(struct Vwap *handle); + +struct RollingVwap *wickra_rolling_vwap_new(uintptr_t period); + +double wickra_rolling_vwap_update(struct RollingVwap *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_rolling_vwap_batch(struct RollingVwap *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_rolling_vwap_reset(struct RollingVwap *handle); + +void wickra_rolling_vwap_free(struct RollingVwap *handle); + +struct Vwma *wickra_vwma_new(uintptr_t period); + +double wickra_vwma_update(struct Vwma *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_vwma_batch(struct Vwma *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_vwma_reset(struct Vwma *handle); + +void wickra_vwma_free(struct Vwma *handle); + +struct Vzo *wickra_vzo_new(uintptr_t period); + +double wickra_vzo_update(struct Vzo *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_vzo_batch(struct Vzo *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_vzo_reset(struct Vzo *handle); + +void wickra_vzo_free(struct Vzo *handle); + +struct Wad *wickra_wad_new(void); + +double wickra_wad_update(struct Wad *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_wad_batch(struct Wad *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_wad_reset(struct Wad *handle); + +void wickra_wad_free(struct Wad *handle); + +struct Wedge *wickra_wedge_new(void); + +double wickra_wedge_update(struct Wedge *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_wedge_batch(struct Wedge *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_wedge_reset(struct Wedge *handle); + +void wickra_wedge_free(struct Wedge *handle); + +struct WeightedClose *wickra_weighted_close_new(void); + +double wickra_weighted_close_update(struct WeightedClose *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_weighted_close_batch(struct WeightedClose *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_weighted_close_reset(struct WeightedClose *handle); + +void wickra_weighted_close_free(struct WeightedClose *handle); + +struct WickRatio *wickra_wick_ratio_new(void); + +double wickra_wick_ratio_update(struct WickRatio *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_wick_ratio_batch(struct WickRatio *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_wick_ratio_reset(struct WickRatio *handle); + +void wickra_wick_ratio_free(struct WickRatio *handle); + +struct WilliamsR *wickra_williams_r_new(uintptr_t period); + +double wickra_williams_r_update(struct WilliamsR *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_williams_r_batch(struct WilliamsR *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_williams_r_reset(struct WilliamsR *handle); + +void wickra_williams_r_free(struct WilliamsR *handle); + +struct YangZhangVolatility *wickra_yang_zhang_volatility_new(uintptr_t period, + uintptr_t trading_periods); + +double wickra_yang_zhang_volatility_update(struct YangZhangVolatility *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_yang_zhang_volatility_batch(struct YangZhangVolatility *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_yang_zhang_volatility_reset(struct YangZhangVolatility *handle); + +void wickra_yang_zhang_volatility_free(struct YangZhangVolatility *handle); + +struct YoyoExit *wickra_yoyo_exit_new(uintptr_t atr_period, double multiplier); + +double wickra_yoyo_exit_update(struct YoyoExit *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp); + +void wickra_yoyo_exit_batch(struct YoyoExit *handle, + const double *open, + const double *high, + const double *low, + const double *close, + const double *volume, + const int64_t *timestamp, + double *out, + uintptr_t n); + +void wickra_yoyo_exit_reset(struct YoyoExit *handle); + +void wickra_yoyo_exit_free(struct YoyoExit *handle); + +struct AmihudIlliquidity *wickra_amihud_illiquidity_new(uintptr_t period); + +double wickra_amihud_illiquidity_update(struct AmihudIlliquidity *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_amihud_illiquidity_reset(struct AmihudIlliquidity *handle); + +void wickra_amihud_illiquidity_free(struct AmihudIlliquidity *handle); + +struct CumulativeVolumeDelta *wickra_cumulative_volume_delta_new(void); + +double wickra_cumulative_volume_delta_update(struct CumulativeVolumeDelta *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_cumulative_volume_delta_reset(struct CumulativeVolumeDelta *handle); + +void wickra_cumulative_volume_delta_free(struct CumulativeVolumeDelta *handle); + +struct Pin *wickra_pin_new(uintptr_t window); + +double wickra_pin_update(struct Pin *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_pin_reset(struct Pin *handle); + +void wickra_pin_free(struct Pin *handle); + +struct RollMeasure *wickra_roll_measure_new(uintptr_t period); + +double wickra_roll_measure_update(struct RollMeasure *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_roll_measure_reset(struct RollMeasure *handle); + +void wickra_roll_measure_free(struct RollMeasure *handle); + +struct SignedVolume *wickra_signed_volume_new(void); + +double wickra_signed_volume_update(struct SignedVolume *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_signed_volume_reset(struct SignedVolume *handle); + +void wickra_signed_volume_free(struct SignedVolume *handle); + +struct TradeImbalance *wickra_trade_imbalance_new(uintptr_t window); + +double wickra_trade_imbalance_update(struct TradeImbalance *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_trade_imbalance_reset(struct TradeImbalance *handle); + +void wickra_trade_imbalance_free(struct TradeImbalance *handle); + +struct TradeSignAutocorrelation *wickra_trade_sign_autocorrelation_new(uintptr_t period); + +double wickra_trade_sign_autocorrelation_update(struct TradeSignAutocorrelation *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_trade_sign_autocorrelation_reset(struct TradeSignAutocorrelation *handle); + +void wickra_trade_sign_autocorrelation_free(struct TradeSignAutocorrelation *handle); + +struct Vpin *wickra_vpin_new(double bucket_volume, uintptr_t num_buckets); + +double wickra_vpin_update(struct Vpin *handle, + double price, + double size, + bool is_buy, + int64_t timestamp); + +void wickra_vpin_reset(struct Vpin *handle); + +void wickra_vpin_free(struct Vpin *handle); + +struct EffectiveSpread *wickra_effective_spread_new(void); + +double wickra_effective_spread_update(struct EffectiveSpread *handle, + double price, + double size, + bool is_buy, + int64_t timestamp, + double mid); + +void wickra_effective_spread_reset(struct EffectiveSpread *handle); + +void wickra_effective_spread_free(struct EffectiveSpread *handle); + +struct KylesLambda *wickra_kyles_lambda_new(uintptr_t window); + +double wickra_kyles_lambda_update(struct KylesLambda *handle, + double price, + double size, + bool is_buy, + int64_t timestamp, + double mid); + +void wickra_kyles_lambda_reset(struct KylesLambda *handle); + +void wickra_kyles_lambda_free(struct KylesLambda *handle); + +struct RealizedSpread *wickra_realized_spread_new(uintptr_t horizon); + +double wickra_realized_spread_update(struct RealizedSpread *handle, + double price, + double size, + bool is_buy, + int64_t timestamp, + double mid); + +void wickra_realized_spread_reset(struct RealizedSpread *handle); + +void wickra_realized_spread_free(struct RealizedSpread *handle); + +struct CalendarSpread *wickra_calendar_spread_new(void); + +double wickra_calendar_spread_update(struct CalendarSpread *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_calendar_spread_reset(struct CalendarSpread *handle); + +void wickra_calendar_spread_free(struct CalendarSpread *handle); + +struct EstimatedLeverageRatio *wickra_estimated_leverage_ratio_new(void); + +double wickra_estimated_leverage_ratio_update(struct EstimatedLeverageRatio *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_estimated_leverage_ratio_reset(struct EstimatedLeverageRatio *handle); + +void wickra_estimated_leverage_ratio_free(struct EstimatedLeverageRatio *handle); + +struct FundingBasis *wickra_funding_basis_new(void); + +double wickra_funding_basis_update(struct FundingBasis *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_funding_basis_reset(struct FundingBasis *handle); + +void wickra_funding_basis_free(struct FundingBasis *handle); + +struct FundingImpliedApr *wickra_funding_implied_apr_new(double intervals_per_year); + +double wickra_funding_implied_apr_update(struct FundingImpliedApr *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_funding_implied_apr_reset(struct FundingImpliedApr *handle); + +void wickra_funding_implied_apr_free(struct FundingImpliedApr *handle); + +struct FundingRate *wickra_funding_rate_new(void); + +double wickra_funding_rate_update(struct FundingRate *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_funding_rate_reset(struct FundingRate *handle); + +void wickra_funding_rate_free(struct FundingRate *handle); + +struct FundingRateMean *wickra_funding_rate_mean_new(uintptr_t window); + +double wickra_funding_rate_mean_update(struct FundingRateMean *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_funding_rate_mean_reset(struct FundingRateMean *handle); + +void wickra_funding_rate_mean_free(struct FundingRateMean *handle); + +struct FundingRateZScore *wickra_funding_rate_z_score_new(uintptr_t window); + +double wickra_funding_rate_z_score_update(struct FundingRateZScore *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_funding_rate_z_score_reset(struct FundingRateZScore *handle); + +void wickra_funding_rate_z_score_free(struct FundingRateZScore *handle); + +struct LongShortRatio *wickra_long_short_ratio_new(void); + +double wickra_long_short_ratio_update(struct LongShortRatio *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_long_short_ratio_reset(struct LongShortRatio *handle); + +void wickra_long_short_ratio_free(struct LongShortRatio *handle); + +struct OpenInterestDelta *wickra_open_interest_delta_new(void); + +double wickra_open_interest_delta_update(struct OpenInterestDelta *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_open_interest_delta_reset(struct OpenInterestDelta *handle); + +void wickra_open_interest_delta_free(struct OpenInterestDelta *handle); + +struct OIPriceDivergence *wickra_oi_price_divergence_new(uintptr_t window); + +double wickra_oi_price_divergence_update(struct OIPriceDivergence *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_oi_price_divergence_reset(struct OIPriceDivergence *handle); + +void wickra_oi_price_divergence_free(struct OIPriceDivergence *handle); + +struct OiToVolumeRatio *wickra_oi_to_volume_ratio_new(void); + +double wickra_oi_to_volume_ratio_update(struct OiToVolumeRatio *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_oi_to_volume_ratio_reset(struct OiToVolumeRatio *handle); + +void wickra_oi_to_volume_ratio_free(struct OiToVolumeRatio *handle); + +struct OIWeighted *wickra_oi_weighted_new(void); + +double wickra_oi_weighted_update(struct OIWeighted *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_oi_weighted_reset(struct OIWeighted *handle); + +void wickra_oi_weighted_free(struct OIWeighted *handle); + +struct OpenInterestMomentum *wickra_open_interest_momentum_new(uintptr_t period); + +double wickra_open_interest_momentum_update(struct OpenInterestMomentum *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_open_interest_momentum_reset(struct OpenInterestMomentum *handle); + +void wickra_open_interest_momentum_free(struct OpenInterestMomentum *handle); + +struct PerpetualPremiumIndex *wickra_perpetual_premium_index_new(void); + +double wickra_perpetual_premium_index_update(struct PerpetualPremiumIndex *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_perpetual_premium_index_reset(struct PerpetualPremiumIndex *handle); + +void wickra_perpetual_premium_index_free(struct PerpetualPremiumIndex *handle); + +struct TakerBuySellRatio *wickra_taker_buy_sell_ratio_new(void); + +double wickra_taker_buy_sell_ratio_update(struct TakerBuySellRatio *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_taker_buy_sell_ratio_reset(struct TakerBuySellRatio *handle); + +void wickra_taker_buy_sell_ratio_free(struct TakerBuySellRatio *handle); + +struct TermStructureBasis *wickra_term_structure_basis_new(void); + +double wickra_term_structure_basis_update(struct TermStructureBasis *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp); + +void wickra_term_structure_basis_reset(struct TermStructureBasis *handle); + +void wickra_term_structure_basis_free(struct TermStructureBasis *handle); + +struct DepthSlope *wickra_depth_slope_new(void); + +double wickra_depth_slope_update(struct DepthSlope *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_depth_slope_reset(struct DepthSlope *handle); + +void wickra_depth_slope_free(struct DepthSlope *handle); + +struct Microprice *wickra_microprice_new(void); + +double wickra_microprice_update(struct Microprice *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_microprice_reset(struct Microprice *handle); + +void wickra_microprice_free(struct Microprice *handle); + +struct OrderBookImbalanceFull *wickra_order_book_imbalance_full_new(void); + +double wickra_order_book_imbalance_full_update(struct OrderBookImbalanceFull *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_order_book_imbalance_full_reset(struct OrderBookImbalanceFull *handle); + +void wickra_order_book_imbalance_full_free(struct OrderBookImbalanceFull *handle); + +struct OrderBookImbalanceTop1 *wickra_order_book_imbalance_top1_new(void); + +double wickra_order_book_imbalance_top1_update(struct OrderBookImbalanceTop1 *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_order_book_imbalance_top1_reset(struct OrderBookImbalanceTop1 *handle); + +void wickra_order_book_imbalance_top1_free(struct OrderBookImbalanceTop1 *handle); + +struct OrderBookImbalanceTopN *wickra_order_book_imbalance_top_n_new(uintptr_t levels); + +double wickra_order_book_imbalance_top_n_update(struct OrderBookImbalanceTopN *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_order_book_imbalance_top_n_reset(struct OrderBookImbalanceTopN *handle); + +void wickra_order_book_imbalance_top_n_free(struct OrderBookImbalanceTopN *handle); + +struct OrderFlowImbalance *wickra_order_flow_imbalance_new(uintptr_t period); + +double wickra_order_flow_imbalance_update(struct OrderFlowImbalance *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_order_flow_imbalance_reset(struct OrderFlowImbalance *handle); + +void wickra_order_flow_imbalance_free(struct OrderFlowImbalance *handle); + +struct QuotedSpread *wickra_quoted_spread_new(void); + +double wickra_quoted_spread_update(struct QuotedSpread *handle, + const double *bid_price, + const double *bid_size, + uintptr_t n_bids, + const double *ask_price, + const double *ask_size, + uintptr_t n_asks); + +void wickra_quoted_spread_reset(struct QuotedSpread *handle); + +void wickra_quoted_spread_free(struct QuotedSpread *handle); + +struct AbsoluteBreadthIndex *wickra_absolute_breadth_index_new(void); + +double wickra_absolute_breadth_index_update(struct AbsoluteBreadthIndex *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_absolute_breadth_index_reset(struct AbsoluteBreadthIndex *handle); + +void wickra_absolute_breadth_index_free(struct AbsoluteBreadthIndex *handle); + +struct AdVolumeLine *wickra_ad_volume_line_new(void); + +double wickra_ad_volume_line_update(struct AdVolumeLine *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_ad_volume_line_reset(struct AdVolumeLine *handle); + +void wickra_ad_volume_line_free(struct AdVolumeLine *handle); + +struct AdvanceDecline *wickra_advance_decline_new(void); + +double wickra_advance_decline_update(struct AdvanceDecline *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_advance_decline_reset(struct AdvanceDecline *handle); + +void wickra_advance_decline_free(struct AdvanceDecline *handle); + +struct AdvanceDeclineRatio *wickra_advance_decline_ratio_new(void); + +double wickra_advance_decline_ratio_update(struct AdvanceDeclineRatio *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_advance_decline_ratio_reset(struct AdvanceDeclineRatio *handle); + +void wickra_advance_decline_ratio_free(struct AdvanceDeclineRatio *handle); + +struct BreadthThrust *wickra_breadth_thrust_new(uintptr_t period); + +double wickra_breadth_thrust_update(struct BreadthThrust *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_breadth_thrust_reset(struct BreadthThrust *handle); + +void wickra_breadth_thrust_free(struct BreadthThrust *handle); + +struct BullishPercentIndex *wickra_bullish_percent_index_new(void); + +double wickra_bullish_percent_index_update(struct BullishPercentIndex *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_bullish_percent_index_reset(struct BullishPercentIndex *handle); + +void wickra_bullish_percent_index_free(struct BullishPercentIndex *handle); + +struct CumulativeVolumeIndex *wickra_cumulative_volume_index_new(void); + +double wickra_cumulative_volume_index_update(struct CumulativeVolumeIndex *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_cumulative_volume_index_reset(struct CumulativeVolumeIndex *handle); + +void wickra_cumulative_volume_index_free(struct CumulativeVolumeIndex *handle); + +struct HighLowIndex *wickra_high_low_index_new(uintptr_t period); + +double wickra_high_low_index_update(struct HighLowIndex *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_high_low_index_reset(struct HighLowIndex *handle); + +void wickra_high_low_index_free(struct HighLowIndex *handle); + +struct McClellanOscillator *wickra_mc_clellan_oscillator_new(void); + +double wickra_mc_clellan_oscillator_update(struct McClellanOscillator *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_mc_clellan_oscillator_reset(struct McClellanOscillator *handle); + +void wickra_mc_clellan_oscillator_free(struct McClellanOscillator *handle); + +struct McClellanSummationIndex *wickra_mc_clellan_summation_index_new(void); + +double wickra_mc_clellan_summation_index_update(struct McClellanSummationIndex *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_mc_clellan_summation_index_reset(struct McClellanSummationIndex *handle); + +void wickra_mc_clellan_summation_index_free(struct McClellanSummationIndex *handle); + +struct NewHighsNewLows *wickra_new_highs_new_lows_new(void); + +double wickra_new_highs_new_lows_update(struct NewHighsNewLows *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_new_highs_new_lows_reset(struct NewHighsNewLows *handle); + +void wickra_new_highs_new_lows_free(struct NewHighsNewLows *handle); + +struct PercentAboveMa *wickra_percent_above_ma_new(void); + +double wickra_percent_above_ma_update(struct PercentAboveMa *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_percent_above_ma_reset(struct PercentAboveMa *handle); + +void wickra_percent_above_ma_free(struct PercentAboveMa *handle); + +struct TickIndex *wickra_tick_index_new(void); + +double wickra_tick_index_update(struct TickIndex *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_tick_index_reset(struct TickIndex *handle); + +void wickra_tick_index_free(struct TickIndex *handle); + +struct Trin *wickra_trin_new(void); + +double wickra_trin_update(struct Trin *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_trin_reset(struct Trin *handle); + +void wickra_trin_free(struct Trin *handle); + +struct UpDownVolumeRatio *wickra_up_down_volume_ratio_new(void); + +double wickra_up_down_volume_ratio_update(struct UpDownVolumeRatio *handle, + const double *change, + const double *volume, + const bool *new_high, + const bool *new_low, + const bool *above_ma, + const bool *on_buy_signal, + uintptr_t n, + int64_t timestamp); + +void wickra_up_down_volume_ratio_reset(struct UpDownVolumeRatio *handle); + +void wickra_up_down_volume_ratio_free(struct UpDownVolumeRatio *handle); + +struct AccelerationBands *wickra_acceleration_bands_new(uintptr_t period, double factor); + +bool wickra_acceleration_bands_update(struct AccelerationBands *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAccelerationBandsOutput *out); + +void wickra_acceleration_bands_reset(struct AccelerationBands *handle); + +void wickra_acceleration_bands_free(struct AccelerationBands *handle); + +struct Adx *wickra_adx_new(uintptr_t period); + +bool wickra_adx_update(struct Adx *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAdxOutput *out); + +void wickra_adx_reset(struct Adx *handle); + +void wickra_adx_free(struct Adx *handle); + +struct Alligator *wickra_alligator_new(uintptr_t jaw_period, + uintptr_t teeth_period, + uintptr_t lips_period); + +bool wickra_alligator_update(struct Alligator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAlligatorOutput *out); + +void wickra_alligator_reset(struct Alligator *handle); + +void wickra_alligator_free(struct Alligator *handle); + +struct AndrewsPitchfork *wickra_andrews_pitchfork_new(uintptr_t strength); + +bool wickra_andrews_pitchfork_update(struct AndrewsPitchfork *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAndrewsPitchforkOutput *out); + +void wickra_andrews_pitchfork_reset(struct AndrewsPitchfork *handle); + +void wickra_andrews_pitchfork_free(struct AndrewsPitchfork *handle); + +struct Aroon *wickra_aroon_new(uintptr_t period); + +bool wickra_aroon_update(struct Aroon *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAroonOutput *out); + +void wickra_aroon_reset(struct Aroon *handle); + +void wickra_aroon_free(struct Aroon *handle); + +struct AtrBands *wickra_atr_bands_new(uintptr_t period, double multiplier); + +bool wickra_atr_bands_update(struct AtrBands *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAtrBandsOutput *out); + +void wickra_atr_bands_reset(struct AtrBands *handle); + +void wickra_atr_bands_free(struct AtrBands *handle); + +struct AtrRatchet *wickra_atr_ratchet_new(uintptr_t atr_period, + double start_mult, + double increment); + +bool wickra_atr_ratchet_update(struct AtrRatchet *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAtrRatchetOutput *out); + +void wickra_atr_ratchet_reset(struct AtrRatchet *handle); + +void wickra_atr_ratchet_free(struct AtrRatchet *handle); + +struct AutoFib *wickra_auto_fib_new(void); + +bool wickra_auto_fib_update(struct AutoFib *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraAutoFibOutput *out); + +void wickra_auto_fib_reset(struct AutoFib *handle); + +void wickra_auto_fib_free(struct AutoFib *handle); + +struct BollingerBands *wickra_bollinger_bands_new(uintptr_t period, double multiplier); + +bool wickra_bollinger_bands_update(struct BollingerBands *handle, + double value, + struct WickraBollingerOutput *out); + +void wickra_bollinger_bands_reset(struct BollingerBands *handle); + +void wickra_bollinger_bands_free(struct BollingerBands *handle); + +struct BomarBands *wickra_bomar_bands_new(uintptr_t period, double coverage); + +bool wickra_bomar_bands_update(struct BomarBands *handle, + double value, + struct WickraBomarBandsOutput *out); + +void wickra_bomar_bands_reset(struct BomarBands *handle); + +void wickra_bomar_bands_free(struct BomarBands *handle); + +struct Camarilla *wickra_camarilla_new(void); + +bool wickra_camarilla_update(struct Camarilla *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraCamarillaPivotsOutput *out); + +void wickra_camarilla_reset(struct Camarilla *handle); + +void wickra_camarilla_free(struct Camarilla *handle); + +struct CandleVolume *wickra_candle_volume_new(uintptr_t period); + +bool wickra_candle_volume_update(struct CandleVolume *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraCandleVolumeOutput *out); + +void wickra_candle_volume_reset(struct CandleVolume *handle); + +void wickra_candle_volume_free(struct CandleVolume *handle); + +struct CentralPivotRange *wickra_central_pivot_range_new(void); + +bool wickra_central_pivot_range_update(struct CentralPivotRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraCentralPivotRangeOutput *out); + +void wickra_central_pivot_range_reset(struct CentralPivotRange *handle); + +void wickra_central_pivot_range_free(struct CentralPivotRange *handle); + +struct ChandeKrollStop *wickra_chande_kroll_stop_new(uintptr_t atr_period, + double atr_multiplier, + uintptr_t stop_period); + +bool wickra_chande_kroll_stop_update(struct ChandeKrollStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraChandeKrollStopOutput *out); + +void wickra_chande_kroll_stop_reset(struct ChandeKrollStop *handle); + +void wickra_chande_kroll_stop_free(struct ChandeKrollStop *handle); + +struct ChandelierExit *wickra_chandelier_exit_new(uintptr_t period, double multiplier); + +bool wickra_chandelier_exit_update(struct ChandelierExit *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraChandelierExitOutput *out); + +void wickra_chandelier_exit_reset(struct ChandelierExit *handle); + +void wickra_chandelier_exit_free(struct ChandelierExit *handle); + +struct ClassicPivots *wickra_classic_pivots_new(void); + +bool wickra_classic_pivots_update(struct ClassicPivots *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraClassicPivotsOutput *out); + +void wickra_classic_pivots_reset(struct ClassicPivots *handle); + +void wickra_classic_pivots_free(struct ClassicPivots *handle); + +struct Cointegration *wickra_cointegration_new(uintptr_t period, uintptr_t adf_lags); + +bool wickra_cointegration_update(struct Cointegration *handle, + double x, + double y, + struct WickraCointegrationOutput *out); + +void wickra_cointegration_reset(struct Cointegration *handle); + +void wickra_cointegration_free(struct Cointegration *handle); + +struct CompositeProfile *wickra_composite_profile_new(uintptr_t period, + uintptr_t bins, + double value_area_pct); + +bool wickra_composite_profile_update(struct CompositeProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraCompositeProfileOutput *out); + +void wickra_composite_profile_reset(struct CompositeProfile *handle); + +void wickra_composite_profile_free(struct CompositeProfile *handle); + +struct DemarkPivots *wickra_demark_pivots_new(void); + +bool wickra_demark_pivots_update(struct DemarkPivots *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraDemarkPivotsOutput *out); + +void wickra_demark_pivots_reset(struct DemarkPivots *handle); + +void wickra_demark_pivots_free(struct DemarkPivots *handle); + +struct Donchian *wickra_donchian_new(uintptr_t period); + +bool wickra_donchian_update(struct Donchian *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraDonchianOutput *out); + +void wickra_donchian_reset(struct Donchian *handle); + +void wickra_donchian_free(struct Donchian *handle); + +struct DonchianStop *wickra_donchian_stop_new(uintptr_t period); + +bool wickra_donchian_stop_update(struct DonchianStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraDonchianStopOutput *out); + +void wickra_donchian_stop_reset(struct DonchianStop *handle); + +void wickra_donchian_stop_free(struct DonchianStop *handle); + +struct DoubleBollinger *wickra_double_bollinger_new(uintptr_t period, + double k_inner, + double k_outer); + +bool wickra_double_bollinger_update(struct DoubleBollinger *handle, + double value, + struct WickraDoubleBollingerOutput *out); + +void wickra_double_bollinger_reset(struct DoubleBollinger *handle); + +void wickra_double_bollinger_free(struct DoubleBollinger *handle); + +struct ElderRay *wickra_elder_ray_new(uintptr_t period); + +bool wickra_elder_ray_update(struct ElderRay *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraElderRayOutput *out); + +void wickra_elder_ray_reset(struct ElderRay *handle); + +void wickra_elder_ray_free(struct ElderRay *handle); + +struct ElderSafeZone *wickra_elder_safe_zone_new(uintptr_t period, double coeff); + +bool wickra_elder_safe_zone_update(struct ElderSafeZone *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraElderSafeZoneOutput *out); + +void wickra_elder_safe_zone_reset(struct ElderSafeZone *handle); + +void wickra_elder_safe_zone_free(struct ElderSafeZone *handle); + +struct Equivolume *wickra_equivolume_new(uintptr_t period); + +bool wickra_equivolume_update(struct Equivolume *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraEquivolumeOutput *out); + +void wickra_equivolume_reset(struct Equivolume *handle); + +void wickra_equivolume_free(struct Equivolume *handle); + +struct FibArcs *wickra_fib_arcs_new(void); + +bool wickra_fib_arcs_update(struct FibArcs *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibArcsOutput *out); + +void wickra_fib_arcs_reset(struct FibArcs *handle); + +void wickra_fib_arcs_free(struct FibArcs *handle); + +struct FibChannel *wickra_fib_channel_new(void); + +bool wickra_fib_channel_update(struct FibChannel *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibChannelOutput *out); + +void wickra_fib_channel_reset(struct FibChannel *handle); + +void wickra_fib_channel_free(struct FibChannel *handle); + +struct FibConfluence *wickra_fib_confluence_new(void); + +bool wickra_fib_confluence_update(struct FibConfluence *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibConfluenceOutput *out); + +void wickra_fib_confluence_reset(struct FibConfluence *handle); + +void wickra_fib_confluence_free(struct FibConfluence *handle); + +struct FibExtension *wickra_fib_extension_new(void); + +bool wickra_fib_extension_update(struct FibExtension *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibExtensionOutput *out); + +void wickra_fib_extension_reset(struct FibExtension *handle); + +void wickra_fib_extension_free(struct FibExtension *handle); + +struct FibFan *wickra_fib_fan_new(void); + +bool wickra_fib_fan_update(struct FibFan *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibFanOutput *out); + +void wickra_fib_fan_reset(struct FibFan *handle); + +void wickra_fib_fan_free(struct FibFan *handle); + +struct FibProjection *wickra_fib_projection_new(void); + +bool wickra_fib_projection_update(struct FibProjection *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibProjectionOutput *out); + +void wickra_fib_projection_reset(struct FibProjection *handle); + +void wickra_fib_projection_free(struct FibProjection *handle); + +struct FibRetracement *wickra_fib_retracement_new(void); + +bool wickra_fib_retracement_update(struct FibRetracement *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibRetracementOutput *out); + +void wickra_fib_retracement_reset(struct FibRetracement *handle); + +void wickra_fib_retracement_free(struct FibRetracement *handle); + +struct FibTimeZones *wickra_fib_time_zones_new(void); + +bool wickra_fib_time_zones_update(struct FibTimeZones *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibTimeZonesOutput *out); + +void wickra_fib_time_zones_reset(struct FibTimeZones *handle); + +void wickra_fib_time_zones_free(struct FibTimeZones *handle); + +struct FibonacciPivots *wickra_fibonacci_pivots_new(void); + +bool wickra_fibonacci_pivots_update(struct FibonacciPivots *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFibonacciPivotsOutput *out); + +void wickra_fibonacci_pivots_reset(struct FibonacciPivots *handle); + +void wickra_fibonacci_pivots_free(struct FibonacciPivots *handle); + +struct FractalChaosBands *wickra_fractal_chaos_bands_new(uintptr_t k); + +bool wickra_fractal_chaos_bands_update(struct FractalChaosBands *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraFractalChaosBandsOutput *out); + +void wickra_fractal_chaos_bands_reset(struct FractalChaosBands *handle); + +void wickra_fractal_chaos_bands_free(struct FractalChaosBands *handle); + +struct GatorOscillator *wickra_gator_oscillator_new(uintptr_t jaw_period, + uintptr_t teeth_period, + uintptr_t lips_period); + +bool wickra_gator_oscillator_update(struct GatorOscillator *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraGatorOscillatorOutput *out); + +void wickra_gator_oscillator_reset(struct GatorOscillator *handle); + +void wickra_gator_oscillator_free(struct GatorOscillator *handle); + +struct GoldenPocket *wickra_golden_pocket_new(void); + +bool wickra_golden_pocket_update(struct GoldenPocket *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraGoldenPocketOutput *out); + +void wickra_golden_pocket_reset(struct GoldenPocket *handle); + +void wickra_golden_pocket_free(struct GoldenPocket *handle); + +struct HeikinAshi *wickra_heikin_ashi_new(void); + +bool wickra_heikin_ashi_update(struct HeikinAshi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraHeikinAshiOutput *out); + +void wickra_heikin_ashi_reset(struct HeikinAshi *handle); + +void wickra_heikin_ashi_free(struct HeikinAshi *handle); + +struct HighLowVolumeNodes *wickra_high_low_volume_nodes_new(uintptr_t period, uintptr_t bins); + +bool wickra_high_low_volume_nodes_update(struct HighLowVolumeNodes *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraHighLowVolumeNodesOutput *out); + +void wickra_high_low_volume_nodes_reset(struct HighLowVolumeNodes *handle); + +void wickra_high_low_volume_nodes_free(struct HighLowVolumeNodes *handle); + +struct HtPhasor *wickra_ht_phasor_new(void); + +bool wickra_ht_phasor_update(struct HtPhasor *handle, + double value, + struct WickraHtPhasorOutput *out); + +void wickra_ht_phasor_reset(struct HtPhasor *handle); + +void wickra_ht_phasor_free(struct HtPhasor *handle); + +struct HurstChannel *wickra_hurst_channel_new(uintptr_t period, double multiplier); + +bool wickra_hurst_channel_update(struct HurstChannel *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraHurstChannelOutput *out); + +void wickra_hurst_channel_reset(struct HurstChannel *handle); + +void wickra_hurst_channel_free(struct HurstChannel *handle); + +struct Ichimoku *wickra_ichimoku_new(uintptr_t tenkan_period, + uintptr_t kijun_period, + uintptr_t senkou_b_period, + uintptr_t displacement); + +bool wickra_ichimoku_update(struct Ichimoku *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraIchimokuOutput *out); + +void wickra_ichimoku_reset(struct Ichimoku *handle); + +void wickra_ichimoku_free(struct Ichimoku *handle); + +struct InitialBalance *wickra_initial_balance_new(uintptr_t period); + +bool wickra_initial_balance_update(struct InitialBalance *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraInitialBalanceOutput *out); + +void wickra_initial_balance_reset(struct InitialBalance *handle); + +void wickra_initial_balance_free(struct InitialBalance *handle); + +struct KalmanHedgeRatio *wickra_kalman_hedge_ratio_new(double delta, double observation_var); + +bool wickra_kalman_hedge_ratio_update(struct KalmanHedgeRatio *handle, + double x, + double y, + struct WickraKalmanHedgeRatioOutput *out); + +void wickra_kalman_hedge_ratio_reset(struct KalmanHedgeRatio *handle); + +void wickra_kalman_hedge_ratio_free(struct KalmanHedgeRatio *handle); + +struct KaseDevStop *wickra_kase_dev_stop_new(uintptr_t period, double dev); + +bool wickra_kase_dev_stop_update(struct KaseDevStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraKaseDevStopOutput *out); + +void wickra_kase_dev_stop_reset(struct KaseDevStop *handle); + +void wickra_kase_dev_stop_free(struct KaseDevStop *handle); + +struct KasePermissionStochastic *wickra_kase_permission_stochastic_new(uintptr_t length, + uintptr_t smooth); + +bool wickra_kase_permission_stochastic_update(struct KasePermissionStochastic *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraKasePermissionStochasticOutput *out); + +void wickra_kase_permission_stochastic_reset(struct KasePermissionStochastic *handle); + +void wickra_kase_permission_stochastic_free(struct KasePermissionStochastic *handle); + +struct Keltner *wickra_keltner_new(uintptr_t ema_period, uintptr_t atr_period, double multiplier); + +bool wickra_keltner_update(struct Keltner *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraKeltnerOutput *out); + +void wickra_keltner_reset(struct Keltner *handle); + +void wickra_keltner_free(struct Keltner *handle); + +struct Kst *wickra_kst_new(uintptr_t roc1, + uintptr_t roc2, + uintptr_t roc3, + uintptr_t roc4, + uintptr_t sma1, + uintptr_t sma2, + uintptr_t sma3, + uintptr_t sma4, + uintptr_t signal); + +bool wickra_kst_update(struct Kst *handle, double value, struct WickraKstOutput *out); + +void wickra_kst_reset(struct Kst *handle); + +void wickra_kst_free(struct Kst *handle); + +struct LeadLagCrossCorrelation *wickra_lead_lag_cross_correlation_new(uintptr_t window, + uintptr_t max_lag); + +bool wickra_lead_lag_cross_correlation_update(struct LeadLagCrossCorrelation *handle, + double x, + double y, + struct WickraLeadLagCrossCorrelationOutput *out); + +void wickra_lead_lag_cross_correlation_reset(struct LeadLagCrossCorrelation *handle); + +void wickra_lead_lag_cross_correlation_free(struct LeadLagCrossCorrelation *handle); + +struct LinRegChannel *wickra_lin_reg_channel_new(uintptr_t period, double multiplier); + +bool wickra_lin_reg_channel_update(struct LinRegChannel *handle, + double value, + struct WickraLinRegChannelOutput *out); + +void wickra_lin_reg_channel_reset(struct LinRegChannel *handle); + +void wickra_lin_reg_channel_free(struct LinRegChannel *handle); + +struct LiquidationFeatures *wickra_liquidation_features_new(void); + +bool wickra_liquidation_features_update(struct LiquidationFeatures *handle, + double funding_rate, + double mark_price, + double index_price, + double futures_price, + double open_interest, + double long_size, + double short_size, + double taker_buy_volume, + double taker_sell_volume, + double long_liquidation, + double short_liquidation, + int64_t timestamp, + struct WickraLiquidationFeaturesOutput *out); + +void wickra_liquidation_features_reset(struct LiquidationFeatures *handle); + +void wickra_liquidation_features_free(struct LiquidationFeatures *handle); + +struct MaEnvelope *wickra_ma_envelope_new(uintptr_t period, double percent); + +bool wickra_ma_envelope_update(struct MaEnvelope *handle, + double value, + struct WickraMaEnvelopeOutput *out); + +void wickra_ma_envelope_reset(struct MaEnvelope *handle); + +void wickra_ma_envelope_free(struct MaEnvelope *handle); + +struct MacdIndicator *wickra_macd_indicator_new(uintptr_t fast, uintptr_t slow, uintptr_t signal); + +bool wickra_macd_indicator_update(struct MacdIndicator *handle, + double value, + struct WickraMacdOutput *out); + +void wickra_macd_indicator_reset(struct MacdIndicator *handle); + +void wickra_macd_indicator_free(struct MacdIndicator *handle); + +struct MacdFix *wickra_macd_fix_new(uintptr_t signal); + +bool wickra_macd_fix_update(struct MacdFix *handle, double value, struct WickraMacdOutput *out); + +void wickra_macd_fix_reset(struct MacdFix *handle); + +void wickra_macd_fix_free(struct MacdFix *handle); + +struct Mama *wickra_mama_new(double fast_limit, double slow_limit); + +bool wickra_mama_update(struct Mama *handle, double value, struct WickraMamaOutput *out); + +void wickra_mama_reset(struct Mama *handle); + +void wickra_mama_free(struct Mama *handle); + +struct MedianChannel *wickra_median_channel_new(uintptr_t period, double multiplier); + +bool wickra_median_channel_update(struct MedianChannel *handle, + double value, + struct WickraMedianChannelOutput *out); + +void wickra_median_channel_reset(struct MedianChannel *handle); + +void wickra_median_channel_free(struct MedianChannel *handle); + +struct ModifiedMaStop *wickra_modified_ma_stop_new(uintptr_t period); + +bool wickra_modified_ma_stop_update(struct ModifiedMaStop *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraModifiedMaStopOutput *out); + +void wickra_modified_ma_stop_reset(struct ModifiedMaStop *handle); + +void wickra_modified_ma_stop_free(struct ModifiedMaStop *handle); + +struct MurreyMathLines *wickra_murrey_math_lines_new(uintptr_t period); + +bool wickra_murrey_math_lines_update(struct MurreyMathLines *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraMurreyMathLinesOutput *out); + +void wickra_murrey_math_lines_reset(struct MurreyMathLines *handle); + +void wickra_murrey_math_lines_free(struct MurreyMathLines *handle); + +struct Nrtr *wickra_nrtr_new(double pct); + +bool wickra_nrtr_update(struct Nrtr *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraNrtrOutput *out); + +void wickra_nrtr_reset(struct Nrtr *handle); + +void wickra_nrtr_free(struct Nrtr *handle); + +struct OpeningRange *wickra_opening_range_new(uintptr_t period); + +bool wickra_opening_range_update(struct OpeningRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraOpeningRangeOutput *out); + +void wickra_opening_range_reset(struct OpeningRange *handle); + +void wickra_opening_range_free(struct OpeningRange *handle); + +struct OvernightIntradayReturn *wickra_overnight_intraday_return_new(int32_t utc_offset_minutes); + +bool wickra_overnight_intraday_return_update(struct OvernightIntradayReturn *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraOvernightIntradayReturnOutput *out); + +void wickra_overnight_intraday_return_reset(struct OvernightIntradayReturn *handle); + +void wickra_overnight_intraday_return_free(struct OvernightIntradayReturn *handle); + +struct ProjectionBands *wickra_projection_bands_new(uintptr_t period); + +bool wickra_projection_bands_update(struct ProjectionBands *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraProjectionBandsOutput *out); + +void wickra_projection_bands_reset(struct ProjectionBands *handle); + +void wickra_projection_bands_free(struct ProjectionBands *handle); + +struct Qqe *wickra_qqe_new(uintptr_t rsi_period, uintptr_t smoothing, double factor); + +bool wickra_qqe_update(struct Qqe *handle, double value, struct WickraQqeOutput *out); + +void wickra_qqe_reset(struct Qqe *handle); + +void wickra_qqe_free(struct Qqe *handle); + +struct QuartileBands *wickra_quartile_bands_new(uintptr_t period); + +bool wickra_quartile_bands_update(struct QuartileBands *handle, + double value, + struct WickraQuartileBandsOutput *out); + +void wickra_quartile_bands_reset(struct QuartileBands *handle); + +void wickra_quartile_bands_free(struct QuartileBands *handle); + +struct RelativeStrengthAB *wickra_relative_strength_ab_new(uintptr_t ma_period, + uintptr_t rsi_period); + +bool wickra_relative_strength_ab_update(struct RelativeStrengthAB *handle, + double x, + double y, + struct WickraRelativeStrengthOutput *out); + +void wickra_relative_strength_ab_reset(struct RelativeStrengthAB *handle); + +void wickra_relative_strength_ab_free(struct RelativeStrengthAB *handle); + +struct Rwi *wickra_rwi_new(uintptr_t period); + +bool wickra_rwi_update(struct Rwi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraRwiOutput *out); + +void wickra_rwi_reset(struct Rwi *handle); + +void wickra_rwi_free(struct Rwi *handle); + +struct SessionHighLow *wickra_session_high_low_new(int32_t utc_offset_minutes); + +bool wickra_session_high_low_update(struct SessionHighLow *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraSessionHighLowOutput *out); + +void wickra_session_high_low_reset(struct SessionHighLow *handle); + +void wickra_session_high_low_free(struct SessionHighLow *handle); + +struct SessionRange *wickra_session_range_new(int32_t utc_offset_minutes); + +bool wickra_session_range_update(struct SessionRange *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraSessionRangeOutput *out); + +void wickra_session_range_reset(struct SessionRange *handle); + +void wickra_session_range_free(struct SessionRange *handle); + +struct SmoothedHeikinAshi *wickra_smoothed_heikin_ashi_new(uintptr_t period); + +bool wickra_smoothed_heikin_ashi_update(struct SmoothedHeikinAshi *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraSmoothedHeikinAshiOutput *out); + +void wickra_smoothed_heikin_ashi_reset(struct SmoothedHeikinAshi *handle); + +void wickra_smoothed_heikin_ashi_free(struct SmoothedHeikinAshi *handle); + +struct SpreadBollingerBands *wickra_spread_bollinger_bands_new(uintptr_t period, double num_std); + +bool wickra_spread_bollinger_bands_update(struct SpreadBollingerBands *handle, + double x, + double y, + struct WickraSpreadBollingerBandsOutput *out); + +void wickra_spread_bollinger_bands_reset(struct SpreadBollingerBands *handle); + +void wickra_spread_bollinger_bands_free(struct SpreadBollingerBands *handle); + +struct StandardErrorBands *wickra_standard_error_bands_new(uintptr_t period, double multiplier); + +bool wickra_standard_error_bands_update(struct StandardErrorBands *handle, + double value, + struct WickraStandardErrorBandsOutput *out); + +void wickra_standard_error_bands_reset(struct StandardErrorBands *handle); + +void wickra_standard_error_bands_free(struct StandardErrorBands *handle); + +struct StarcBands *wickra_starc_bands_new(uintptr_t sma_period, + uintptr_t atr_period, + double multiplier); + +bool wickra_starc_bands_update(struct StarcBands *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraStarcBandsOutput *out); + +void wickra_starc_bands_reset(struct StarcBands *handle); + +void wickra_starc_bands_free(struct StarcBands *handle); + +struct Stochastic *wickra_stochastic_new(uintptr_t k_period, uintptr_t d_period); + +bool wickra_stochastic_update(struct Stochastic *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraStochasticOutput *out); + +void wickra_stochastic_reset(struct Stochastic *handle); + +void wickra_stochastic_free(struct Stochastic *handle); + +struct SuperTrend *wickra_super_trend_new(uintptr_t atr_period, double multiplier); + +bool wickra_super_trend_update(struct SuperTrend *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraSuperTrendOutput *out); + +void wickra_super_trend_reset(struct SuperTrend *handle); + +void wickra_super_trend_free(struct SuperTrend *handle); + +struct TdLines *wickra_td_lines_new(uintptr_t lookback, uintptr_t target); + +bool wickra_td_lines_update(struct TdLines *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTdLinesOutput *out); + +void wickra_td_lines_reset(struct TdLines *handle); + +void wickra_td_lines_free(struct TdLines *handle); + +struct TdMovingAverage *wickra_td_moving_average_new(uintptr_t period_st1, uintptr_t period_st2); + +bool wickra_td_moving_average_update(struct TdMovingAverage *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTdMovingAverageOutput *out); + +void wickra_td_moving_average_reset(struct TdMovingAverage *handle); + +void wickra_td_moving_average_free(struct TdMovingAverage *handle); + +struct TdRangeProjection *wickra_td_range_projection_new(void); + +bool wickra_td_range_projection_update(struct TdRangeProjection *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTdRangeProjectionOutput *out); + +void wickra_td_range_projection_reset(struct TdRangeProjection *handle); + +void wickra_td_range_projection_free(struct TdRangeProjection *handle); + +struct TdRiskLevel *wickra_td_risk_level_new(uintptr_t lookback, uintptr_t target); + +bool wickra_td_risk_level_update(struct TdRiskLevel *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTdRiskLevelOutput *out); + +void wickra_td_risk_level_reset(struct TdRiskLevel *handle); + +void wickra_td_risk_level_free(struct TdRiskLevel *handle); + +struct TdSequential *wickra_td_sequential_new(uintptr_t setup_lookback, + uintptr_t setup_target, + uintptr_t countdown_lookback, + uintptr_t countdown_target); + +bool wickra_td_sequential_update(struct TdSequential *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTdSequentialOutput *out); + +void wickra_td_sequential_reset(struct TdSequential *handle); + +void wickra_td_sequential_free(struct TdSequential *handle); + +struct TtmSqueeze *wickra_ttm_squeeze_new(uintptr_t period, double bb_mult, double kc_mult); + +bool wickra_ttm_squeeze_update(struct TtmSqueeze *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTtmSqueezeOutput *out); + +void wickra_ttm_squeeze_reset(struct TtmSqueeze *handle); + +void wickra_ttm_squeeze_free(struct TtmSqueeze *handle); + +struct ValueArea *wickra_value_area_new(uintptr_t period, + uintptr_t bin_count, + double value_area_pct); + +bool wickra_value_area_update(struct ValueArea *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraValueAreaOutput *out); + +void wickra_value_area_reset(struct ValueArea *handle); + +void wickra_value_area_free(struct ValueArea *handle); + +struct VolatilityCone *wickra_volatility_cone_new(uintptr_t window, uintptr_t lookback); + +bool wickra_volatility_cone_update(struct VolatilityCone *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVolatilityConeOutput *out); + +void wickra_volatility_cone_reset(struct VolatilityCone *handle); + +void wickra_volatility_cone_free(struct VolatilityCone *handle); + +struct VolumeWeightedMacd *wickra_volume_weighted_macd_new(uintptr_t fast, + uintptr_t slow, + uintptr_t signal); + +bool wickra_volume_weighted_macd_update(struct VolumeWeightedMacd *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVolumeWeightedMacdOutput *out); + +void wickra_volume_weighted_macd_reset(struct VolumeWeightedMacd *handle); + +void wickra_volume_weighted_macd_free(struct VolumeWeightedMacd *handle); + +struct VolumeWeightedSr *wickra_volume_weighted_sr_new(uintptr_t period); + +bool wickra_volume_weighted_sr_update(struct VolumeWeightedSr *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVolumeWeightedSrOutput *out); + +void wickra_volume_weighted_sr_reset(struct VolumeWeightedSr *handle); + +void wickra_volume_weighted_sr_free(struct VolumeWeightedSr *handle); + +struct Vortex *wickra_vortex_new(uintptr_t period); + +bool wickra_vortex_update(struct Vortex *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVortexOutput *out); + +void wickra_vortex_reset(struct Vortex *handle); + +void wickra_vortex_free(struct Vortex *handle); + +struct VwapStdDevBands *wickra_vwap_std_dev_bands_new(double multiplier); + +bool wickra_vwap_std_dev_bands_update(struct VwapStdDevBands *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVwapStdDevBandsOutput *out); + +void wickra_vwap_std_dev_bands_reset(struct VwapStdDevBands *handle); + +void wickra_vwap_std_dev_bands_free(struct VwapStdDevBands *handle); + +struct WaveTrend *wickra_wave_trend_new(uintptr_t channel_period, + uintptr_t average_period, + uintptr_t signal_period); + +bool wickra_wave_trend_update(struct WaveTrend *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraWaveTrendOutput *out); + +void wickra_wave_trend_reset(struct WaveTrend *handle); + +void wickra_wave_trend_free(struct WaveTrend *handle); + +struct WilliamsFractals *wickra_williams_fractals_new(void); + +bool wickra_williams_fractals_update(struct WilliamsFractals *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraWilliamsFractalsOutput *out); + +void wickra_williams_fractals_reset(struct WilliamsFractals *handle); + +void wickra_williams_fractals_free(struct WilliamsFractals *handle); + +struct WoodiePivots *wickra_woodie_pivots_new(void); + +bool wickra_woodie_pivots_update(struct WoodiePivots *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraWoodiePivotsOutput *out); + +void wickra_woodie_pivots_reset(struct WoodiePivots *handle); + +void wickra_woodie_pivots_free(struct WoodiePivots *handle); + +struct ZeroLagMacd *wickra_zero_lag_macd_new(uintptr_t fast, uintptr_t slow, uintptr_t signal); + +bool wickra_zero_lag_macd_update(struct ZeroLagMacd *handle, + double value, + struct WickraZeroLagMacdOutput *out); + +void wickra_zero_lag_macd_reset(struct ZeroLagMacd *handle); + +void wickra_zero_lag_macd_free(struct ZeroLagMacd *handle); + +struct ZigZag *wickra_zig_zag_new(double threshold); + +bool wickra_zig_zag_update(struct ZigZag *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraZigZagOutput *out); + +void wickra_zig_zag_reset(struct ZigZag *handle); + +void wickra_zig_zag_free(struct ZigZag *handle); + +struct DayOfWeekProfile *wickra_day_of_week_profile_new(int32_t utc_offset_minutes); + +intptr_t wickra_day_of_week_profile_update(struct DayOfWeekProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + double *values, + uintptr_t cap); + +void wickra_day_of_week_profile_reset(struct DayOfWeekProfile *handle); + +void wickra_day_of_week_profile_free(struct DayOfWeekProfile *handle); + +struct IntradayVolatilityProfile *wickra_intraday_volatility_profile_new(uintptr_t buckets, + int32_t utc_offset_minutes); + +intptr_t wickra_intraday_volatility_profile_update(struct IntradayVolatilityProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + double *values, + uintptr_t cap); + +void wickra_intraday_volatility_profile_reset(struct IntradayVolatilityProfile *handle); + +void wickra_intraday_volatility_profile_free(struct IntradayVolatilityProfile *handle); + +struct TimeOfDayReturnProfile *wickra_time_of_day_return_profile_new(uintptr_t buckets, + int32_t utc_offset_minutes); + +intptr_t wickra_time_of_day_return_profile_update(struct TimeOfDayReturnProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + double *values, + uintptr_t cap); + +void wickra_time_of_day_return_profile_reset(struct TimeOfDayReturnProfile *handle); + +void wickra_time_of_day_return_profile_free(struct TimeOfDayReturnProfile *handle); + +struct TpoProfile *wickra_tpo_profile_new(uintptr_t period, uintptr_t bin_count); + +intptr_t wickra_tpo_profile_update(struct TpoProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTpoProfileOutputScalars *scalars, + double *values, + uintptr_t cap); + +void wickra_tpo_profile_reset(struct TpoProfile *handle); + +void wickra_tpo_profile_free(struct TpoProfile *handle); + +struct VolumeByTimeProfile *wickra_volume_by_time_profile_new(uintptr_t buckets, + int32_t utc_offset_minutes); + +intptr_t wickra_volume_by_time_profile_update(struct VolumeByTimeProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + double *values, + uintptr_t cap); + +void wickra_volume_by_time_profile_reset(struct VolumeByTimeProfile *handle); + +void wickra_volume_by_time_profile_free(struct VolumeByTimeProfile *handle); + +struct VolumeProfile *wickra_volume_profile_new(uintptr_t period, uintptr_t bin_count); + +intptr_t wickra_volume_profile_update(struct VolumeProfile *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVolumeProfileOutputScalars *scalars, + double *values, + uintptr_t cap); + +void wickra_volume_profile_reset(struct VolumeProfile *handle); + +void wickra_volume_profile_free(struct VolumeProfile *handle); + +struct DollarBars *wickra_dollar_bars_new(double dollar_per_bar); + +uintptr_t wickra_dollar_bars_update(struct DollarBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraDollarBar *out, + uintptr_t cap); + +void wickra_dollar_bars_reset(struct DollarBars *handle); + +void wickra_dollar_bars_free(struct DollarBars *handle); + +struct ImbalanceBars *wickra_imbalance_bars_new(double threshold); + +uintptr_t wickra_imbalance_bars_update(struct ImbalanceBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraImbalanceBar *out, + uintptr_t cap); + +void wickra_imbalance_bars_reset(struct ImbalanceBars *handle); + +void wickra_imbalance_bars_free(struct ImbalanceBars *handle); + +struct KagiBars *wickra_kagi_bars_new(double reversal); + +uintptr_t wickra_kagi_bars_update(struct KagiBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraKagiBar *out, + uintptr_t cap); + +void wickra_kagi_bars_reset(struct KagiBars *handle); + +void wickra_kagi_bars_free(struct KagiBars *handle); + +struct PointAndFigureBars *wickra_point_and_figure_bars_new(double box_size, uintptr_t reversal); + +uintptr_t wickra_point_and_figure_bars_update(struct PointAndFigureBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraPnfColumn *out, + uintptr_t cap); + +void wickra_point_and_figure_bars_reset(struct PointAndFigureBars *handle); + +void wickra_point_and_figure_bars_free(struct PointAndFigureBars *handle); + +struct RangeBars *wickra_range_bars_new(double range); + +uintptr_t wickra_range_bars_update(struct RangeBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraRangeBar *out, + uintptr_t cap); + +void wickra_range_bars_reset(struct RangeBars *handle); + +void wickra_range_bars_free(struct RangeBars *handle); + +struct RenkoBars *wickra_renko_bars_new(double box_size); + +uintptr_t wickra_renko_bars_update(struct RenkoBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraRenkoBrick *out, + uintptr_t cap); + +void wickra_renko_bars_reset(struct RenkoBars *handle); + +void wickra_renko_bars_free(struct RenkoBars *handle); + +struct RunBars *wickra_run_bars_new(uintptr_t run_length); + +uintptr_t wickra_run_bars_update(struct RunBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraRunBar *out, + uintptr_t cap); + +void wickra_run_bars_reset(struct RunBars *handle); + +void wickra_run_bars_free(struct RunBars *handle); + +struct ThreeLineBreakBars *wickra_three_line_break_bars_new(uintptr_t lines); + +uintptr_t wickra_three_line_break_bars_update(struct ThreeLineBreakBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraLineBreakBar *out, + uintptr_t cap); + +void wickra_three_line_break_bars_reset(struct ThreeLineBreakBars *handle); + +void wickra_three_line_break_bars_free(struct ThreeLineBreakBars *handle); + +struct TickBars *wickra_tick_bars_new(uintptr_t ticks); + +uintptr_t wickra_tick_bars_update(struct TickBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraTickBar *out, + uintptr_t cap); + +void wickra_tick_bars_reset(struct TickBars *handle); + +void wickra_tick_bars_free(struct TickBars *handle); + +struct VolumeBars *wickra_volume_bars_new(double volume_per_bar); + +uintptr_t wickra_volume_bars_update(struct VolumeBars *handle, + double open, + double high, + double low, + double close, + double volume, + int64_t timestamp, + struct WickraVolumeBar *out, + uintptr_t cap); + +void wickra_volume_bars_reset(struct VolumeBars *handle); + +void wickra_volume_bars_free(struct VolumeBars *handle); + +struct MacdExt *wickra_macd_ext_new(uintptr_t fast, + uint8_t fast_type, + uintptr_t slow, + uint8_t slow_type, + uintptr_t signal, + uint8_t signal_type); + +bool wickra_macd_ext_update(struct MacdExt *handle, double value, struct WickraMacdOutput *out); + +void wickra_macd_ext_reset(struct MacdExt *handle); + +void wickra_macd_ext_free(struct MacdExt *handle); + +struct Footprint *wickra_footprint_new(double tick_size); + +intptr_t wickra_footprint_update(struct Footprint *handle, + double price, + double size, + bool is_buy, + int64_t timestamp, + struct WickraFootprintLevel *out, + uintptr_t cap); + +void wickra_footprint_reset(struct Footprint *handle); + +void wickra_footprint_free(struct Footprint *handle); + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif /* WICKRA_H */ diff --git a/bindings/go/wickra.go b/bindings/go/wickra.go index 625bfc40..02e3ecd2 100644 --- a/bindings/go/wickra.go +++ b/bindings/go/wickra.go @@ -4,16 +4,21 @@ // Each indicator is an opaque-handle type with a New constructor and // Update/Batch/Reset/Close methods. Handles are freed by Close and, as a // backstop, by a finalizer; call Close explicitly to release native memory -// promptly. The binding links against the prebuilt Wickra C ABI library -// (libwickra.so/.dylib or wickra.dll) staged under ./lib — see the package -// README for how to provision it. +// promptly. The binding links against the prebuilt Wickra C ABI library, staged +// per platform under ./lib/_/, with the C ABI header vendored +// under ./include. For distribution the libraries are committed alongside the +// source in the wickra-go module, so `go get` + `go build` works with no extra +// steps — see the package README. package wickra /* -#cgo CFLAGS: -I${SRCDIR}/../c/include -#cgo linux LDFLAGS: -L${SRCDIR}/lib -lwickra -Wl,-rpath,${SRCDIR}/lib -#cgo darwin LDFLAGS: -L${SRCDIR}/lib -lwickra -Wl,-rpath,${SRCDIR}/lib -#cgo windows LDFLAGS: -L${SRCDIR}/lib -l:wickra.dll +#cgo CFLAGS: -I${SRCDIR}/include +#cgo linux,amd64 LDFLAGS: -L${SRCDIR}/lib/linux_amd64 -lwickra -Wl,-rpath,${SRCDIR}/lib/linux_amd64 +#cgo linux,arm64 LDFLAGS: -L${SRCDIR}/lib/linux_arm64 -lwickra -Wl,-rpath,${SRCDIR}/lib/linux_arm64 +#cgo darwin,amd64 LDFLAGS: -L${SRCDIR}/lib/darwin_amd64 -lwickra -Wl,-rpath,${SRCDIR}/lib/darwin_amd64 +#cgo darwin,arm64 LDFLAGS: -L${SRCDIR}/lib/darwin_arm64 -lwickra -Wl,-rpath,${SRCDIR}/lib/darwin_arm64 +#cgo windows,amd64 LDFLAGS: -L${SRCDIR}/lib/windows_amd64 -l:wickra.dll +#cgo windows,arm64 LDFLAGS: -L${SRCDIR}/lib/windows_arm64 -l:wickra.dll #include "wickra.h" */ import "C"