What is the Zig Zag Channels?

Zig Zag Channels is documented from the local Rust reference copy at `zig_zag_channels`. It currently exposes middle, upper, lower 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 Zig Zag Channels?

The Zig Zag Channels is calculated using specific mathematical formulas with parameters: length (default: 100), extend (default: true).

What are the best settings for Zig Zag Channels?

The optimal settings depend on your trading style and timeframe. Default settings are: length: 100, extend: true. Experiment with different values to find what works best for your strategy.

Zig Zag Channels

Parameters: length = 100 | extend = true

Overview

Zig Zag Channels builds a channel around a zig-zag style structural path and returns middle, upper, and lower lines. It is useful when you want a more structured channel than a plain moving envelope, especially for swing-oriented chart work.

In VectorTA the indicator works on open-high-low-close input, supports direct slice execution and batch sweeps over the main structural lookback while keeping the extend toggle explicit. That makes it a useful channeling tool for pattern overlays and swing-distance studies.

Defaults: `length = 100` and `extend = true`.

Implementation Examples

Run Zig Zag Channels on direct OHLC slices or on candle data with the default extension behavior.

use vector_ta::indicators::zig_zag_channels::{
    zig_zag_channels,
    ZigZagChannelsInput,
    ZigZagChannelsParams,
};

let output = zig_zag_channels(&ZigZagChannelsInput::from_slices(
    &open,
    &high,
    &low,
    &close,
    ZigZagChannelsParams::default(),
))?;

println!("middle = {:?}", output.middle.last());
println!("upper = {:?}", output.upper.last());

The builder exposes the main structural lookback, the extend toggle, and both candle and slice execution paths.

use vector_ta::indicators::zig_zag_channels::ZigZagChannelsBuilder;

let from_candles = ZigZagChannelsBuilder::new()
    .length(100)
    .extend(true)
    .apply(&candles)?;

let from_slices = ZigZagChannelsBuilder::new()
    .length(60)
    .extend(false)
    .apply_slices(&open, &high, &low, &close)?;

This indicator does not expose a streaming path; it is evaluated over full OHLC windows.

// ZigZagChannels is evaluated over complete OHLC inputs.
// Use the direct input or builder APIs for each recalculation window.

let output = zig_zag_channels(&ZigZagChannelsInput::from_slices(
    &open,
    &high,
    &low,
    &close,
    ZigZagChannelsParams { length: Some(100), extend: Some(true) },
))?;

Batch mode sweeps the structural lookback while keeping the extend behavior fixed for the run.

use vector_ta::indicators::zig_zag_channels::ZigZagChannelsBatchBuilder;

let batch = ZigZagChannelsBatchBuilder::new()
    .length_range(40, 120, 20)
    .extend(true)
    .apply_slices(&open, &high, &low, &close)?;

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

API Reference

Input Methods ▼

ZigZagChannelsInput::from_candles(&Candles, ZigZagChannelsParams)
    -> ZigZagChannelsInput

ZigZagChannelsInput::from_slices(&[f64], &[f64], &[f64], &[f64], ZigZagChannelsParams)
    -> ZigZagChannelsInput

ZigZagChannelsInput::with_default_candles(&Candles)
    -> ZigZagChannelsInput

Parameters Structure ▼

pub struct ZigZagChannelsParams {
    pub length: Option<usize>,
    pub extend: Option<bool>,
}

Output Structure ▼

pub struct ZigZagChannelsOutput {
    pub middle: Vec<f64>,
    pub upper: Vec<f64>,
    pub lower: Vec<f64>,
}

Validation, Warmup & NaNs ▼

Open, high, low, and close inputs must share the same non-zero length and contain enough valid data for the resolved length.
The extend toggle changes whether the structural channel is projected forward after the last confirmed pivot.
There is no streaming API for this indicator; it is evaluated over complete OHLC windows.
Batch mode validates the lookback range before generating the channel matrix.

Builder, Streaming & Batch APIs ▼

ZigZagChannelsBuilder::new()
    .length(usize)
    .extend(bool)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_slices(&[f64], &[f64], &[f64], &[f64])

ZigZagChannelsBatchBuilder::new()
    .length_range(start, end, step)
    .extend(bool)
    .apply_slices(&[f64], &[f64], &[f64], &[f64])

Python Bindings

Python exposes direct and batch helpers for the middle, upper, and lower zig-zag channel lines.

from vector_ta import zig_zag_channels, zig_zag_channels_batch

single = zig_zag_channels(open, high, low, close, length=100, extend=True)
batch = zig_zag_channels_batch(open, high, low, close, length_range=(40, 120, 20), extend=True)

JavaScript/WASM Bindings

The WASM layer exposes direct, batch, allocation, and into-buffer helpers for zig-zag channel calculations.

import init, { zig_zag_channels_js, zig_zag_channels_batch_js } from "vector-ta-wasm";

await init();

const single = zig_zag_channels_js(open, high, low, close, 100, true);
const batch = zig_zag_channels_batch_js(open, high, low, close, {
  length_range: [40, 120, 20],
  extend: true,
});

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

Aroon

Technical analysis indicator

Aroon Oscillator

Technical analysis indicator

Chande Momentum Oscillator

Technical analysis indicator