What is the Volatility Ratio Adaptive RSX?

Volatility Ratio Adaptive RSX is documented from the local Rust reference copy at `volatility_ratio_adaptive_rsx`. It currently exposes line, signal as the public output contract. The page content is generated from the extracted Rust API surface, binding exports, and validation rules.

How do I calculate the Volatility Ratio Adaptive RSX?

The Volatility Ratio Adaptive RSX is calculated using specific mathematical formulas with parameters: period (default: 14), speed (default: 0.5).

What are the best settings for Volatility Ratio Adaptive RSX?

The optimal settings depend on your trading style and timeframe. Default settings are: period: 14, speed: 0.5. Experiment with different values to find what works best for your strategy.

Volatility Ratio Adaptive RSX

Parameters: period = 14 | speed = 0.5

Overview

Volatility Ratio Adaptive RSX produces a two-line adaptive oscillator that adjusts its RSX-style response using a volatility-ratio speed control. It is useful when you want a smoother oscillator than a classic RSI while still allowing responsiveness to change with market conditions.

In VectorTA the indicator works on a single source slice or candle data, supports streaming updates, and exposes batch sweeps across both the period and speed controls. That makes it suitable for adaptive oscillator studies and systematic tuning of responsiveness.

Defaults: `period = 14` and `speed = 0.5`.

Implementation Examples

Run the indicator on a source slice or on candles using the default close source.

use vector_ta::indicators::volatility_ratio_adaptive_rsx::{
    volatility_ratio_adaptive_rsx,
    VolatilityRatioAdaptiveRsxInput,
    VolatilityRatioAdaptiveRsxParams,
};

let output = volatility_ratio_adaptive_rsx(&VolatilityRatioAdaptiveRsxInput::from_slice(
    &close,
    VolatilityRatioAdaptiveRsxParams {
        period: Some(14),
        speed: Some(0.5),
    },
))?;

println!("line = {:?}", output.line.last());
println!("signal = {:?}", output.signal.last());

The builder exposes the adaptive period, speed, and both candle and slice execution paths.

use vector_ta::indicators::volatility_ratio_adaptive_rsx::VolatilityRatioAdaptiveRsxBuilder;

let from_candles = VolatilityRatioAdaptiveRsxBuilder::new()
    .period(14)
    .speed(0.5)
    .apply(&candles)?;

let from_slice = VolatilityRatioAdaptiveRsxBuilder::new()
    .period(21)
    .speed(0.8)
    .apply_slice(&close)?;

let _stream = VolatilityRatioAdaptiveRsxBuilder::new()
    .period(10)
    .into_stream()?;

Streaming mode updates the adaptive line and signal values from each new source point.

use vector_ta::indicators::volatility_ratio_adaptive_rsx::{
    VolatilityRatioAdaptiveRsxParams,
    VolatilityRatioAdaptiveRsxStream,
};

let mut stream = VolatilityRatioAdaptiveRsxStream::try_new(
    VolatilityRatioAdaptiveRsxParams::default(),
)?;

for value in close.iter().copied() {
    if let Some((line, signal)) = stream.update(value) {
        println!("line={line}, signal={signal}");
    }
}

Batch mode sweeps both the period and speed controls and returns flattened line and signal matrices.

use vector_ta::indicators::volatility_ratio_adaptive_rsx::VolatilityRatioAdaptiveRsxBatchBuilder;

let batch = VolatilityRatioAdaptiveRsxBatchBuilder::new()
    .period_range(7, 21, 7)
    .speed_range(0.2, 1.0, 0.2)
    .apply_slice(&close)?;

println!("rows = {}, cols = {}", batch.rows, batch.cols);

API Reference

Input Methods ▼

VolatilityRatioAdaptiveRsxInput::from_candles(&Candles, "close", VolatilityRatioAdaptiveRsxParams)
    -> VolatilityRatioAdaptiveRsxInput

VolatilityRatioAdaptiveRsxInput::from_slice(&[f64], VolatilityRatioAdaptiveRsxParams)
    -> VolatilityRatioAdaptiveRsxInput

VolatilityRatioAdaptiveRsxInput::with_default_candles(&Candles)
    -> VolatilityRatioAdaptiveRsxInput

Parameters Structure ▼

pub struct VolatilityRatioAdaptiveRsxParams {
    pub period: Option<usize>,
    pub speed: Option<f64>,
}

Output Structure ▼

pub struct VolatilityRatioAdaptiveRsxOutput {
    pub line: Vec<f64>,
    pub signal: Vec<f64>,
}

Validation, Warmup & NaNs ▼

The source slice must contain enough valid data for the resolved period.
Candle execution uses the requested source field, with the default candle helper using close.
Streaming returns None until the adaptive line and signal are warmed up.
Batch mode validates the period and speed range axes before building the grid.

Builder, Streaming & Batch APIs ▼

VolatilityRatioAdaptiveRsxBuilder::new()
    .period(usize)
    .speed(f64)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_slice(&[f64])
    .into_stream()

VolatilityRatioAdaptiveRsxStream::try_new(params)
stream.update(value) -> Option<(f64, f64)>

VolatilityRatioAdaptiveRsxBatchBuilder::new()
    .period_range(start, end, step)
    .speed_range(start, end, step)
    .apply_slice(&[f64])

Python Bindings

Python exposes direct, stream, and batch helpers for the adaptive RSX line and signal pair.

from vector_ta import volatility_ratio_adaptive_rsx, volatility_ratio_adaptive_rsx_batch, VolatilityRatioAdaptiveRsxStream

single = volatility_ratio_adaptive_rsx(close, period=14, speed=0.5)
stream = VolatilityRatioAdaptiveRsxStream(period=14, speed=0.5)
point = stream.update(close[-1])
batch = volatility_ratio_adaptive_rsx_batch(close, period_range=(7, 21, 7), speed_range=(0.2, 1.0, 0.2))

JavaScript/WASM Bindings

The WASM layer exposes direct, batch, allocation, and into-buffer helpers for adaptive RSX calculations.

import init, {
  volatility_ratio_adaptive_rsx_js,
  volatility_ratio_adaptive_rsx_batch_js,
  volatility_ratio_adaptive_rsx_into_host,
} from "vector-ta-wasm";

await init();

const single = volatility_ratio_adaptive_rsx_js(close, 14, 0.5);
const batch = volatility_ratio_adaptive_rsx_batch_js(close, {
  period_range: [7, 21, 7],
  speed_range: [0.2, 1.0, 0.2],
});

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

Accumulation/Distribution

Technical analysis indicator

Average True Range

Technical analysis indicator

Bollinger Bands

Technical analysis indicator

Bollinger Bands Width

Technical analysis indicator

Choppiness Index

Technical analysis indicator

Chaikin Volatility Index

Technical analysis indicator