What is the MESA Stochastic Multi Length?

MESA Stochastic Multi Length applies a shared Ehlers-style high-pass and smoothing filter to the selected source, then produces four stochastic-style MESA lines and four trigger averages over independent lookback lengths.

How do I calculate the MESA Stochastic Multi Length?

The MESA Stochastic Multi Length is calculated using specific mathematical formulas with parameters: length_1 (default: 48), length_2 (default: 21), length_3 (default: 9), length_4 (default: 6), trigger_length (default: 2).

MESA Stochastic Multi Length

Parameters: length_1 = 48 | length_2 = 21 | length_3 = 9 | length_4 = 6 | trigger_length = 2

Overview

MESA Stochastic Multi Length runs one shared filtered source stream, then evaluates that filtered signal across four stochastic lookbacks. The result is eight aligned output series: mesa_1, mesa_2, mesa_3, mesa_4, and matching trigger lines trigger_1 through trigger_4. Each trigger is a rolling SMA of its corresponding MESA line.

Candle-based input defaults to close. The default parameter set is length_1 = 48, length_2 = 21, length_3 = 9, length_4 = 6, and trigger_length = 2. In Rust, the stream API returns a raw eight-value tuple on every update rather than an Option, so warmup and invalid bars appear as NaN values inside the tuple.

Defaults: source = close, lengths = 48 / 21 / 9 / 6, trigger length = 2.

Implementation Examples

Calculate all four MESA lines and their four trigger lines from a slice or from candles:

