Cyberpunk Value Trend Analyzer

Parameters: entry_level = 30 (1–100) | exit_level = 75 (1–100)

Overview

Cyberpunk Value Trend Analyzer is a multi-stage regime tool built around where the close sits inside the recent 75-bar range. That normalized close position is smoothed repeatedly to produce a fast value-trend line, while a lagged copy of the previous trend value is kept alongside it for crossover-style interpretation. The result is a bounded trend-strength read that acts more like a state machine than a simple one-line oscillator.

The indicator also computes a deviation index from a 13-bar close average and uses that as an overbought filter. Buy and sell markers are then generated from threshold crossings on the main trend line: a buy triggers when the trend rises through the entry level, and a sell triggers when it falls back below the exit level. Because the trend model depends on a full 75-bar rolling range, the output is intentionally inactive during the early warmup.

Defaults: Cyberpunk Value Trend Analyzer uses `entry_level = 30` and `exit_level = 75`.

Implementation Examples

Compute the full six-channel trend surface from OHLC slices or candle data.

use vector_ta::indicators::cyberpunk_value_trend_analyzer::{
    cyberpunk_value_trend_analyzer,
    CyberpunkValueTrendAnalyzerInput,
    CyberpunkValueTrendAnalyzerParams,
};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

let output = cyberpunk_value_trend_analyzer(&CyberpunkValueTrendAnalyzerInput::from_slices(
    &open,
    &high,
    &low,
    &close,
    CyberpunkValueTrendAnalyzerParams::default(),
))?;

let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let candle_output = cyberpunk_value_trend_analyzer(
    &CyberpunkValueTrendAnalyzerInput::with_default_candles(&candles)
)?;

println!("trend = {:?}", output.value_trend.last());
println!("deviation = {:?}", output.deviation_index.last());
println!("buy signal = {:?}", candle_output.buy_signal.last());

API Reference

Input Methods ▼ 
// From candles
CyberpunkValueTrendAnalyzerInput::from_candles(
    &Candles,
    CyberpunkValueTrendAnalyzerParams,
) -> CyberpunkValueTrendAnalyzerInput

// From OHLC slices
CyberpunkValueTrendAnalyzerInput::from_slices(
    &[f64], &[f64], &[f64], &[f64], CyberpunkValueTrendAnalyzerParams
) -> CyberpunkValueTrendAnalyzerInput

// From candles with default parameters
CyberpunkValueTrendAnalyzerInput::with_default_candles(&Candles)
    -> CyberpunkValueTrendAnalyzerInput
Parameters Structure ▼ 
pub struct CyberpunkValueTrendAnalyzerParams {
    pub entry_level: Option<usize>, // default 30
    pub exit_level: Option<usize>,  // default 75
}
Output Structure ▼ 
pub struct CyberpunkValueTrendAnalyzerOutput {
    pub value_trend: Vec<f64>,
    pub value_trend_lag: Vec<f64>,
    pub deviation_index: Vec<f64>,
    pub overbought_signal: Vec<f64>,
    pub buy_signal: Vec<f64>,
    pub sell_signal: Vec<f64>,
}
Validation, Warmup & NaNs ▼
  • Open, high, low, and close must all be non-empty slices with identical lengths.
  • entry_level and exit_level must both stay within 1..=100.
  • The longest contiguous valid OHLC run must be at least 75 bars or the indicator returns NotEnoughValidData.
  • If streaming hits a non-finite OHLC bar it resets its internal rolling state.
  • Before the 75-bar range is established, the value-trend path remains inactive and the event signals stay non-actionable.
  • Batch mode rejects invalid integer ranges, overflowed shapes, and unsupported kernels.
  • All six in-place output buffers for batch and WASM low-level entry points must match the required flattened matrix size.
Builder, Streaming & Batch APIs ▼ 
// Builder
CyberpunkValueTrendAnalyzerBuilder::new()
    .entry_level(usize)
    .exit_level(usize)
    .kernel(Kernel)
    .apply_slices(&[f64], &[f64], &[f64], &[f64])

