ti-engine
    Preparing search index...

    Interface CandleIndicatorsBulk

    Bulk/rolling candle indicators: operate over a sliding window and return arrays.

    General behavior:

    • Windowing: For inputs of length L and a window size N, the output length is L - N + 1 (when N applies).
    • Start index: The first output corresponds to indices [0..N-1], the second to [1..N], and so on.
    • Typed arrays: You may pass number[] or Float64Array (both are accepted).
    • OHLC alignment: Arrays for highs/lows/close must have equal length.
    • Insufficient data: If the effective window exceeds input length, the result is an empty array.
    interface CandleIndicatorsBulk {
        donchianChannels(
            highs: number[],
            lows: number[],
            period: number,
        ): [number, number, number][];
        ichimokuCloud(
            highs: number[],
            lows: number[],
            close: number[],
            conversionPeriod: number,
            basePeriod: number,
            spanBPeriod: number,
        ): [number, number, number, number, number][];
        keltnerChannel(
            highs: number[],
            lows: number[],
            close: number[],
            constantModelType: ConstantModelType,
            atrConstantModelType: ConstantModelType,
            multiplier: number,
            period: number,
        ): [number, number, number][];
        mcginleyDynamicBands(
            prices: number[],
            deviationModel: DeviationModel,
            deviationMultiplier: number,
            previousMcGinleyDynamic: number,
            period: number,
        ): [number, number, number][];
        mcginleyDynamicEnvelopes(
            prices: number[],
            difference: number,
            previousMcGinleyDynamic: number,
            period: number,
        ): [number, number, number][];
        movingConstantBands(
            prices: number[],
            constantModelType: ConstantModelType,
            deviationModel: DeviationModel,
            deviationMultiplier: number,
            period: number,
        ): [number, number, number][];
        movingConstantEnvelopes(
            prices: number[],
            constantModelType: ConstantModelType,
            difference: number,
            period: number,
        ): [number, number, number][];
        supertrend(
            highs: number[],
            lows: number[],
            close: number[],
            constantModelType: ConstantModelType,
            multiplier: number,
            period: number,
        ): number[];
    }
    Index

    Methods

    donchianChannels ichimokuCloud keltnerChannel mcginleyDynamicBands mcginleyDynamicEnvelopes movingConstantBands movingConstantEnvelopes supertrend

    Methods

    • Rolling Donchian Channels.

      Window size:

      • Uses the provided period N; output length = highs.length - N + 1.

      Middle line:

      • Average of rolling highest-high and lowest-low, i.e., (upper + lower) / 2.

      Parameters

      • highs: number[]

        High prices.

      • lows: number[]

        Low prices.

      • period: number

        Window length.

      Returns [number, number, number][]

      Array of [lower, middle, upper] per window.

      const out = bulk.donchianChannels(highs, lows, 20);
      // out[i] corresponds to highs/lows[i..i+19]

    • Rolling Ichimoku Cloud.

      Effective window:

      • Uses max(conversionPeriod, basePeriod, spanBPeriod) as the effective N.
      • For inputs of length L, output length = L - N + 1.

      Output tuple:

      • [spanA, spanB, base (Kijun), conversion (Tenkan), displacedClose]

      Parameters

      • highs: number[]

        High prices (length L).

      • lows: number[]

        Low prices (length L).

      • close: number[]

        Close prices (length L).

      • conversionPeriod: number

        Tenkan-sen period.

      • basePeriod: number

        Kijun-sen period.

      • spanBPeriod: number

        Senkou Span B period.

      Returns [number, number, number, number, number][]

      Array of [spanA, spanB, base, conversion, displacedClose] per window.

      const out = bulk.ichimokuCloud(highs, lows, close, 9, 26, 52);
      // N = max(9, 26, 52) = 52; out[i] corresponds to OHLC[i..i+51]

    • Rolling Keltner Channel using ATR and a central moving constant.

      Window size:

      • Uses the provided period N; output length = highs.length - N + 1.

      Notes:

      • constantModelType defines the moving average for the typical price center.
      • atrConstantModelType defines the ATR's smoothing model.

      Parameters

      • highs: number[]

        High prices.

      • lows: number[]

        Low prices.

      • close: number[]

        Close prices.

      • constantModelType: ConstantModelType

        Central model (for typical price).

      • atrConstantModelType: ConstantModelType

        Model for ATR calculation.

      • multiplier: number

        Multiplier for ATR width.

      • period: number

        Window length.

      Returns [number, number, number][]

      Array of [lower, middle, upper] per window.

      const out = bulk.keltnerChannel(
        highs, lows, close,
        ConstantModelType.ExponentialMovingAverage,
        ConstantModelType.SimpleMovingAverage,
        2.0,
        20
      );

    • Rolling McGinley Dynamic bands using a deviation model and multiplier.

      Window size:

      • Uses the provided period N; output length = prices.length - N + 1.

      Seeding:

      • previousMcGinleyDynamic seeds the first window's McGinley; use 0.0 if none.

      Parameters

      • prices: number[]

        Close prices.

      • deviationModel: DeviationModel

        Deviation model (StdDev, MAD, etc.).

      • deviationMultiplier: number

        Multiplier applied to the deviation (e.g., 2.0).

      • previousMcGinleyDynamic: number

        Previous McGinley value to seed the first window (0.0 if unknown).

      • period: number

        Window length.

      Returns [number, number, number][]

      Array of [lower, mcginley, upper] per window.

      const out = bulk.mcginleyDynamicBands(
        prices, DeviationModel.StandardDeviation, 2.0, 0.0, 20
      );

    • Rolling McGinley Dynamic envelopes (±percentage of McGinley value).

      Window size:

      • Uses the provided period N; output length = prices.length - N + 1.

      Seeding:

      • previousMcGinleyDynamic seeds the first window's McGinley; use 0.0 if none.

      Parameters

      • prices: number[]

        Close prices.

      • difference: number

        Percent band width (e.g., 3.0 for ±3%).

      • previousMcGinleyDynamic: number

        Previous McGinley value to seed the first window (0.0 if unknown).

      • period: number

        Window length for the McGinley computation.

      Returns [number, number, number][]

      Array of [lower, mcginley, upper] per window.

      const out = bulk.mcginleyDynamicEnvelopes(prices, 3.0, 0.0, 14);
      // out[i] corresponds to prices[i..i+13]

    • Rolling generalized bands (e.g., Bollinger) around a moving constant using a deviation model.

      Window size:

      • Uses the provided period N; output length = prices.length - N + 1.

      Band formula:

      • lower = middle - deviationMultiplier * deviation
      • upper = middle + deviationMultiplier * deviation
      • where middle is the chosen moving constant over the window.

      Parameters

      • prices: number[]

        Close prices.

      • constantModelType: ConstantModelType

        Central model (SMA, EMA, median, etc.).

      • deviationModel: DeviationModel

        Deviation model (StdDev, MAD, MedianAD, ModeAD, UlcerIndex).

      • deviationMultiplier: number

        Multiplier applied to the deviation (e.g., 2.0).

      • period: number

        Window length for both the constant and deviation.

      Returns [number, number, number][]

      Array of [lower, middle, upper] per window.

      const out = bulk.movingConstantBands(
        prices,
        ConstantModelType.SimpleMovingAverage,
        DeviationModel.StandardDeviation,
        2.0,
        20
      );
      // out[i] corresponds to prices[i..i+19]

    • Rolling envelopes around a moving constant (±percentage of the central line).

      Window size:

      • Uses the provided period N; output length = prices.length - N + 1.

      Parameters

      • prices: number[]

        Close prices.

      • constantModelType: ConstantModelType

        Central model (SMA, EMA, median, etc.).

      • difference: number

        Percent band width (e.g., 3.0 for ±3%).

      • period: number

        Window length for the moving constant.

      Returns [number, number, number][]

      Array of [lower, middle, upper] per window.

      const out = bulk.movingConstantEnvelopes(
        prices, ConstantModelType.ExponentialMovingAverage, 3.0, 20
      );
      // out[i] corresponds to prices[i..i+19]

    • Rolling Supertrend values.

      Window size:

      • Uses the provided period N; output length = highs.length - N + 1.

      Parameters

      • highs: number[]

        High prices.

      • lows: number[]

        Low prices.

      • close: number[]

        Close prices.

      • constantModelType: ConstantModelType

        Model used by ATR.

      • multiplier: number

        Multiplier for ATR.

      • period: number

        Window length for ATR and bands.

      Returns number[]

      Array of supertrend values per window.

      const out = bulk.supertrend(
        highs, lows, close,
        ConstantModelType.SimpleMovingAverage,
        2.0,
        10
      );

    Settings

    Member Visibility

    On This Page

    Methods