Modified God Mode (MG)

Parameters: n1 = 17 | n2 = 6 | n3 = 4 | mode = tradition_mg | use_volume = true

Overview

The Modified God Mode indicator creates a sophisticated composite oscillator by intelligently averaging multiple momentum components including TCI, RSI or MFI, CSI variants, Williams %R, CBCI, and Laguerre RSI into a single unified signal. This multi layered approach captures different aspects of market momentum simultaneously, with each component contributing its unique perspective on price action to produce a more robust overall reading than any single oscillator could provide. The indicator generates three outputs: a wavetrend line showing the composite momentum value, a signal line smoothed with a 6 period SMA for crossover signals, and a histogram displaying the difference between them to highlight momentum shifts. Traders value this indicator for its ability to filter out false signals that plague individual oscillators, as the averaging process requires multiple components to align before generating strong readings. The various mode options allow adaptation to different market conditions, with tradition_mg mode incorporating volume through Money Flow Index when available, adding another dimension to the momentum analysis that pure price based oscillators miss.

Implementation Examples

Get wavetrend, signal, and histogram in a few lines:

use vectorta::indicators::mod_god_mode::{mod_god_mode, ModGodModeInput, ModGodModeParams, ModGodModeMode};
use vectorta::utilities::data_loader::{Candles, read_candles_from_csv};

// Using with OHLCV slices
let high = vec![/* ... */];
let low = vec![/* ... */];
let close = vec![/* ... */];
let volume = vec![/* ... */];
let params = ModGodModeParams { n1: Some(17), n2: Some(6), n3: Some(4), mode: Some(ModGodModeMode::TraditionMg), use_volume: Some(true) };
let input = ModGodModeInput::from_slices(&high, &low, &close, Some(&volume), params);
let out = mod_god_mode(&input)?; // out.wavetrend, out.signal, out.histogram

// Using with Candles and defaults (n1=17, n2=6, n3=4, mode=tradition_mg, use_volume=true)
let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let input = ModGodModeInput::with_default_candles(&candles);
let out = mod_god_mode(&input)?;

API Reference

Input Methods ▼ 
// From slices (volume optional)
ModGodModeInput::from_slices(&[f64], &[f64], &[f64], Option<&[f64]>, ModGodModeParams) -> ModGodModeInput

// From candles
ModGodModeInput::from_candles(&Candles, ModGodModeParams) -> ModGodModeInput

// Candles with library defaults (n1=17, n2=6, n3=4, mode=TraditionMg, use_volume=true)
ModGodModeInput::with_default_candles(&Candles) -> ModGodModeInput
Parameters Structure ▼ 
#[derive(Debug, Clone)]
pub enum ModGodModeMode { Godmode, Tradition, GodmodeMg, TraditionMg }
// Default: TraditionMg

#[derive(Debug, Clone)]
pub struct ModGodModeParams {
    pub n1: Option<usize>,       // Default: 17
    pub n2: Option<usize>,       // Default: 6
    pub n3: Option<usize>,       // Default: 4
    pub mode: Option<ModGodModeMode>, // Default: TraditionMg
    pub use_volume: Option<bool>,     // Default: true
}
Output Structure ▼ 
#[derive(Debug, Clone)]
pub struct ModGodModeOutput {
    pub wavetrend: Vec<f64>,  // composite oscillator
    pub signal: Vec<f64>,     // SMA(6) of wavetrend
    pub histogram: Vec<f64>,  // EMA(n3) of ((wt - sig)*2 + 50)
}
Validation, Warmup & NaNs ▼
  • n1 > 0, n2 > 0, n3 > 0; otherwise ModGodModeError::InvalidPeriod.
  • Requires at least max(n1, n2, n3) valid points after first finite value; else NotEnoughValidData.
  • Leading indices are NaN until warmup; signal/histogram start after an extra 5 samples due to SMA(6).
  • use_volume=true uses MFI for MF; otherwise MF falls back to RSI.
  • Streaming returns None until ring buffer reaches max(n1, n2, n3).
Error Handling ▼ 
use vectorta::indicators::mod_god_mode::{mod_god_mode, ModGodModeError};

match mod_god_mode(&input) {
    Ok(o) => handle(o),
    Err(ModGodModeError::EmptyInputData) => eprintln!("Input data is empty"),
    Err(ModGodModeError::AllValuesNaN) => eprintln!("All input values are NaN"),
    Err(ModGodModeError::InvalidPeriod { n1, n2, n3, data_len }) =>
        eprintln!("Invalid period n1={}, n2={}, n3={}, len={}", n1, n2, n3, data_len),
    Err(ModGodModeError::NotEnoughValidData { needed, valid }) =>
        eprintln!("Need {} valid points after first finite, got {}", needed, valid),
    Err(ModGodModeError::InvalidDestinationLen { dst, src }) =>
        eprintln!("Destination length {} != source {}", dst, src),
    Err(ModGodModeError::InvalidKernelForBatch) => eprintln!("Invalid batch kernel"),
    Err(ModGodModeError::CalculationError(msg)) => eprintln!("Calc error: {}", msg),
}

Python Bindings

Basic Usage ▼

