What is the Possible RSI?

Possible RSI builds an RSI-family oscillator, normalizes it into probability-style zones, and emits adaptive buy, sell, and signal-state outputs.

How do I calculate the Possible RSI?

The Possible RSI is calculated using specific mathematical formulas with parameters: period (default: 32), rsi_mode (default: regular), norm_period (default: 100), normalization_mode (default: gaussian_fisher), normalization_length (default: 15), nonlag_period (default: 15), dynamic_zone_period (default: 20), buy_probability (default: 0.2), sell_probability (default: 0.2), signal_type (default: zeroline_crossover), run_highpass (default: false), highpass_period (default: 15).

Possible RSI

Overview

Possible RSI is a layered oscillator. It begins with an RSI-family engine such as regular RSI or RSX, optionally filters the source first with a high-pass stage, then normalizes the result into a bounded probability-style oscillator using one of several normalization pipelines.

From that normalized value it derives dynamic buy, sell, and middle levels, a state series, and long or short signals according to the selected trigger mode. The stream version exposes the full seven-field point output and reports its own warmup period from the resolved parameter set.

Defaults: `period = 32`, `rsi_mode = "regular"`, `norm_period = 100`, `normalization_mode = "gaussian_fisher"`, `normalization_length = 15`, `nonlag_period = 15`, `dynamic_zone_period = 20`, `buy_probability = 0.2`, `sell_probability = 0.2`, `signal_type = "zeroline_crossover"`, `run_highpass = false`, and `highpass_period = 15`.

Implementation Examples

Run the indicator on candle closes or on a direct slice with one resolved parameter set.

