What is the Range Filtered Trend Signals?

Range Filtered Trend Signals blends a Kalman-style trend estimate with a supertrend envelope so you can separate trending states from ranging states and see the short- and long-term directional flags that come from that filter stack.

How do I calculate the Range Filtered Trend Signals?

The Range Filtered Trend Signals is calculated using specific mathematical formulas with parameters: kalman_alpha (default: 0.01), kalman_beta (default: 0.1), kalman_period (default: 77), dev (default: 1.2), supertrend_factor (default: 0.7), supertrend_atr_period (default: 7).

Range Filtered Trend Signals

Overview

Range Filtered Trend Signals combines a Kalman-based trend estimate, a supertrend-style envelope, and a long weighted moving average filter to label whether the market is currently trending or ranging. Instead of only producing one oscillator line, it returns the filter backbone, the active envelope, trend-state flags, and short- versus long-term directional markers.

That makes it useful when you want the raw smoothed trend estimate, the active supertrend level, and the regime classification from the same indicator family. VectorTA supports high-low-close candle input, raw slices, live streaming updates, and full batch sweeps across all six numeric controls.

Defaults: `kalman_alpha = 0.01`, `kalman_beta = 0.1`, `kalman_period = 77`, `dev = 1.2`, `supertrend_factor = 0.7`, and `supertrend_atr_period = 7`.

Implementation Examples

Run the filter stack from candles or from explicit high, low, and close slices.

