What is the Trend Direction Force Index?

Trend Direction Force Index compresses directional persistence into a single force line so you can gauge whether a trend is strengthening or fading without needing separate directional components.

How do I calculate the Trend Direction Force Index?

The Trend Direction Force Index is calculated using specific mathematical formulas with parameters: length (default: 10).

What are the best settings for Trend Direction Force Index?

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

Trend Direction Force Index

Parameters: length = 10

Overview

Trend Direction Force Index turns recent directional persistence into a single force line. Instead of splitting bullish and bearish continuation into two separate outputs, it collapses the current directional pressure into one series that can be used as a compact confirmation tool for momentum, breakout follow-through, or trend exhaustion studies.

In VectorTA the indicator accepts a direct source slice or candle data with an explicit source field, supports a streaming update path for live bars, and exposes batch sweeps across its single length control. It is one of the simpler interfaces in the library, but that simplicity makes it useful when you want a lightweight force measure rather than a full multi-line trend panel.

Defaults: `length = 10`.

Implementation Examples

Run the force index on a direct source slice or on candle data.

use vector_ta::indicators::trend_direction_force_index::{
    trend_direction_force_index,
    TrendDirectionForceIndexInput,
    TrendDirectionForceIndexParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let direct = trend_direction_force_index(&TrendDirectionForceIndexInput::from_slice(
    &close,
    TrendDirectionForceIndexParams { length: Some(10) },
))?;

let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let from_candles = trend_direction_force_index(
    &TrendDirectionForceIndexInput::with_default_candles(&candles),
)?;

println!("force = {:?}", direct.values.last());
println!("candle force = {:?}", from_candles.values.last());

The builder exposes the force length, kernel selection, and an alternate candle-source path.

use vector_ta::indicators::trend_direction_force_index::TrendDirectionForceIndexBuilder;
use vector_ta::utilities::enums::Kernel;

let from_slice = TrendDirectionForceIndexBuilder::new()
    .length(10)
    .kernel(Kernel::Auto)
    .apply_slice(&close)?;

let from_default_candles = TrendDirectionForceIndexBuilder::new()
    .length(14)
    .kernel(Kernel::Avx2)
    .apply(&candles)?;

let from_alt_source = TrendDirectionForceIndexBuilder::new()
    .length(12)
    .apply_candles(&candles, "hlc3")?;

let _stream = TrendDirectionForceIndexBuilder::new()
    .length(8)
    .into_stream()?;

Streaming mode updates the force line one value at a time with O(1) state.

use vector_ta::indicators::trend_direction_force_index::{
    TrendDirectionForceIndexParams,
    TrendDirectionForceIndexStream,
};

let mut stream = TrendDirectionForceIndexStream::try_new(TrendDirectionForceIndexParams::default())?;

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

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

use vector_ta::indicators::trend_direction_force_index::TrendDirectionForceIndexBatchBuilder;

let batch = TrendDirectionForceIndexBatchBuilder::new()
    .length_range(6, 18, 2)
    .apply_slice(&close)?;

println!("rows = {}, cols = {}", batch.rows, batch.cols);
println!("values buffer = {}", batch.values.len());
println!("combo count = {}", batch.combos.len());

API Reference

Input Methods▼

TrendDirectionForceIndexInput::from_candles(&Candles, "close", TrendDirectionForceIndexParams)
    -> TrendDirectionForceIndexInput

TrendDirectionForceIndexInput::from_slice(&[f64], TrendDirectionForceIndexParams)
    -> TrendDirectionForceIndexInput

TrendDirectionForceIndexInput::with_default_candles(&Candles)
    -> TrendDirectionForceIndexInput

Parameters Structure▼

pub struct TrendDirectionForceIndexParams {
    pub length: Option<usize>,  // default 10
}

Output Structure▼

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

Validation, Warmup & NaNs▼

The source slice must not be empty or entirely NaN, and the resolved length must fit the available data.
Direct evaluation rejects output-length mismatches and invalid inputs before producing the force series.
The stream returns None until enough valid values accumulate to compute the force line.
Batch mode validates the length axis and rejects invalid sweep ranges.

Builder, Streaming & Batch APIs▼

TrendDirectionForceIndexBuilder::new()
    .length(usize)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_candles(&Candles, "hlc3")
    .apply_slice(&[f64])
    .into_stream()

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

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

Python Bindings

Python exposes a direct function, a stream class, and a batch helper that returns the force matrix plus the resolved length axis.

from vector_ta import (
    trend_direction_force_index,
    trend_direction_force_index_batch,
    TrendDirectionForceIndexStream,
)

values = trend_direction_force_index(close, length=10)

stream = TrendDirectionForceIndexStream(length=10)
point = stream.update(close[-1])

batch = trend_direction_force_index_batch(close, length_range=(6, 18, 2))

JavaScript/WASM Bindings

The WASM layer exposes direct, batch, and into-buffer entry points for callers that want either a simple object-returning path or manual memory control.

import init, {
  trend_direction_force_index_js,
  trend_direction_force_index_batch_js,
  trend_direction_force_index_alloc,
  trend_direction_force_index_free,
  trend_direction_force_index_into,
  trend_direction_force_index_batch_into,
} from "vector-ta-wasm";

await init();

const single = trend_direction_force_index_js(close, 10);
console.log(single.values);

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

Alphatrend

Technical analysis indicator

Aroon

Technical analysis indicator

Aroon Oscillator

Technical analysis indicator