NET MyRSI (Noise-Eliminated MyRSI)

Parameters: period = 14

Overview

NET MyRSI enhances John Ehlers' MyRSI oscillator with a Noise Elimination Technique that filters market noise by ranking pairwise comparisons of recent momentum values, producing an exceptionally smooth signal bounded between -1 and 1. The indicator first calculates MyRSI values that measure the balance between upward and downward price changes, then applies the NET filter which examines whether newer MyRSI readings consistently exceed older ones within the lookback window. This dual processing creates a momentum indicator that responds to genuine trend changes while ignoring minor fluctuations that plague traditional RSI variants. Values approaching 1 indicate strong upward momentum with consistent improvement in readings, while values near -1 signal deteriorating momentum across the evaluation period. Traders appreciate NET MyRSI for its ability to maintain smooth signals even in choppy markets, making it particularly effective for identifying trend continuations and avoiding premature exits during minor retracements.

Implementation Examples

Compute NET MyRSI from a price slice or candles:

use vector_ta::indicators::net_myrsi::{net_myrsi, NetMyrsiInput, NetMyrsiParams};
use vector_ta::utilities::data_loader::{Candles, read_candles_from_csv};

// Using with price data slice
let prices = vec![100.0, 101.0, 100.5, 102.0, 103.2, 102.8];
let params = NetMyrsiParams { period: Some(14) }; // default 14
let input = NetMyrsiInput::from_slice(&prices, params);
let out = net_myrsi(&input)?;

// Using with Candles (defaults: source="close", period=14)
let candles: Candles = read_candles_from_csv("data/sample.csv")?;
let input = NetMyrsiInput::with_default_candles(&candles);
let out = net_myrsi(&input)?;

// Access values
for v in out.values { println!("NET MyRSI: {}", v); }

API Reference

Input Methods ▼ 
// From price slice
NetMyrsiInput::from_slice(&[f64], NetMyrsiParams) -> NetMyrsiInput

// From candles with custom source (e.g., "close")
NetMyrsiInput::from_candles(&Candles, &str, NetMyrsiParams) -> NetMyrsiInput

// From candles with default params (close, period=14)
NetMyrsiInput::with_default_candles(&Candles) -> NetMyrsiInput
Parameters Structure ▼ 
pub struct NetMyrsiParams {
    pub period: Option<usize>, // Default: 14
}
Output Structure ▼ 
pub struct NetMyrsiOutput {
    pub values: Vec<f64>, // NET MyRSI values in [-1, 1]
}
Validation, Warmup & NaNs ▼
  • period > 0 and period ≤ len(data); otherwise NetMyrsiError::InvalidPeriod.
  • Requires at least period + 1 valid points after the first finite value; otherwise NetMyrsiError::NotEnoughValidData.
  • Indices before the first finite input are NaN. Warmup index warm = first + period − 1 is 0.0 when period > 1 (otherwise NaN).
  • Streaming returns None until enough samples are buffered (prices: period + 1, MyRSI: period).
Error Handling ▼ 
use vector_ta::indicators::net_myrsi::{net_myrsi, NetMyrsiError};

match net_myrsi(&input) {
    Ok(output) => process(output.values),
    Err(NetMyrsiError::EmptyInputData) => eprintln!("Input is empty"),
    Err(NetMyrsiError::AllValuesNaN) => eprintln!("All values are NaN"),
    Err(NetMyrsiError::InvalidPeriod { period, data_len }) => {
        eprintln!("Invalid period: {} (len={})", period, data_len)
    }
    Err(NetMyrsiError::NotEnoughValidData { needed, valid }) => {
        eprintln!("Need {} data points after first valid, only {}", needed, valid)
    }
}

Python Bindings

Basic Usage ▼

Calculate NET MyRSI using NumPy arrays (default period=14):

import numpy as np
from vector_ta import net_myrsi

prices = np.array([100.0, 101.0, 100.5, 102.0, 103.2, 102.8], dtype=np.float64)

# Defaults
vals = net_myrsi(prices)

# Custom period and kernel selection
vals = net_myrsi(prices, period=14, kernel="auto")  # or "avx2", "scalar"

