What is the Nonlinear Regression Zero Lag Moving Average?

Nonlinear Regression Zero Lag Moving Average applies a double weighted moving-average zero-lag transform, then smooths that result with a quadratic regression curve to produce a trend line, a lagged signal line, and long or short crossover markers.

How do I calculate the Nonlinear Regression Zero Lag Moving Average?

The Nonlinear Regression Zero Lag Moving Average is calculated using specific mathematical formulas with parameters: zlma_period (default: 15), regression_period (default: 15).

What are the best settings for Nonlinear Regression Zero Lag Moving Average?

The optimal settings depend on your trading style and timeframe. Default settings are: zlma_period: 15, regression_period: 15. Experiment with different values to find what works best for your strategy.

Nonlinear Regression Zero Lag Moving Average

Parameters: zlma_period = 15 | regression_period = 15

Overview

Nonlinear Regression Zero Lag Moving Average starts by running two weighted moving averages in sequence, then doubles the first response and subtracts the second to build a zero-lag input series. That series is fed into a rolling quadratic regression, which produces the final trend value with less phase delay than a plain moving average crossover.

The indicator returns the regression value, a one-bar delayed signal line, and two event flags that turn on when the value crosses above or below the signal. It can run on a candle close source or on a direct price slice, and the streaming variant resets itself whenever a NaN sample appears.

Defaults: `zlma_period = 15` and `regression_period = 15`.

Implementation Examples

Apply the indicator to a close slice or let it read the default close source from candles.