Calculate wavetrend, signal, and histogram (tuple of arrays):

import numpy as np
from vectorta import mod_god_mode, ModGodModeStream

high = np.array([...], dtype=float)
low = np.array([...], dtype=float)
close = np.array([...], dtype=float)
volume = np.array([...], dtype=float)

wt, sig, hist = mod_god_mode(
    high, low, close,
    volume=volume,    # or None
    n1=17, n2=6, n3=4,
    mode="tradition_mg",
    use_volume=True,
    kernel="auto"
)
Streaming ▼ 
from vectorta import ModGodModeStream

stream = ModGodModeStream(n1=17, n2=6, n3=4, mode="tradition_mg", use_volume=False)
for h, l, c in zip(high, low, close):
    out = stream.update(h, l, c, volume=None)
    if out is not None:
        wt, sig, hist = out
# Reset when needed
stream.reset()
Batch (Parameter Sweep) ▼

Returns dict with matrices and tested params:

from vectorta import mod_god_mode_batch

result = mod_god_mode_batch(
    high, low, close,
    volume=None,
    n1_range=(12, 20, 2),
    n2_range=(4, 8, 2),
    n3_range=(3, 5, 1),
    mode="tradition_mg",
    kernel="auto"
)

wt = result["wavetrend"]      # shape: (rows, len)
sig = result["signal"]        # shape: (rows, len)
hist = result["histogram"]    # shape: (rows, len)
rows, cols = result["rows"], result["cols"]
n1s, n2s, n3s = result["n1s"], result["n2s"], result["n3s"]
modes = result["modes"]
CUDA Acceleration ▼

CUDA support for Modified God Mode is not yet available. The API will follow the same patterns as other CUDA-enabled indicators when added.

JavaScript/WASM Bindings

Basic Usage ▼

Calculate MG in JavaScript/TypeScript; returns {{ wavetrend, signal, histogram }}:

import { mod_god_mode } from 'vectorta-wasm';

const high = new Float64Array([/* ... */]);
const low = new Float64Array([/* ... */]);
const close = new Float64Array([/* ... */]);
const volume = new Float64Array([/* ... */]);

const out = mod_god_mode(
  high, low, close,
  volume,        // or null/undefined
  17, 6, 4,      // n1, n2, n3 (optional)
  'tradition_mg',
  true           // use_volume
);

console.log(out.wavetrend.length, out.signal.length, out.histogram.length);
Memory-Efficient Operations ▼

Use zero-copy “into” APIs for large datasets; allocate and map inputs/outputs in WASM memory:

import { mod_god_mode_alloc, mod_god_mode_free, mod_god_mode_into, memory } from 'vectorta-wasm';

const len = high.length;

// Allocate and copy inputs
const highPtr = mod_god_mode_alloc(len);
const lowPtr  = mod_god_mode_alloc(len);
const closePtr= mod_god_mode_alloc(len);
const volPtr  = mod_god_mode_alloc(len);
new Float64Array(memory.buffer, highPtr, len).set(high);
new Float64Array(memory.buffer, lowPtr,  len).set(low);
new Float64Array(memory.buffer, closePtr,len).set(close);
new Float64Array(memory.buffer, volPtr,  len).set(volume);

// Allocate outputs
const outWPtr = mod_god_mode_alloc(len);
const outSPtr = mod_god_mode_alloc(len);
const outHPtr = mod_god_mode_alloc(len);

// Pass mode as string; has_volume indicates whether vol_ptr is used
mod_god_mode_into(
  highPtr, lowPtr, closePtr, volPtr,
  len, /* has_volume= */ true,
  17, 6, 4, 'tradition_mg',
  outWPtr, outSPtr, outHPtr
);

// Read results
const wt = new Float64Array(memory.buffer, outWPtr, len).slice();
const sig = new Float64Array(memory.buffer, outSPtr, len).slice();
const hist = new Float64Array(memory.buffer, outHPtr, len).slice();

// Free allocations
for (const [ptr] of [[highPtr],[lowPtr],[closePtr],[volPtr],[outWPtr],[outSPtr],[outHPtr]]) {
  mod_god_mode_free(ptr, len);
}
Flat Output Variant ▼

Flat layout for the three outputs (row-major [wt..., sig..., hist...]):

import { mod_god_mode_js_flat } from 'vectorta-wasm';

const res = mod_god_mode_js_flat(high, low, close, null, 17, 6, 4, 'tradition_mg', false);
// res has: { values: Float64Array, rows: 3, cols: len }
const { values, rows, cols } = res;
const wt = values.slice(0, cols);
const sig = values.slice(cols, 2*cols);
const hist = values.slice(2*cols, 3*cols);

Performance Analysis

Comparison:
View:
Loading chart...

AMD Ryzen 9 9950X (CPU) | NVIDIA RTX 4090 (GPU) | Benchmarks: 2026-01-05

Related Indicators

Alphatrend

Technical analysis indicator

Aso

Technical analysis indicator

Avsl

Technical analysis indicator

Buff Averages

Technical analysis indicator

Chandelier Exit

Technical analysis indicator

Dma

Technical analysis indicator