How do I calculate the Velocity Acceleration Convergence Divergence Indicator?

The Velocity Acceleration Convergence Divergence Indicator is calculated using specific mathematical formulas with parameters: length (default: 21), smooth_length (default: 5).

What are the best settings for Velocity Acceleration Convergence Divergence Indicator?

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

Velocity Acceleration Convergence Divergence Indicator

Parameters: length = 21 | smooth_length = 5

Overview

Velocity Acceleration Convergence Divergence Indicator compresses a velocity-and-acceleration transform into a two-line oscillator with a signal companion. It is useful when you want a MACD-like view built from rate-of-change behavior rather than classic moving-average separation.

In VectorTA the indicator works on a single source series or candle data, streams live values, and exposes batch sweeps over the main lookback and smoothing controls. That makes it appropriate for both fast exploratory momentum work and systematic optimization of its two length axes.

Defaults: `length = 21` and `smooth_length = 5`.

Implementation Examples

Run the indicator on a direct source slice or on candle data with the default source field.

use vector_ta::indicators::velocity_acceleration_convergence_divergence_indicator::{
    velocity_acceleration_convergence_divergence_indicator,
    VelocityAccelerationConvergenceDivergenceIndicatorInput,
    VelocityAccelerationConvergenceDivergenceIndicatorParams,
};

let output = velocity_acceleration_convergence_divergence_indicator(
    &VelocityAccelerationConvergenceDivergenceIndicatorInput::from_slice(
        &close,
        VelocityAccelerationConvergenceDivergenceIndicatorParams {
            length: Some(21),
            smooth_length: Some(5),
        },
    ),
)?;

println!("vacd = {:?}", output.vacd.last());
println!("signal = {:?}", output.signal.last());

The builder exposes the two length controls and both slice and candle execution paths.

use vector_ta::indicators::velocity_acceleration_convergence_divergence_indicator::VelocityAccelerationConvergenceDivergenceIndicatorBuilder;

let from_candles = VelocityAccelerationConvergenceDivergenceIndicatorBuilder::new()
    .length(21)
    .smooth_length(5)
    .apply(&candles)?;

let from_slice = VelocityAccelerationConvergenceDivergenceIndicatorBuilder::new()
    .length(34)
    .smooth_length(8)
    .apply_slice(&close)?;

Streaming mode updates the oscillator and signal values from each new source value.

use vector_ta::indicators::velocity_acceleration_convergence_divergence_indicator::{
    VelocityAccelerationConvergenceDivergenceIndicatorParams,
    VelocityAccelerationConvergenceDivergenceIndicatorStream,
};

let mut stream = VelocityAccelerationConvergenceDivergenceIndicatorStream::try_new(
    VelocityAccelerationConvergenceDivergenceIndicatorParams::default(),
)?;

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

Batch mode sweeps the main length and signal-smoothing length and returns flattened VACD and signal matrices.

use vector_ta::indicators::velocity_acceleration_convergence_divergence_indicator::VelocityAccelerationConvergenceDivergenceIndicatorBatchBuilder;

let batch = VelocityAccelerationConvergenceDivergenceIndicatorBatchBuilder::new()
    .length_range((13, 34, 3))
    .smooth_length_range((3, 9, 2))
    .apply_slice(&close)?;

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

API Reference

Input Methods ▼

VelocityAccelerationConvergenceDivergenceIndicatorInput::from_candles(&Candles, "close", VelocityAccelerationConvergenceDivergenceIndicatorParams)
    -> VelocityAccelerationConvergenceDivergenceIndicatorInput

VelocityAccelerationConvergenceDivergenceIndicatorInput::from_slice(&[f64], VelocityAccelerationConvergenceDivergenceIndicatorParams)
    -> VelocityAccelerationConvergenceDivergenceIndicatorInput

VelocityAccelerationConvergenceDivergenceIndicatorInput::with_default_candles(&Candles)
    -> VelocityAccelerationConvergenceDivergenceIndicatorInput

Parameters Structure ▼

pub struct VelocityAccelerationConvergenceDivergenceIndicatorParams {
    pub length: Option<usize>,
    pub smooth_length: Option<usize>,
}

Output Structure ▼

pub struct VelocityAccelerationConvergenceDivergenceIndicatorOutput {
    pub vacd: Vec<f64>,
    pub signal: Vec<f64>,
}

Validation, Warmup & NaNs ▼

The source slice must not be empty or all NaN, and the resolved length and smooth_length must fit the available data.
Candles use the requested source field when building the input path.
Streaming returns None until the warmup for both lines completes.
Batch mode validates both range axes before expanding the sweep.

Builder, Streaming & Batch APIs ▼

VelocityAccelerationConvergenceDivergenceIndicatorBuilder::new()
    .length(usize)
    .smooth_length(usize)
    .kernel(Kernel)
    .apply(&Candles)
    .apply_candles(&Candles, "close")
    .apply_slice(&[f64])

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

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

Python Bindings

Python exposes direct, stream, and batch helpers for the VACD oscillator pair.

from vector_ta import (
    velocity_acceleration_convergence_divergence_indicator,
    velocity_acceleration_convergence_divergence_indicator_batch,
    VelocityAccelerationConvergenceDivergenceIndicatorStream,
)

single = velocity_acceleration_convergence_divergence_indicator(close, length=21, smooth_length=5)
stream = VelocityAccelerationConvergenceDivergenceIndicatorStream(length=21, smooth_length=5)
point = stream.update(close[-1])
batch = velocity_acceleration_convergence_divergence_indicator_batch(
    close,
    length_range=(13, 34, 3),
    smooth_length_range=(3, 9, 2),
)

JavaScript/WASM Bindings

The WASM layer exposes direct, batch, allocation, and into-buffer helpers for VACD workflows.

import init, {
  velocity_acceleration_convergence_divergence_indicator_js,
  velocity_acceleration_convergence_divergence_indicator_batch_js,
  velocity_acceleration_convergence_divergence_indicator_into,
} from "vector-ta-wasm";

await init();

const single = velocity_acceleration_convergence_divergence_indicator_js(close, 21, 5);
const batch = velocity_acceleration_convergence_divergence_indicator_batch_js(close, {
  length_range: [13, 34, 3],
  smooth_length_range: [3, 9, 2],
});

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

Acceleration Oscillator

Technical analysis indicator

Awesome Oscillator

Technical analysis indicator

Absolute Price Oscillator

Technical analysis indicator

Commodity Channel Index

Technical analysis indicator

CCI Cycle

Technical analysis indicator

Center of Gravity

Technical analysis indicator