CyberpunkValueTrendAnalyzerBuilder::new()
    .apply(&Candles)

CyberpunkValueTrendAnalyzerBuilder::new()
    .into_stream()

// Stream
CyberpunkValueTrendAnalyzerStream::try_new(CyberpunkValueTrendAnalyzerParams)
CyberpunkValueTrendAnalyzerStream::update(open, high, low, close)
    -> Option<(f64, f64, f64, f64, f64, f64)>

// Batch
CyberpunkValueTrendAnalyzerBatchBuilder::new()
    .entry_level_range(start, end, step)
    .entry_level_static(usize)
    .exit_level_range(start, end, step)
    .exit_level_static(usize)
    .kernel(Kernel)
    .apply_slices(&[f64], &[f64], &[f64], &[f64])
Error Handling ▼ 
pub enum CyberpunkValueTrendAnalyzerError {
    EmptyInputData,
    InputLengthMismatch { open_len: usize, high_len: usize, low_len: usize, close_len: usize },
    AllValuesNaN,
    InvalidEntryLevel { entry_level: usize },
    InvalidExitLevel { exit_level: usize },
    NotEnoughValidData { needed: usize, valid: usize },
    OutputLengthMismatch { expected: usize, got: usize },
    MismatchedOutputLen { dst_len: usize, expected_len: usize },
    InvalidRange { start: String, end: String, step: String },
    InvalidKernel(Kernel),
    InvalidKernelForBatch(Kernel),
    InvalidInput { msg: String },
}

Python Bindings

Python exposes a tuple-returning single-run function, a streaming class, and a batch function. The single-run binding returns six NumPy arrays in order: value_trend, value_trend_lag, deviation_index, overbought_signal, buy_signal, and sell_signal. Batch returns those same channels as matrices plus the tested entry and exit levels together with rows and cols. 

import numpy as np
from vector_ta import (
    cyberpunk_value_trend_analyzer,
    cyberpunk_value_trend_analyzer_batch,
    CyberpunkValueTrendAnalyzerStream,
)

open_ = np.asarray(open_values, dtype=np.float64)
high = np.asarray(high_values, dtype=np.float64)
low = np.asarray(low_values, dtype=np.float64)
close = np.asarray(close_values, dtype=np.float64)

value_trend, value_trend_lag, deviation_index, overbought_signal, buy_signal, sell_signal = (
    cyberpunk_value_trend_analyzer(
        open_,
        high,
        low,
        close,
        entry_level=30,
        exit_level=75,
        kernel="auto",
    )
)

stream = CyberpunkValueTrendAnalyzerStream(entry_level=30, exit_level=75)
print(stream.update(open_[-1], high[-1], low[-1], close[-1]))

batch = cyberpunk_value_trend_analyzer_batch(
    open_,
    high,
    low,
    close,
    entry_level_range=(20, 40, 10),
    exit_level_range=(70, 90, 10),
    kernel="auto",
)

print(batch["entry_levels"], batch["exit_levels"], batch["rows"], batch["cols"])

JavaScript/WASM Bindings

The WASM layer exposes object-returning single-run and batch wrappers plus low-level allocation and in-place exports. The standard JavaScript wrapper returns the six output arrays directly, while the batch wrapper adds rows, cols, and a combos array containing the tested entry or exit level pairs. 

import init, {
  cyberpunk_value_trend_analyzer_js,
  cyberpunk_value_trend_analyzer_batch_js,
} from "/pkg/vector_ta.js";

await init();

const open = new Float64Array(openValues);
const high = new Float64Array(highValues);
const low = new Float64Array(lowValues);
const close = new Float64Array(closeValues);

const result = cyberpunk_value_trend_analyzer_js(
  open,
  high,
  low,
  close,
  30,
  75,
);

console.log(result.value_trend, result.buy_signal);

const batch = cyberpunk_value_trend_analyzer_batch_js(open, high, low, close, {
  entry_level_range: [20, 40, 10],
  exit_level_range: [70, 90, 10],
});

console.log(batch.combos, batch.rows, batch.cols);

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