What is the Trend Continuation Factor?

Trend Continuation Factor separates bullish and bearish continuation pressure into paired outputs so you can compare how strongly a move is extending in each direction instead of collapsing that information into one signed line.

How do I calculate the Trend Continuation Factor?

The Trend Continuation Factor is calculated using specific mathematical formulas with parameters: length (default: 35).

What are the best settings for Trend Continuation Factor?

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

Trend Continuation Factor

Parameters: length = 35

Overview

Trend Continuation Factor measures how strongly price is continuing upward versus downward and publishes those two pressures separately as `plus_tcf` and `minus_tcf`. That makes it easier to compare the balance between bullish and bearish continuation rather than collapsing both sides into a single signed oscillator.

In VectorTA the indicator works on a single source slice or on candle data with the default close field, supports a streaming state machine for live updates, and exposes batch sweeps across the length control. It is a simple interface, but the paired output is useful when you want to study whether one side of the market is extending while the other is fading rather than merely crossing zero.

Defaults: `length = 35`.

Implementation Examples

Run the paired continuation outputs on a direct source slice or on candle closes.

use vector_ta::indicators::trend_continuation_factor::{
    trend_continuation_factor,
    TrendContinuationFactorInput,
    TrendContinuationFactorParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let direct = trend_continuation_factor(&TrendContinuationFactorInput::from_slice(
    &close,
    TrendContinuationFactorParams { length: Some(35) },
))?;

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

println!("plus = {:?}", direct.plus_tcf.last());
println!("minus = {:?}", direct.minus_tcf.last());
println!("candle plus = {:?}", from_candles.plus_tcf.last());

The builder is intentionally small: just the continuation length and kernel selection.

use vector_ta::indicators::trend_continuation_factor::TrendContinuationFactorBuilder;
use vector_ta::utilities::enums::Kernel;

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

let from_candles = TrendContinuationFactorBuilder::new()
    .length(50)
    .kernel(Kernel::Avx2)
    .apply(&candles)?;

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

Streaming mode updates both continuation-pressure series with O(1) state per bar.

use vector_ta::indicators::trend_continuation_factor::{
    TrendContinuationFactorParams,
    TrendContinuationFactorStream,
};

let mut stream = TrendContinuationFactorStream::try_new(TrendContinuationFactorParams::default())?;

for value in close.iter().copied() {
    if let Some((plus_tcf, minus_tcf)) = stream.update(value) {
        println!("plus={plus_tcf}, minus={minus_tcf}");
    }
}

Batch mode sweeps the length axis and returns separate flattened matrices for positive and negative continuation.

use vector_ta::indicators::trend_continuation_factor::TrendContinuationFactorBatchBuilder;

let batch = TrendContinuationFactorBatchBuilder::new()
    .length_range(20, 50, 5)
    .apply_slice(&close)?;

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

API Reference

Input Methods▼

TrendContinuationFactorInput::from_candles(&Candles, "close", TrendContinuationFactorParams)
    -> TrendContinuationFactorInput

TrendContinuationFactorInput::from_slice(&[f64], TrendContinuationFactorParams)
    -> TrendContinuationFactorInput

TrendContinuationFactorInput::with_default_candles(&Candles)
    -> TrendContinuationFactorInput

Parameters Structure▼

pub struct TrendContinuationFactorParams {
    pub length: Option<usize>,  // default 35
}

Output Structure▼

pub struct TrendContinuationFactorOutput {
    pub plus_tcf: Vec<f64>,
    pub minus_tcf: Vec<f64>,
}

Validation, Warmup & NaNs▼

The source slice must not be empty or entirely NaN, and the resolved length must fit the available data.
The stream returns None until enough valid bars accumulate to seed both continuation-pressure series.
Output buffers must align with the source length or the indicator returns the documented output-length mismatch error.
Batch mode validates the length axis and rejects invalid sweep ranges.

Builder, Streaming & Batch APIs▼

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

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

TrendContinuationFactorBatchBuilder::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 paired matrices for the positive and negative continuation factors.

from vector_ta import (
    trend_continuation_factor,
    trend_continuation_factor_batch,
    TrendContinuationFactorStream,
)

plus_tcf, minus_tcf = trend_continuation_factor(close, length=35)

stream = TrendContinuationFactorStream(length=35)
point = stream.update(close[-1])

batch = trend_continuation_factor_batch(close, length_range=(20, 50, 5))

JavaScript/WASM Bindings

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

import init, {
  trend_continuation_factor_js,
  trend_continuation_factor_batch_js,
  trend_continuation_factor_alloc,
  trend_continuation_factor_free,
  trend_continuation_factor_into,
  trend_continuation_factor_into_host,
  trend_continuation_factor_batch_into,
} from "vector-ta-wasm";

await init();

const single = trend_continuation_factor_js(close, 35);
console.log(single.plus_tcf, single.minus_tcf);

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