use vector_ta::indicators::nonlinear_regression_zero_lag_moving_average::{
    nonlinear_regression_zero_lag_moving_average,
    NonlinearRegressionZeroLagMovingAverageInput,
    NonlinearRegressionZeroLagMovingAverageParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let output = nonlinear_regression_zero_lag_moving_average(
    &NonlinearRegressionZeroLagMovingAverageInput::from_slice(
        &close,
        NonlinearRegressionZeroLagMovingAverageParams {
            zlma_period: Some(15),
            regression_period: Some(15),
        },
    ),
)?;

let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let candle_output = nonlinear_regression_zero_lag_moving_average(
    &NonlinearRegressionZeroLagMovingAverageInput::with_default_candles(&candles),
)?;

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

The builder exposes both periods and optional kernel selection for candle or slice input.

use vector_ta::indicators::nonlinear_regression_zero_lag_moving_average::NonlinearRegressionZeroLagMovingAverageBuilder;
use vector_ta::utilities::enums::Kernel;

let from_close = NonlinearRegressionZeroLagMovingAverageBuilder::new()
    .zlma_period(20)
    .regression_period(10)
    .kernel(Kernel::Auto)
    .apply_slice(&close)?;

let from_candles = NonlinearRegressionZeroLagMovingAverageBuilder::new()
    .zlma_period(15)
    .regression_period(18)
    .kernel(Kernel::Scalar)
    .apply_candles(&candles, "close")?;

let _stream = NonlinearRegressionZeroLagMovingAverageBuilder::new()
    .zlma_period(15)
    .regression_period(15)
    .into_stream()?;

Streaming mode returns the current value, delayed signal, and crossover flags once the warmup window is filled.

use vector_ta::indicators::nonlinear_regression_zero_lag_moving_average::{
    NonlinearRegressionZeroLagMovingAverageParams,
    NonlinearRegressionZeroLagMovingAverageStream,
};

let mut stream = NonlinearRegressionZeroLagMovingAverageStream::try_new(
    NonlinearRegressionZeroLagMovingAverageParams {
        zlma_period: Some(15),
        regression_period: Some(15),
    },
)?;

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

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

assert_eq!(stream.update(f64::NAN), None);

Batch mode sweeps both period axes and returns row-major output matrices with combo metadata.

use vector_ta::indicators::nonlinear_regression_zero_lag_moving_average::NonlinearRegressionZeroLagMovingAverageBatchBuilder;
use vector_ta::utilities::enums::Kernel;

let batch = NonlinearRegressionZeroLagMovingAverageBatchBuilder::new()
    .zlma_period_range((10, 20, 5))
    .regression_period_range((10, 20, 5))
    .kernel(Kernel::Auto)
    .apply_slice(&close)?;

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

API Reference

Input Methods ▼

NonlinearRegressionZeroLagMovingAverageInput::from_candles(
    &Candles,
    "close",
    NonlinearRegressionZeroLagMovingAverageParams,
) -> NonlinearRegressionZeroLagMovingAverageInput

NonlinearRegressionZeroLagMovingAverageInput::from_slice(
    &[f64],
    NonlinearRegressionZeroLagMovingAverageParams,
) -> NonlinearRegressionZeroLagMovingAverageInput

NonlinearRegressionZeroLagMovingAverageInput::with_default_candles(&Candles)
    -> NonlinearRegressionZeroLagMovingAverageInput

Parameters Structure ▼

pub struct NonlinearRegressionZeroLagMovingAverageParams {
    pub zlma_period: Option<usize>,       // default 15
    pub regression_period: Option<usize>, // default 15
}

Output Structure ▼

pub struct NonlinearRegressionZeroLagMovingAverageOutput {
    pub value: Vec<f64>,
    pub signal: Vec<f64>,
    pub long_signal: Vec<f64>,
    pub short_signal: Vec<f64>,
}

Validation, Warmup & NaNs ▼

The input slice must not be empty and must contain at least one finite value.
zlma_period and regression_period must both be greater than 0.
The longest consecutive finite run must be at least 2 * zlma_period + regression_period - 2.
Warmup equals that required valid count minus 1, and earlier outputs are emitted as NaN with zeroed crossover flags.
The streaming implementation resets itself and returns None when it receives NaN.
Batch mode rejects non-batch kernels through InvalidKernelForBatch.

Builder, Streaming & Batch APIs ▼

NonlinearRegressionZeroLagMovingAverageBuilder::new()
    .zlma_period(usize)
    .regression_period(usize)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_candles(&Candles, "close")
    .apply_slice(&[f64])
    .into_stream()

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

NonlinearRegressionZeroLagMovingAverageBatchBuilder::new()
    .zlma_period_range((start, end, step))
    .regression_period_range((start, end, step))
    .kernel(Kernel)
    .apply_slice(&[f64])
    .apply_candles(&Candles, "close")

Python Bindings

Python exposes a single-array function, a stream class, and a batch helper. The scalar call returns four NumPy arrays in value-signal-crossover order, the stream emits four scalars or None, and the batch helper returns a dictionary containing reshaped matrices plus the swept period axes.

from vector_ta import (
    nonlinear_regression_zero_lag_moving_average,
    nonlinear_regression_zero_lag_moving_average_batch,
    NonlinearRegressionZeroLagMovingAverageStream,
)

value, signal, long_signal, short_signal = nonlinear_regression_zero_lag_moving_average(
    close,
    zlma_period=15,
    regression_period=15,
)

stream = NonlinearRegressionZeroLagMovingAverageStream(15, 15)
point = stream.update(close[-1])

batch = nonlinear_regression_zero_lag_moving_average_batch(
    close,
    zlma_period_range=(10, 20, 5),
    regression_period_range=(10, 20, 5),
)

print(batch.keys())
# dict_keys(['value', 'signal', 'long_signal', 'short_signal',
#            'zlma_periods', 'regression_periods', 'rows', 'cols'])

JavaScript/WASM Bindings

The WASM surface includes high-level scalar and batch entry points plus low-level allocation and into-buffer helpers. The high-level calls return plain JS objects, while the low-level calls write four contiguous output arrays into caller-managed memory.

import init, {
  nonlinear_regression_zero_lag_moving_average_js,
  nonlinear_regression_zero_lag_moving_average_batch_js,
  nonlinear_regression_zero_lag_moving_average_alloc,
  nonlinear_regression_zero_lag_moving_average_free,
  nonlinear_regression_zero_lag_moving_average_into,
  nonlinear_regression_zero_lag_moving_average_batch_into,
} from "vector-ta-wasm";

await init();

const out = nonlinear_regression_zero_lag_moving_average_js(close, 15, 15);
const batch = nonlinear_regression_zero_lag_moving_average_batch_js(close, {
  zlma_period_range: [10, 20, 5],
  regression_period_range: [10, 20, 5],
});

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

Arnaud Legoux Moving Average

Moving average indicator

Buff Averages

Technical analysis indicator

Compound Ratio Moving Average (CoRa Wave)

Moving average indicator

Centered Weighted Moving Average

Moving average indicator

Double Exponential Moving Average

Moving average indicator

Ehlers Distance Coefficient Filter

Moving average indicator