What is the Vertical Horizontal Filter?

Vertical Horizontal Filter is documented from the local Rust reference copy at `vertical_horizontal_filter`. It currently exposes values 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 Vertical Horizontal Filter?

The Vertical Horizontal Filter is calculated using specific mathematical formulas with parameters: length (default: null).

What are the best settings for Vertical Horizontal Filter?

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

Vertical Horizontal Filter

Parameters: length =

Overview

Vertical Horizontal Filter is a single-line market-mode study that compares directional movement with total path length over a rolling window. It is commonly used to distinguish trend persistence from noisier sideways behavior without bringing in multiple smoothing or signal lines.

In VectorTA the indicator works on a direct source slice or on candles, supports streaming updates, and exposes a single-axis batch sweep over its lookback. That makes it one of the lighter-weight regime filters in the library and a useful companion to trend-following systems.

Defaults: `length = 28`.

Implementation Examples

Run VHF on a source slice or on candles using the default configuration.

use vector_ta::indicators::vertical_horizontal_filter::{
    vertical_horizontal_filter,
    VerticalHorizontalFilterInput,
    VerticalHorizontalFilterParams,
};

let output = vertical_horizontal_filter(&VerticalHorizontalFilterInput::from_slice(
    &close,
    VerticalHorizontalFilterParams { length: Some(28) },
))?;

println!("vhf = {:?}", output.values.last());

The builder exposes a single length control, plus slice, candle, and stream paths.

use vector_ta::indicators::vertical_horizontal_filter::VerticalHorizontalFilterBuilder;

let from_candles = VerticalHorizontalFilterBuilder::new()
    .length(28)
    .apply(&candles)?;

let from_slice = VerticalHorizontalFilterBuilder::new()
    .length(35)
    .apply_slice(&close)?;

let _stream = VerticalHorizontalFilterBuilder::new()
    .length(20)
    .into_stream()?;

Streaming mode updates the VHF value from one source point at a time.

use vector_ta::indicators::vertical_horizontal_filter::{
    VerticalHorizontalFilterParams,
    VerticalHorizontalFilterStream,
};

let mut stream = VerticalHorizontalFilterStream::try_new(
    VerticalHorizontalFilterParams::default(),
)?;

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

Batch mode sweeps the length axis and returns one flattened VHF matrix.

use vector_ta::indicators::vertical_horizontal_filter::VerticalHorizontalFilterBatchBuilder;

let batch = VerticalHorizontalFilterBatchBuilder::new()
    .length_range(14, 42, 7)
    .apply_slice(&close)?;

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

API Reference

Input Methods ▼

VerticalHorizontalFilterInput::from_candles(&Candles, VerticalHorizontalFilterParams)
    -> VerticalHorizontalFilterInput

VerticalHorizontalFilterInput::from_slice(&[f64], VerticalHorizontalFilterParams)
    -> VerticalHorizontalFilterInput

VerticalHorizontalFilterInput::with_default_candles(&Candles)
    -> VerticalHorizontalFilterInput

Parameters Structure ▼

pub struct VerticalHorizontalFilterParams {
    pub length: Option<usize>,
}

Output Structure ▼

pub struct VerticalHorizontalFilterOutput {
    pub values: Vec<f64>,
}

Validation, Warmup & NaNs ▼

The source slice must contain enough valid data for the resolved length.
Candles follow the library standard input path, while slices expose the leanest direct route.
Streaming returns None until the lookback is fully warmed up.
Batch mode validates the single range axis before building the output matrix.

Builder, Streaming & Batch APIs ▼

VerticalHorizontalFilterBuilder::new()
    .length(usize)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_slice(&[f64])
    .into_stream()

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

VerticalHorizontalFilterBatchBuilder::new()
    .length_range(start, end, step)
    .apply_slice(&[f64])

Python Bindings

Python exposes direct, stream, and batch helpers for the single VHF line.

from vector_ta import vertical_horizontal_filter, vertical_horizontal_filter_batch, VerticalHorizontalFilterStream

single = vertical_horizontal_filter(close, length=28)
stream = VerticalHorizontalFilterStream(length=28)
point = stream.update(close[-1])
batch = vertical_horizontal_filter_batch(close, length_range=(14, 42, 7))

JavaScript/WASM Bindings

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

import init, { vertical_horizontal_filter_js, vertical_horizontal_filter_batch_js } from "vector-ta-wasm";

await init();

const single = vertical_horizontal_filter_js(close, 28);
const batch = vertical_horizontal_filter_batch_js(close, { length_range: [14, 42, 7] });

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 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

Damiani Volatmeter

Technical analysis indicator