use vector_ta::indicators::possible_rsi::{
    possible_rsi,
    PossibleRsiInput,
    PossibleRsiParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let output = possible_rsi(&PossibleRsiInput::from_slice(
    &close,
    PossibleRsiParams {
        period: Some(32),
        rsi_mode: Some("regular".to_string()),
        norm_period: Some(100),
        normalization_mode: Some("gaussian_fisher".to_string()),
        normalization_length: Some(15),
        nonlag_period: Some(15),
        dynamic_zone_period: Some(20),
        buy_probability: Some(0.2),
        sell_probability: Some(0.2),
        signal_type: Some("zeroline_crossover".to_string()),
        run_highpass: Some(false),
        highpass_period: Some(15),
    },
))?;

let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let candle_output = possible_rsi(&PossibleRsiInput::with_default_candles(&candles))?;

println!("value = {:?}", output.value.last());
println!("long signal = {:?}", candle_output.long_signal.last());

The builder exposes the RSI engine, normalization pipeline, zone settings, signal mode, and optional high-pass filter.

use vector_ta::indicators::possible_rsi::PossibleRsiBuilder;
use vector_ta::utilities::enums::Kernel;

let from_candles = PossibleRsiBuilder::new()
    .period(32)
    .rsi_mode("rsx")
    .norm_period(120)
    .normalization_mode("softmax")
    .normalization_length(20)
    .nonlag_period(15)
    .dynamic_zone_period(24)
    .buy_probability(0.2)
    .sell_probability(0.2)
    .signal_type("levels_crossover")
    .run_highpass(true)
    .highpass_period(15)
    .kernel(Kernel::Auto)
    .apply(&candles)?;

let from_slice = PossibleRsiBuilder::new()
    .rsi_mode("regular")
    .signal_type("zeroline_crossover")
    .apply_slice(&close)?;

let _stream = PossibleRsiBuilder::new().into_stream()?;

Streaming mode emits the full indicator point once its resolved warmup period is satisfied.

use vector_ta::indicators::possible_rsi::{PossibleRsiParams, PossibleRsiStream};

let mut stream = PossibleRsiStream::try_new(PossibleRsiParams::default())?;

println!("warmup bars = {}", stream.get_warmup_period());

for value in close.iter().copied() {
    if let Some(point) = stream.update(value) {
        println!(
            "{}, {}, {}, {}, {}, {}, {}",
            point.value,
            point.buy_level,
            point.sell_level,
            point.middle_level,
            point.state,
            point.long_signal,
            point.short_signal,
        );
    }
}

stream.reset();

Batch mode sweeps the numeric parameter axes while holding the named RSI, normalization, and signal modes fixed.

use vector_ta::indicators::possible_rsi::PossibleRsiBatchBuilder;
use vector_ta::utilities::enums::Kernel;

let batch = PossibleRsiBatchBuilder::new()
    .period_range(24, 32, 8)
    .norm_period_range(80, 120, 20)
    .normalization_length_range(10, 20, 5)
    .nonlag_period_range(10, 20, 5)
    .dynamic_zone_period_range(16, 24, 8)
    .buy_probability_range(0.1, 0.2, 0.1)
    .sell_probability_range(0.1, 0.2, 0.1)
    .kernel(Kernel::Auto)
    .apply_slice(&close)?;

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

API Reference

Input Methods ▼

PossibleRsiInput::from_candles(&Candles, "close", PossibleRsiParams)
    -> PossibleRsiInput

PossibleRsiInput::from_slice(&[f64], PossibleRsiParams)
    -> PossibleRsiInput

PossibleRsiInput::with_default_candles(&Candles)
    -> PossibleRsiInput

Parameters Structure ▼

pub struct PossibleRsiParams {
    pub period: Option<usize>,                 // default 32
    pub rsi_mode: Option<String>,             // regular, rsx, slow, rapid, harris, cutler, ehlers_smoothed
    pub norm_period: Option<usize>,           // default 100
    pub normalization_mode: Option<String>,   // gaussian_fisher, softmax, regular_norm
    pub normalization_length: Option<usize>,  // default 15
    pub nonlag_period: Option<usize>,         // default 15
    pub dynamic_zone_period: Option<usize>,   // default 20
    pub buy_probability: Option<f64>,         // default 0.2
    pub sell_probability: Option<f64>,        // default 0.2
    pub signal_type: Option<String>,          // slope, dynamic_middle_crossover, levels_crossover, zeroline_crossover
    pub run_highpass: Option<bool>,           // default false
    pub highpass_period: Option<usize>,       // default 15
}

Output Structure ▼

pub struct PossibleRsiOutput {
    pub value: Vec<f64>,
    pub buy_level: Vec<f64>,
    pub sell_level: Vec<f64>,
    pub middle_level: Vec<f64>,
    pub state: Vec<f64>,
    pub long_signal: Vec<f64>,
    pub short_signal: Vec<f64>,
}

Validation, Warmup & Modes ▼

The input slice must not be empty and must contain at least one finite value.
period, norm_period, normalization_length, nonlag_period, dynamic_zone_period, and highpass_period must all be greater than 0.
buy_probability and sell_probability must be finite and remain inside [0.0, 0.5].
The supported RSI modes are regular, rsx, slow, rapid, harris, cutler, and ehlers_smoothed.
The supported normalization modes are gaussian_fisher, softmax, and regular_norm.
The supported signal types are slope, dynamic_middle_crossover, levels_crossover, and zeroline_crossover.
The resolved warmup is derived from period, norm_period, normalization_length, the nonlag kernel length, and dynamic_zone_period; the direct path requires one more valid bar than that estimate.
Batch mode validates every numeric sweep axis and rejects non-batch kernels.

Builder, Streaming & Batch APIs ▼

PossibleRsiBuilder::new()
    .period(usize)
    .rsi_mode("regular")
    .norm_period(usize)
    .normalization_mode("gaussian_fisher")
    .normalization_length(usize)
    .nonlag_period(usize)
    .dynamic_zone_period(usize)
    .buy_probability(f64)
    .sell_probability(f64)
    .signal_type("zeroline_crossover")
    .run_highpass(bool)
    .highpass_period(usize)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_slice(&[f64])
    .into_stream()

PossibleRsiStream::try_new(params)
stream.update(f64) -> Option<PossibleRsiPoint>
stream.reset()
stream.get_warmup_period() -> usize

PossibleRsiBatchBuilder::new()
    .period_range(start, end, step)
    .norm_period_range(start, end, step)
    .normalization_length_range(start, end, step)
    .nonlag_period_range(start, end, step)
    .dynamic_zone_period_range(start, end, step)
    .buy_probability_range(start, end, step)
    .sell_probability_range(start, end, step)
    .highpass_period_range(start, end, step)
    .kernel(Kernel)
    .apply_slice(&[f64])

Python Bindings

Python exposes a scalar function, a stream class, and a batch helper. The scalar call returns seven NumPy arrays, the stream emits a seven-value tuple or None, and the batch helper returns reshaped matrices plus the swept numeric axes.

from vector_ta import possible_rsi, possible_rsi_batch, PossibleRsiStream

value, buy_level, sell_level, middle_level, state, long_signal, short_signal = possible_rsi(
    close,
    period=32,
    rsi_mode="regular",
    norm_period=100,
    normalization_mode="gaussian_fisher",
    normalization_length=15,
    nonlag_period=15,
    dynamic_zone_period=20,
    buy_probability=0.2,
    sell_probability=0.2,
    signal_type="zeroline_crossover",
    run_highpass=False,
    highpass_period=15,
)

stream = PossibleRsiStream()
point = stream.update(close[-1])

batch = possible_rsi_batch(
    close,
    period_range=(24, 32, 8),
    norm_period_range=(80, 120, 20),
    normalization_length_range=(10, 20, 5),
    nonlag_period_range=(10, 20, 5),
    dynamic_zone_period_range=(16, 24, 8),
    buy_probability_range=(0.1, 0.2, 0.1),
    sell_probability_range=(0.1, 0.2, 0.1),
)

print(batch.keys())

JavaScript/WASM Bindings

The WASM layer exposes scalar and batch helpers plus low-level allocation and into-buffer APIs. The high-level calls return plain JS objects containing all seven output arrays, and the low-level APIs write those arrays into caller-managed memory.

import init, {
  possible_rsi_js,
  possible_rsi_batch_js,
  possible_rsi_alloc,
  possible_rsi_free,
  possible_rsi_into,
  possible_rsi_batch_into,
} from "vector-ta-wasm";

await init();

const out = possible_rsi_js(
  close,
  32,
  "regular",
  100,
  "gaussian_fisher",
  15,
  15,
  20,
  0.2,
  0.2,
  "zeroline_crossover",
  false,
  15,
);

const batch = possible_rsi_batch_js(close, {
  period_range: [24, 32, 8],
  norm_period_range: [80, 120, 20],
  normalization_length_range: [10, 20, 5],
  nonlag_period_range: [10, 20, 5],
  dynamic_zone_period_range: [16, 24, 8],
  buy_probability_range: [0.1, 0.2, 0.1],
  sell_probability_range: [0.1, 0.2, 0.1],
});

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

Acceleration Oscillator

Technical analysis indicator

Awesome Oscillator

Technical analysis indicator

Absolute Price Oscillator

Technical analysis indicator

Commodity Channel Index

Technical analysis indicator

CCI Cycle

Technical analysis indicator

Center of Gravity

Technical analysis indicator