use vector_ta::indicators::range_filtered_trend_signals::{
    range_filtered_trend_signals,
    RangeFilteredTrendSignalsInput,
    RangeFilteredTrendSignalsParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let direct = range_filtered_trend_signals(&RangeFilteredTrendSignalsInput::from_slices(
    &high,
    &low,
    &close,
    RangeFilteredTrendSignalsParams::default(),
))?;

let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let from_candles = range_filtered_trend_signals(&RangeFilteredTrendSignalsInput::with_default_candles(&candles))?;

println!("kalman = {:?}", direct.kalman.last());
println!("market_trending = {:?}", from_candles.market_trending.last());

The builder exposes all six controls plus kernel selection for either candles or explicit slices.

use vector_ta::indicators::range_filtered_trend_signals::RangeFilteredTrendSignalsBuilder;
use vector_ta::utilities::enums::Kernel;

let from_candles = RangeFilteredTrendSignalsBuilder::new()
    .kalman_alpha(0.01)
    .kalman_beta(0.1)
    .kalman_period(77)
    .dev(1.2)
    .supertrend_factor(0.7)
    .supertrend_atr_period(7)
    .kernel(Kernel::Auto)
    .apply(&candles)?;

let _stream = RangeFilteredTrendSignalsBuilder::new()
    .supertrend_atr_period(10)
    .into_stream()?;

Streaming mode returns the full point payload once the long warmup window has been satisfied.

use vector_ta::indicators::range_filtered_trend_signals::{
    RangeFilteredTrendSignalsParams,
    RangeFilteredTrendSignalsStream,
};

let mut stream = RangeFilteredTrendSignalsStream::try_new(
    RangeFilteredTrendSignalsParams::default()
)?;

for i in 0..close.len() {
    if let Some(point) = stream.update(high[i], low[i], close[i]) {
        println!(
            "{} {} {} {}",
            point.kalman,
            point.supertrend,
            point.market_trending,
            point.long_term_bullish
        );
    }
}

Batch mode sweeps every numeric parameter and returns flattened matrices for each output field.

use vector_ta::indicators::range_filtered_trend_signals::{
    RangeFilteredTrendSignalsBatchBuilder,
    RangeFilteredTrendSignalsBatchRange,
};
use vector_ta::utilities::enums::Kernel;

let batch = RangeFilteredTrendSignalsBatchBuilder::new()
    .range(RangeFilteredTrendSignalsBatchRange {
        kalman_alpha: (0.01, 0.02, 0.01),
        kalman_beta: (0.1, 0.2, 0.1),
        kalman_period: (77, 99, 22),
        dev: (1.0, 1.4, 0.2),
        supertrend_factor: (0.7, 1.1, 0.2),
        supertrend_atr_period: (7, 11, 2),
    })
    .kernel(Kernel::Auto)
    .apply_slices(&high, &low, &close)?;

println!("rows = {}, cols = {}", batch.rows, batch.cols);
println!("first combo = {:?}", batch.combos.first());
println!("state len = {}", batch.state.len());

API Reference

Input Methods▼

RangeFilteredTrendSignalsInput::from_candles(&Candles, RangeFilteredTrendSignalsParams)
    -> RangeFilteredTrendSignalsInput

RangeFilteredTrendSignalsInput::from_slices(&[f64], &[f64], &[f64], RangeFilteredTrendSignalsParams)
    -> RangeFilteredTrendSignalsInput

RangeFilteredTrendSignalsInput::with_default_candles(&Candles)
    -> RangeFilteredTrendSignalsInput

Parameters Structure▼

pub struct RangeFilteredTrendSignalsParams {
    pub kalman_alpha: Option<f64>,
    pub kalman_beta: Option<f64>,
    pub kalman_period: Option<usize>,
    pub dev: Option<f64>,
    pub supertrend_factor: Option<f64>,
    pub supertrend_atr_period: Option<usize>,
}

Output Structure▼

pub struct RangeFilteredTrendSignalsOutput {
    pub kalman: Vec<f64>,
    pub supertrend: Vec<f64>,
    pub upper_band: Vec<f64>,
    pub lower_band: Vec<f64>,
    pub trend: Vec<f64>,
    pub kalman_trend: Vec<f64>,
    pub state: Vec<f64>,
    pub market_trending: Vec<f64>,
    pub market_ranging: Vec<f64>,
    pub short_term_bullish: Vec<f64>,
    pub short_term_bearish: Vec<f64>,
    pub long_term_bullish: Vec<f64>,
    pub long_term_bearish: Vec<f64>,
}

Validation & Warmup▼

High, low, and close series must be non-empty, equal in length, and contain at least one valid triple.
kalman_alpha must be finite and greater than 0.
kalman_beta must be finite and non-negative.
kalman_period and supertrend_atr_period must be greater than 0.
The vector path has a long warmup driven by the internal 200-period weighted average and the ATR period.
Batch mode validates every sweep axis and rejects non-batch kernels.

Builder, Streaming & Batch APIs▼

RangeFilteredTrendSignalsBuilder::new()
    .kalman_alpha(f64)
    .kalman_beta(f64)
    .kalman_period(usize)
    .dev(f64)
    .supertrend_factor(f64)
    .supertrend_atr_period(usize)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_slices(&[f64], &[f64], &[f64])
    .into_stream()

RangeFilteredTrendSignalsStream::try_new(params)
stream.update(high, low, close) -> Option<RangeFilteredTrendSignalsStreamOutput>

RangeFilteredTrendSignalsBatchBuilder::new()
    .range(RangeFilteredTrendSignalsBatchRange)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_slices(&[f64], &[f64], &[f64])

Python Bindings

Python exposes scalar and batch helpers that return dictionaries keyed by every output field, plus a stream class that returns the current multi-field signal snapshot once the filter state is ready.

from vector_ta import (
    range_filtered_trend_signals,
    range_filtered_trend_signals_batch,
    RangeFilteredTrendSignalsStream,
)

single = range_filtered_trend_signals(high, low, close)

stream = RangeFilteredTrendSignalsStream()
point = stream.update(high[-1], low[-1], close[-1])

batch = range_filtered_trend_signals_batch(
    high,
    low,
    close,
    kalman_alpha_range=(0.01, 0.02, 0.01),
    kalman_beta_range=(0.1, 0.2, 0.1),
    kalman_period_range=(77, 99, 22),
    dev_range=(1.0, 1.4, 0.2),
    supertrend_factor_range=(0.7, 1.1, 0.2),
    supertrend_atr_period_range=(7, 11, 2),
)

print(single["kalman"][-1], single["market_trending"][-1])
print(batch["rows"], batch["cols"])

JavaScript/WASM Bindings

The WASM layer exposes object-returning scalar and batch helpers covering all output fields for the filter stack.

import init, {
  range_filtered_trend_signals_js,
  range_filtered_trend_signals_batch,
} from "vector-ta-wasm";

await init();

const single = range_filtered_trend_signals_js(
  high,
  low,
  close,
  0.01,
  0.1,
  77,
  1.2,
  0.7,
  7,
);

const batch = range_filtered_trend_signals_batch(high, low, close, {
  kalman_alpha_range: [0.01, 0.02, 0.01],
  kalman_beta_range: [0.1, 0.2, 0.1],
  kalman_period_range: [77, 99, 22],
  dev_range: [1.0, 1.4, 0.2],
  supertrend_factor_range: [0.7, 1.1, 0.2],
  supertrend_atr_period_range: [7, 11, 2],
});

console.log(single.kalman, single.market_trending, batch.rows);

CUDA Bindings (Rust)

Additional details for the CUDA bindings can be found inside the VectorTA repository.

Performance Analysis

Comparison:

View:

Placeholder data (no recorded benchmarks for this indicator)

Across sizes, Rust CPU runs about 1.14× faster than Tulip C in this benchmark.

Loading chart...

AMD Ryzen 9 9950X (CPU) | NVIDIA RTX 4090 (GPU)

Related Indicators

Average Directional Index

Technical analysis indicator

Average Directional Movement Index Rating

Technical analysis indicator

Alligator

Technical analysis indicator

Alphatrend

Technical analysis indicator

Aroon

Technical analysis indicator

Aroon Oscillator

Technical analysis indicator