use vector_ta::indicators::mesa_stochastic_multi_length::{
    mesa_stochastic_multi_length, MesaStochasticMultiLengthInput, MesaStochasticMultiLengthParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let source = vec![101.0, 101.4, 101.1, 102.2, 102.8, 102.5, 103.1];

let input = MesaStochasticMultiLengthInput::from_slice(
    &source,
    MesaStochasticMultiLengthParams {
        length_1: Some(48),
        length_2: Some(21),
        length_3: Some(9),
        length_4: Some(6),
        trigger_length: Some(2),
    },
);

let out = mesa_stochastic_multi_length(&input)?;
println!("{:?}", out.mesa_1);
println!("{:?}", out.trigger_1);
println!("{:?}", out.mesa_4);
println!("{:?}", out.trigger_4);

// Candle helper defaults to close
let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let out = mesa_stochastic_multi_length(
    &MesaStochasticMultiLengthInput::with_default_candles(&candles)
)?;

The Rust builder exposes source selection, all five numeric parameters, and kernel control:

use vector_ta::indicators::mesa_stochastic_multi_length::MesaStochasticMultiLengthBuilder;
use vector_ta::utilities::enums::Kernel;

let out = MesaStochasticMultiLengthBuilder::new()
    .source("close")
    .length_1(48)
    .length_2(21)
    .length_3(9)
    .length_4(6)
    .trigger_length(2)
    .kernel(Kernel::Auto)
    .apply(&candles)?;

// Slice-based usage
let out = MesaStochasticMultiLengthBuilder::new()
    .length_1(64)
    .length_2(32)
    .length_3(16)
    .length_4(8)
    .trigger_length(3)
    .apply_slice(&source)?;

Streaming returns an eight-value tuple on every update. Early bars usually remain NaN until the internal windows fill, and there is no separate reset or warmup accessor on this stream type:

use vector_ta::indicators::mesa_stochastic_multi_length::{
    MesaStochasticMultiLengthBuilder, MesaStochasticMultiLengthParams, MesaStochasticMultiLengthStream,
};

let mut stream = MesaStochasticMultiLengthStream::try_new(MesaStochasticMultiLengthParams {
    length_1: Some(48),
    length_2: Some(21),
    length_3: Some(9),
    length_4: Some(6),
    trigger_length: Some(2),
})?;

for &value in &source {
    let (mesa_1, mesa_2, mesa_3, mesa_4, trigger_1, trigger_2, trigger_3, trigger_4) =
        stream.update(value);

    println!(
        "{} {} {} {} {} {} {} {}",
        mesa_1, mesa_2, mesa_3, mesa_4, trigger_1, trigger_2, trigger_3, trigger_4
    );
}

// Builder shortcut
let mut stream = MesaStochasticMultiLengthBuilder::new()
    .length_1(48)
    .length_2(21)
    .length_3(9)
    .length_4(6)
    .trigger_length(2)
    .into_stream()?;

Batch mode sweeps Cartesian products of the five length ranges and returns flattened row-major arrays plus combo metadata:

use vector_ta::indicators::mesa_stochastic_multi_length::MesaStochasticMultiLengthBatchBuilder;
use vector_ta::utilities::enums::Kernel;

let batch = MesaStochasticMultiLengthBatchBuilder::new()
    .length_1_range((32, 64, 16))
    .length_2_range((14, 28, 7))
    .length_3_range((9, 9, 0))
    .length_4_range((6, 6, 0))
    .trigger_length_range((2, 4, 1))
    .kernel(Kernel::Auto)
    .apply_slice(&source)?;

println!("rows={}, cols={}", batch.rows, batch.cols);
println!("{:?}", batch.combos);
println!("{:?}", batch.mesa_1);
println!("{:?}", batch.trigger_1);

API Reference

Input Methods ▼

MesaStochasticMultiLengthInput::from_candles(
    &Candles,
    source: &str,
    MesaStochasticMultiLengthParams,
) -> MesaStochasticMultiLengthInput

MesaStochasticMultiLengthInput::from_slice(
    &[f64],
    MesaStochasticMultiLengthParams,
) -> MesaStochasticMultiLengthInput

MesaStochasticMultiLengthInput::from_slices(
    &[f64],
    MesaStochasticMultiLengthParams,
) -> MesaStochasticMultiLengthInput

MesaStochasticMultiLengthInput::with_default_candles(&Candles) -> MesaStochasticMultiLengthInput

Parameters Structure ▼

pub struct MesaStochasticMultiLengthParams {
    pub length_1: Option<usize>,
    pub length_2: Option<usize>,
    pub length_3: Option<usize>,
    pub length_4: Option<usize>,
    pub trigger_length: Option<usize>,
}

// Defaults
length_1 = 48
length_2 = 21
length_3 = 9
length_4 = 6
trigger_length = 2

Output Structure ▼

pub struct MesaStochasticMultiLengthOutput {
    pub mesa_1: Vec<f64>,
    pub mesa_2: Vec<f64>,
    pub mesa_3: Vec<f64>,
    pub mesa_4: Vec<f64>,
    pub trigger_1: Vec<f64>,
    pub trigger_2: Vec<f64>,
    pub trigger_3: Vec<f64>,
    pub trigger_4: Vec<f64>,
}

Builders, Batch Range, and Stream ▼

MesaStochasticMultiLengthBuilder::new() exposes source(), length_1(), length_2(), length_3(), length_4(), trigger_length(), kernel(), apply(), apply_slice(), and into_stream().
MesaStochasticMultiLengthStream::try_new(params) validates that every length is greater than zero.
MesaStochasticMultiLengthStream::update(source) returns (f64, f64, f64, f64, f64, f64, f64, f64) in mesa_1..mesa_4, then trigger_1..trigger_4 order.
The stream has no public reset() or get_warmup_period() method.
MesaStochasticMultiLengthBatchRange sweeps length_1, length_2, length_3, length_4, and trigger_length as (start, end, step) tuples.
Default batch ranges are (48,48,0), (21,21,0), (9,9,0), (6,6,0), and (2,2,0).
Range rules are strict: start must be non-zero, step == 0 requires start == end, and stepped ranges must be ascending and inclusive.
Batch output is flattened row-major across rows * cols for each of the eight returned series, plus combos, rows, and cols.

Validation and Error Conditions ▼

EmptyInputData is returned when the source slice is empty.
AllValuesNaN is returned when the source contains no finite values.
InvalidPeriod is returned when any length or trigger length is zero.
OutputLengthMismatch is used by the into-slice path when any output slice length differs from the input length.
InvalidRange is returned for invalid batch tuples.
InvalidKernelForBatch can be returned by batch execution when the selected kernel is not allowed.

Python Bindings

Standard Usage ▼

The Python function returns a dict of NumPy arrays with the eight output keys:

import numpy as np
from vector_ta import mesa_stochastic_multi_length

source = np.asarray(close, dtype=np.float64)

out = mesa_stochastic_multi_length(
    source,
    length_1=48,
    length_2=21,
    length_3=9,
    length_4=6,
    trigger_length=2,
)

print(out["mesa_1"])
print(out["trigger_1"])
print(out["mesa_4"])
print(out["trigger_4"])

Streaming ▼

MesaStochasticMultiLengthStream returns a dict snapshot on each update:

from vector_ta import MesaStochasticMultiLengthStream

stream = MesaStochasticMultiLengthStream(
    length_1=48,
    length_2=21,
    length_3=9,
    length_4=6,
    trigger_length=2,
)

for value in source:
    point = stream.update(float(value))
    print(point["mesa_1"], point["trigger_1"])

Batch Processing ▼

Batch output is a dict containing eight reshaped output arrays plus per-row parameter vectors:

from vector_ta import mesa_stochastic_multi_length_batch

batch = mesa_stochastic_multi_length_batch(
    source,
    length_1_range=(32, 64, 16),
    length_2_range=(14, 28, 7),
    length_3_range=(9, 9, 0),
    length_4_range=(6, 6, 0),
    trigger_length_range=(2, 4, 1),
)

print(batch["mesa_1"].shape)       # (rows, cols)
print(batch["trigger_1"].shape)    # (rows, cols)
print(batch["length_1"])
print(batch["trigger_length"])
print(batch["rows"], batch["cols"])

JavaScript/WASM Bindings

Standard Usage ▼

The high-level JS call returns an object with the same eight field names as the Rust output:

import init, { mesa_stochastic_multi_length_js } from 'vectorta-wasm';

await init();

const source = new Float64Array(close);
const out = mesa_stochastic_multi_length_js(source, 48, 21, 9, 6, 2) as {
  mesa_1: number[];
  mesa_2: number[];
  mesa_3: number[];
  mesa_4: number[];
  trigger_1: number[];
  trigger_2: number[];
  trigger_3: number[];
  trigger_4: number[];
};

console.log(out.mesa_1);
console.log(out.trigger_1);

Batch Processing ▼

Batch config uses five [start, end, step] arrays. The returned object carries flattened output arrays, parameter vectors, and rows/cols metadata:

import { mesa_stochastic_multi_length_batch_js } from 'vectorta-wasm';

const batch = mesa_stochastic_multi_length_batch_js(source, {
  length_1_range: [32, 64, 16],
  length_2_range: [14, 28, 7],
  length_3_range: [9, 9, 0],
  length_4_range: [6, 6, 0],
  trigger_length_range: [2, 4, 1],
}) as {
  mesa_1: number[];
  mesa_2: number[];
  mesa_3: number[];
  mesa_4: number[];
  trigger_1: number[];
  trigger_2: number[];
  trigger_3: number[];
  trigger_4: number[];
  length_1: number[];
  length_2: number[];
  length_3: number[];
  length_4: number[];
  trigger_length: number[];
  rows: number;
  cols: number;
};

console.log(batch.rows, batch.cols);
console.log(batch.length_1);
console.log(batch.trigger_length);

Low-Level Memory API ▼

WASM also exposes raw buffer helpers for manual memory management. There is no JS stream class export for this indicator.

mesa_stochastic_multi_length_alloc(len: number): number
mesa_stochastic_multi_length_free(ptr: number, len: number): void

mesa_stochastic_multi_length_into(
  source_ptr: number,
  mesa_1_ptr: number,
  mesa_2_ptr: number,
  mesa_3_ptr: number,
  mesa_4_ptr: number,
  trigger_1_ptr: number,
  trigger_2_ptr: number,
  trigger_3_ptr: number,
  trigger_4_ptr: number,
  len: number,
  length_1: number,
  length_2: number,
  length_3: number,
  length_4: number,
  trigger_length: number
): void

mesa_stochastic_multi_length_batch_into(
  source_ptr: number,
  mesa_1_ptr: number,
  mesa_2_ptr: number,
  mesa_3_ptr: number,
  mesa_4_ptr: number,
  trigger_1_ptr: number,
  trigger_2_ptr: number,
  trigger_3_ptr: number,
  trigger_4_ptr: number,
  len: number,
  length_1_start: number,
  length_1_end: number,
  length_1_step: number,
  length_2_start: number,
  length_2_end: number,
  length_2_step: number,
  length_3_start: number,
  length_3_end: number,
  length_3_step: number,
  length_4_start: number,
  length_4_end: number,
  length_4_step: number,
  trigger_length_start: number,
  trigger_length_end: number,
  trigger_length_step: number
): number

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