print(vals)
Streaming Real-time Updates ▼

Use the streaming helper to process ticks efficiently:

from vector_ta import NetMyrsiStream

stream = NetMyrsiStream(14)
for price in price_feed:
    v = stream.update(price)
    if v is not None:
        print(f"NET MyRSI: {v}")
Batch Parameter Optimization ▼

Evaluate multiple period values:

import numpy as np
from vector_ta import net_myrsi_batch

prices = np.array([...], dtype=np.float64)

res = net_myrsi_batch(prices, period_range=(10, 20, 5), kernel="auto")

print(res['values'].shape)  # (num_periods, len(prices))
print(res['periods'])       # [10, 15, 20]

# Select a specific row
row_idx = list(res['periods']).index(15)
row = res['values'][row_idx]
CUDA Acceleration ▼

CUDA helpers are available when the Python package is built with CUDA support. Inputs must be float32; outputs are device arrays (DLPack / __cuda_array_interface__ compatible).

import numpy as np
from vector_ta import net_myrsi_cuda_batch_dev, net_myrsi_cuda_many_series_one_param_dev

# One series (float32)
data_f32 = np.asarray(load_data(), dtype=np.float32)

dev = net_myrsi_cuda_batch_dev(
    data_f32=data_f32,
    period_range=(5, 30, 5),
    device_id=0,
)

# Many series (time-major)
data_tm_f32 = np.asarray(load_data_time_major_matrix(), dtype=np.float32)

dev_tm = net_myrsi_cuda_many_series_one_param_dev(
    data_tm_f32=data_tm_f32,
    period=14,
    device_id=0,
)

JavaScript/WASM Bindings

Basic Usage ▼

Calculate NET MyRSI in JavaScript/TypeScript:

import { net_myrsi_js } from 'vectorta-wasm';

const prices = new Float64Array([100.0, 101.0, 100.5, 102.0]);
const result = net_myrsi_js(prices, 14);
console.log('NET MyRSI:', result);
Memory-Efficient Operations ▼

Use zero-copy operations for large datasets:

import { net_myrsi_alloc, net_myrsi_free, net_myrsi_into, memory } from 'vectorta-wasm';

const prices = new Float64Array([/* your data */]);
const n = prices.length;

const inPtr = net_myrsi_alloc(n);
const outPtr = net_myrsi_alloc(n);

new Float64Array(memory.buffer, inPtr, n).set(prices);

// Args: in_ptr, out_ptr, len, period
net_myrsi_into(inPtr, outPtr, n, 14);

const values = new Float64Array(memory.buffer, outPtr, n).slice();

net_myrsi_free(inPtr, n);
net_myrsi_free(outPtr, n);
Batch Processing ▼

Parameter sweep via unified batch API:

import { net_myrsi_batch } from 'vectorta-wasm';

const prices = new Float64Array([/* historical prices */]);
const config = { period_range: [10, 20, 5] };

// Returns { values: Float64Array, combos: { period }[], rows, cols }
const out = net_myrsi_batch(prices, config);

// Reshape flat values into rows x cols
const rows = out.rows, cols = out.cols;
const matrix: number[][] = [];
for (let r = 0; r < rows; r++) {
  const start = r * cols;
  matrix.push(Array.from(out.values.slice(start, start + cols)));
}

// Access parameter metadata
const periods = out.combos.map(c => c.period);
console.log(periods); // [10, 15, 20]

CUDA Bindings (Rust)

use vector_ta::cuda::CudaNetMyrsi;
use vector_ta::indicators::net_myrsi::NetMyrsiBatchRange;

let cuda = CudaNetMyrsi::new(0)?;

let data_f32: [f32] = /* ... */;
let sweep = NetMyrsiBatchRange::default();

let out = cuda.net_myrsi_batch_dev(&data_f32, &sweep)?;
let _ = out;

Performance Analysis

Comparison:
View:
Loading chart...

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

CUDA note

In our benchmark workload, the Rust CPU implementation is faster than CUDA for this indicator. Prefer the Rust/CPU path unless your workload differs.

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