Dynamic Volume RSI (DVRSI) [QuantAlgo] for Thinkorswim

[netarchitech]

On the surface this appears to be just another variation of the RSI, but the application of Volume makes this particular RSI worth it...
Author states: The Dynamic Volume RSI (DVRSI) is a unique indicator designed to provide more accurate and responsive signals by incorporating both price movement and volume sensitivity into the RSI framework. It begins by calculating the traditional RSI values based on a user-defined length and price source, but unlike standard RSI tools, the DVRSI applies volume-weighted adjustments to reflect the strength of market participation.

The indicator dynamically adjusts its sensitivity by factoring in volume to the RSI calculation, which means that price moves backed by higher volumes carry more weight, making the signal more reliable. This method helps identify stronger trends and reduces the risk of false signals in low-volume environments. To further enhance accuracy, the DVRSI offers an adaptive smoothing option that allows users to reduce noise during periods of market volatility. This adaptive smoothing function responds to market conditions, providing a cleaner signal by reducing erratic movements or price spikes that could lead to misleading signals.

Additionally, the DVRSI uses dynamic color-coding to visually represent the strength of bullish or bearish trends. The candles and RSI plots change color based on the RSI values crossing critical thresholds, such as the 50 level, offering an intuitive way to recognize trend shifts. Traders can also configure alerts for specific RSI crossovers (e.g., above 50 or below 40), ensuring that they stay informed of potential trend reversals and significant market shifts in real-time.

The combination of volume sensitivity, adaptive smoothing, and dynamic trend visualization makes the DVRSI a robust and versatile tool for traders and investors looking to fine-tune their market analysis. By incorporating both price and volume data, this indicator delivers more precise signals, helping users make informed decisions with greater confidence.

Here is the original Tradingview code:
https://www.tradingview.com/script/MXgu1xbN-Dynamic-Volume-RSI-DVRSI-QuantAlgo/

For the new ThinkOrSwim code, you must scroll down to the next post

 

[741]

Here is my progress so far with conversion:

# Dynamic Volume RSI (DVRSI) [QuantAlgo]

declare lower;

input rsi_length = 14;
input priceSourceInput = {default HLC3, CLOSE, OHLC4, HIGH, LOW, OPEN, HL2};
input enable_smoothing = YES;
input smoothing_length = 14;
input paint_trend_candles = YES;
DefineGlobalColor("Bullish", CreateColor(0, 255, 170)); # #00ffaa
DefineGlobalColor("Bearish", CreateColor(255, 0, 0));   # #ff0000

def price_src;
switch (priceSourceInput) {
    case CLOSE:
        price_src = close;
    case HLC3:
        price_src = (high + low + close) / 3;
    case OHLC4:
        price_src = (open + high + low + close) / 4;
    case HIGH:
        price_src = high;
    case LOW:
        price_src = low;
    case OPEN:
        price_src = open;
    case HL2:
        price_src = (high + low) / 2;
}

def vol_volatility = fold i = 0 to Min(smoothing_length-1, 29) with v = 0 do
    v + AbsValue(GetValue(volume, i) - GetValue(volume, i+1));
def vol_change = AbsValue(volume - GetValue(volume, smoothing_length));
def vol_alpha = 1.0 / smoothing_length;

rec vol_rma = if IsNaN(vol_rma[1]) then
                 SimpleMovingAvg(volume, smoothing_length)
              else
                 vol_alpha * volume + (1 - vol_alpha) * vol_rma[1];

def vol_efficiency_ratio = if vol_volatility != 0 then vol_change / vol_volatility else 0;
def fast_end = 2.0 / (2.0 + 1);
def slow_end = 2.0 / (30.0 + 1);
def vol_smooth_factor = Power(vol_efficiency_ratio * (fast_end - slow_end) + slow_end, 2);
def vol_dynamic_ema = vol_rma + vol_smooth_factor * (volume - vol_rma);
def final_volume = if enable_smoothing then vol_dynamic_ema else volume;
def price_change = price_src - GetValue(price_src, 1);
def up_vol = Max(price_change, 0) * final_volume;
def down_vol = AbsValue(Min(price_change, 0)) * final_volume;
def up_alpha = 1.0 / rsi_length;

rec up_rma = if IsNaN(up_rma[1]) then
               SimpleMovingAvg(up_vol, rsi_length)
            else
               up_alpha * up_vol + (1 - up_alpha) * up_rma[1];

def down_alpha = 1.0 / rsi_length;
rec down_rma = if IsNaN(down_rma[1]) then
                 SimpleMovingAvg(down_vol, rsi_length)
              else
                 down_alpha * down_vol + (1 - down_alpha) * down_rma[1];

def raw_rsi = if down_rma == 0 then 100 else if up_rma == 0 then 0 else 100 - (100 / (1 + up_rma / down_rma));
def smooth = 2.0 / (rsi_length + 1);
def ema_value = ExpAverage(raw_rsi, rsi_length);
def dvrsi = ema_value + smooth * (raw_rsi - ema_value);
def prev_dvrsi = GetValue(dvrsi, 1);
def prev2_dvrsi = GetValue(dvrsi, 2);
def prev3_dvrsi = GetValue(dvrsi, 3);

# Main DVRSI Line
plot DVRSILine = dvrsi;
DVRSILine.SetDefaultColor(Color.WHITE);
DVRSILine.SetLineWeight(2);

# Reference Lines
plot MidLine = 50;
MidLine.SetDefaultColor(Color.GRAY);
MidLine.SetStyle(Curve.SHORT_DASH);
plot TopLine = 90;
TopLine.SetDefaultColor(Color.DARK_GRAY);
TopLine.SetStyle(Curve.SHORT_DASH);
plot BottomLine = 10;
BottomLine.SetDefaultColor(Color.DARK_GRAY);
BottomLine.SetStyle(Curve.SHORT_DASH);
plot SixtyLine = 60;
SixtyLine.SetDefaultColor(Color.DARK_GRAY);
SixtyLine.SetStyle(Curve.POINTS);
plot FortyLine = 40;
FortyLine.SetDefaultColor(Color.DARK_GRAY);
FortyLine.SetStyle(Curve.POINTS);

# Trend fill
AddCloud(DVRSILine, MidLine, GlobalColor("Bullish"), GlobalColor("Bearish"));

def bullish_shift = (dvrsi > 50 and prev_dvrsi <= 50) or (prev_dvrsi > 50 and prev2_dvrsi <= 50 and dvrsi > 50);
def bearish_shift = (dvrsi < 50 and prev_dvrsi >= 50) or (prev_dvrsi < 50 and prev2_dvrsi >= 50 and dvrsi < 50);
def overbought_signal = (dvrsi < 60 and prev_dvrsi >= 60) or (prev_dvrsi < 60 and prev2_dvrsi >= 60) or (prev2_dvrsi < 60 and prev3_dvrsi >= 60 and dvrsi < 60);
def oversold_signal = (dvrsi > 40 and prev_dvrsi <= 40) or (prev_dvrsi > 40 and prev2_dvrsi <= 40) or (prev2_dvrsi > 40 and prev3_dvrsi <= 40 and dvrsi > 40);

# Plot signals
plot BullSignal = if bullish_shift then 50 else Double.NaN;
BullSignal.SetPaintingStrategy(PaintingStrategy.POINTS);
BullSignal.SetLineWeight(4);
BullSignal.SetDefaultColor(GlobalColor("Bullish"));
plot BearSignal = if bearish_shift then 50 else Double.NaN;
BearSignal.SetPaintingStrategy(PaintingStrategy.POINTS);
BearSignal.SetLineWeight(4);
BearSignal.SetDefaultColor(GlobalColor("Bearish"));
plot OverboughtSignal = if overbought_signal then 75 else Double.NaN;
OverboughtSignal.SetPaintingStrategy(PaintingStrategy.ARROW_DOWN);
OverboughtSignal.SetLineWeight(3);
OverboughtSignal.SetDefaultColor(GlobalColor("Bearish"));
plot OversoldSignal = if oversold_signal then 25 else Double.NaN;
OversoldSignal.SetPaintingStrategy(PaintingStrategy.ARROW_UP);
OversoldSignal.SetLineWeight(3);
OversoldSignal.SetDefaultColor(GlobalColor("Bullish"));

# Bar coloring
AssignPriceColor(if !paint_trend_candles then Color.CURRENT else if dvrsi > 50 then GlobalColor("Bullish") else GlobalColor("Bearish"));

# Labels
AddLabel(yes, "DVRSI(" + rsi_length + "): " + Round(dvrsi, 1), if dvrsi > 50 then GlobalColor("Bullish") else GlobalColor("Bearish"));
AddLabel(bullish_shift, "Bullish Trend Shift", GlobalColor("Bullish"));
AddLabel(bearish_shift, "Bearish Trend Shift", GlobalColor("Bearish"));
AddLabel(overbought_signal, "Potential Overbought", GlobalColor("Bearish"));
AddLabel(oversold_signal, "Potential Oversold", GlobalColor("Bullish"));

 

[samer800]

https://www.tradingview.com/script/MXgu1xbN-Dynamic-Volume-RSI-DVRSI-QuantAlgo/
On the surface this appears to be just another variation of the RSI, but the application of Volume makes this particular RSI worth converting, IMHO...

Thank you for your time and consideration with this potential conversion...

View attachment 24256

Intro: Elevate your trading and investing strategies with the Dynamic Volume RSI (DVRSI), a powerful tool designed to provide clear insights into market momentum and trend shifts. This indicator is ideal for traders and investors who want to stay ahead of the curve by using volume-responsive calculations and adaptive smoothing techniques to enhance signal clarity and reliability.

More info: https://www.tradingview.com/script/MXgu1xbN-Dynamic-Volume-RSI-DVRSI-QuantAlgo/

Source Code:

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © QuantAlgo

// @version=5
indicator("Dynamic Volume RSI (DVRSI) [QuantAlgo]", shorttitle="QuantAlgo - DVRSI", format=format.price, precision=2, timeframe="", timeframe_gaps=true, explicit_plot_zorder=true)

//              ╔═══════════════════════════╗              //
//              ║    USER DEFINED INPUTS    ║              //
//              ╚═══════════════════════════╝              //

// Input Groups
var string IndexSettings  = "══════ Dynamic Volume RSI Settings ══════"
var string SmoothingGroup = "══════ Smoothing Settings ══════"
var string Appearance     = "══════ Appearance Settings ══════"
var string tooltip_1      = "Choose the source for calculating the index."
var string tooltip_2      = "Enable smoothing to reduce noise."

// Dynamic Volume RSI Settings
rsi_length                = input.int     (14, minval=1, title="RSI Length",                group=IndexSettings,  tooltip=tooltip_1)
price_source_input        = input.source  (hlc3,         title="Price Source",              group=IndexSettings,  tooltip=tooltip_1)

// Smoothing Settings
enable_smoothing          = input.bool    (true,         title="Enable Adaptive Smoothing", group=SmoothingGroup, tooltip=tooltip_2)
smoothing_length          = input.int     (14,           title="Smoothing Length",          group=SmoothingGroup)

// Appearance Settings
paint_trend_candles       = input.bool    (true,         title="Paint Candles by Trend?",   group=Appearance)
bullish_color             = input.color   (#00ffaa,    title="Bullish Trend Color",       group=Appearance)
bearish_color             = input.color   (#ff0000,    title="Bearish Trend Color",       group=Appearance)

//              ╔══════════════════════════╗              //
//              ║    COLOR DECLARATIONS    ║              //
//              ╚══════════════════════════╝              //

var color up_color   = bullish_color
var color down_color = bearish_color

//              ╔══════════════════════════╗              //
//              ║    CORE CALCULATIONS     ║              //
//              ╚══════════════════════════╝              //

// Adaptive Smoothing Calculation
DynamicEMA(source, length) =>
    fast_end         = 2 / (2 + 1)
    slow_end         = 2 / (30 + 1)
    change           = math.abs(source - source[length])
    volatility       = math.sum(math.abs(source - source[1]), length)
    efficiency_ratio = change / volatility
    smooth_factor    = math.pow(efficiency_ratio * (fast_end - slow_end) + slow_end, 2)
    ta.rma(source, length) + smooth_factor * (source - ta.rma(source, length))

// Noise Reduction to filter out sudden market spikes
NoiseReducer(source, length) =>
    smooth           = 2 / (length + 1)
    ta.ema(source, length) + smooth * (source - ta.ema(source, length))

// Dynamic Volume RSI with Adaptive Smoothing
DynamicVolumeRSI(source, length) =>
    smoothed_volume  = DynamicEMA(volume, smoothing_length)
    price_change     = ta.change(source)
    up               = ta.rma(math.max(price_change, 0) * smoothed_volume, length)
    down             = ta.rma(math.abs(math.min(price_change, 0)) * smoothed_volume, length)
    index            = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
    NoiseReducer(index, length)  // Noise reduction applied to smooth out the signal in choppy markets

// Calculate the Adaptive Dynamic Volume RSI (DVRSI)
dvrsi = DynamicVolumeRSI(price_source_input, rsi_length)

//              ╔══════════════════════════╗              //
//              ║         PLOTTING         ║              //
//              ╚══════════════════════════╝              //

// Plot the DVRSI
plot_dvrsi  = plot(dvrsi, histbase=50, color=color.new(chart.fg_color, 0), title="Adaptive Dynamic Volume RSI")
mid_line    = plot(50,                 color=color.new(chart.fg_color, 0), title="Mid Line")

// Overbought/Oversold Plotting
top_line    = plot(90, display=display.none)
bottom_line = plot(10, display=display.none)

// Trend Visualization
fill(plot_dvrsi, mid_line, color=dvrsi > 50 ? color.new(up_color, 90) : color.new(down_color, 90), title="Trend Fill")
fill(plot_dvrsi, mid_line, dvrsi, 50, color.new(chart.bg_color, 1000), dvrsi > 50 ? up_color : down_color)

fill(mid_line, top_line,    top_value=90, bottom_value=60, bottom_color=na, top_color=color.from_gradient(dvrsi, 20, 90, color.new(down_color, 100), color.new(down_color, 40)))
fill(mid_line, bottom_line, top_value=40, bottom_value=10, bottom_color=color.from_gradient(dvrsi, 20, 90, color.new(up_color, 40), color.new(up_color, 100)), top_color=na)

// Plot Bullish and Bearish Trend Shifts
plotchar(ta.crossover (dvrsi, 50) ? 50 : na, "Bullish Trend Shift", "·",  location.absolute, up_color,   size=size.large)
plotchar(ta.crossunder(dvrsi, 50) ? 50 : na, "Bearish Trend Shift", "·",  location.absolute, down_color, size=size.large)

// Plot Overbought and Oversold Signals
plotchar(ta.crossunder(dvrsi, 60) ? 75 : na, "Potential Overbought", "▼", location.absolute, down_color, size=size.tiny)
plotchar(ta.crossover (dvrsi, 40) ? 25 : na, "Potential Oversold", "▲",   location.absolute, up_color,   size=size.tiny)

//              ╔════════════════════════════════╗              //
//              ║    TREND COLOR VISUALIZATION   ║              //
//              ╚════════════════════════════════╝              //

// Barcolor based on DVRSI Trend
var bar_colour = #ffffff
if      dvrsi > 50
    bar_colour := up_color
else if dvrsi < 50
    bar_colour := down_color

barcolor(paint_trend_candles ? bar_colour : na)

//              ╔══════════════════════════╗              //
//              ║          ALERTS          ║              //
//              ╚══════════════════════════╝              //

alertcondition(ta.crossover (dvrsi, 50), "Bullish Trend Shift", "DVRSI Crossed Over 50")
alertcondition(ta.crossunder(dvrsi, 50), "Bearish Trend Shift", "DVRSI Crossed Under 50")
alertcondition(ta.crossunder(dvrsi, 60), "Bearish Take Profit", "DVRSI Crossed Below 60")
alertcondition(ta.crossover (dvrsi, 40), "Bullish Take Profit", "DVRSI Crossed Above 40")

//              ╔══════════════════════════╗              //
//              ║        CREATED BY        ║              //
//              ╚══════════════════════════╝              //

// ██████╗ ██╗   ██╗ █████╗ ███╗   ██╗████████╗     █████╗ ██╗      ██████╗  ██████╗
//██╔═══██╗██║   ██║██╔══██╗████╗  ██║╚══██╔══╝    ██╔══██╗██║     ██╔════╝ ██╔═══██╗
//██║   ██║██║   ██║███████║██╔██╗ ██║   ██║       ███████║██║     ██║  ███╗██║   ██║
//██║▄▄ ██║██║   ██║██╔══██║██║╚██╗██║   ██║       ██╔══██║██║     ██║   ██║██║   ██║
//╚██████╔╝╚██████╔╝██║  ██║██║ ╚████║   ██║       ██║  ██║███████╗╚██████╔╝╚██████╔╝
// ╚══▀▀═╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝       ╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚═════╝

check the below:

#// Indicator for TOS
#// © QuantAlgo
#indicator("Dynamic Volume RSI (DVRSI) [QuantAlgo]", shorttitle="QuantAlgo - DVRSI"
# Converted by Sam4Cok@Samer800    - 03/2025

Declare lower;

input timeframe = AggregationPeriod.MIN;
input colorBars = yes; # "Paint Candles by Trend?"
input rsi_length = 14; #, minval=1, title="RSI Length"
input PriceSource = FundamentalType.HLC3; # "Price Source"
input smoothing_length   = 14; # "Smoothing Length"
input overbought = 60;
input oversold = 40;


def na = Double.NaN;
def last = IsNaN(close);
def GAP = GetAggregationPeriod();
def tf = Max(GAP, timeframe);
def price_source_input = Fundamental(PriceSource, Period = tf);
#// Dynamic Volume RSI with Adaptive Smoothing
Script DynamicVolumeRSI {
input source = hlc3;
input length = 14;
input smoothing_length = 14;
input vol = volume;
    def fast_end   = 2 / (2 + 1);
    def slow_end   = 2 / (30 + 1);
    def change     = AbsValue(vol - vol[smoothing_length]);
    def volatility = sum(AbsValue(vol - vol[1]), smoothing_length);
    def efficiency_ratio = change / volatility;
    def smooth_factor    = power(efficiency_ratio * (fast_end - slow_end) + slow_end, 2);
    def rma = WildersAverage(vol, smoothing_length);
    def smoothed_volume = rma + smooth_factor * (vol - rma);
    def price_change = (source - source[1]);
    def up = WildersAverage(max(price_change, 0) * smoothed_volume, length);
    def dn = WildersAverage(AbsValue(min(price_change, 0)) * smoothed_volume, length);
    def index = if dn == 0 then 100 else if up == 0 then 0 else 100 - (100 / (1 + up / dn));
    def smooth = 2 / (length + 1);
    def ema = ExpAverage(index, length);
    def dynamicRsi = ema + smooth * (index - ema);
    plot out = dynamicRsi;
}

#// Calculate the Adaptive Dynamic Volume RSI (DVRSI)
def dvrsi = DynamicVolumeRSI(price_source_input, rsi_length, smoothing_length, volume(Period = tf)/10000);

#// Plot Bullish and Bearish Trend Shifts
def zeroCrossUp = (dvrsi > 50) and (dvrsi[1] <= 50);
def zeroCrossDn = (dvrsi < 50) and (dvrsi[1] >= 50);
plot zeroUp = if zeroCrossUp and !zeroCrossUp[1] then 50 else na; # "Bullish Trend Shift"
plot zeroDn = if zeroCrossDn and !zeroCrossDn[1] then 50 else na; # "Bearish Trend Shift"
zeroUp.SetPaintingStrategy(PaintingStrategy.POINTS);
zeroDn.SetPaintingStrategy(PaintingStrategy.POINTS);
zeroUp.SetDefaultColor(Color.GREEN);
zeroDn.SetDefaultColor(Color.RED);

#// Plot Overbought and Oversold Signals
plot obSig = if (dvrsi Crosses Below overbought) then overbought + 5 else na; # "Potential Overbought", "▼"
plot osSig = if (dvrsi Crosses Above oversold) then oversold - 5 else na; # "Potential Oversold", "▲"
obSig.SetPaintingStrategy(PaintingStrategy.LINE_VS_SQUARES);
osSig.SetPaintingStrategy(PaintingStrategy.LINE_VS_SQUARES);
obSig.SetDefaultColor(Color.MAGENTA);
osSig.SetDefaultColor(Color.CYAN);

#/ Plot the DVRSI
plot upper = if !last then 90 else na;
plot lower = if !last then 10 else na;
plot dvrsiLine = if !last then dvrsi else na; # "Adaptive Dynamic Volume RSI")
plot mid_line  = if !last then 50 else na; # "Mid Line"
plot obLine = if !last then overbought else na;
plot osLine = if !last then oversold else na;
upper.SetPaintingStrategy(PaintingStrategy.SQUARES);
lower.SetPaintingStrategy(PaintingStrategy.SQUARES);
obLine.SetStyle(Curve.SHORT_DASH);
osLine.SetStyle(Curve.SHORT_DASH);
dvrsiLine.SetDefaultColor(Color.CYAN);
mid_line.SetDefaultColor(Color.DARK_GRAY);
obLine.SetDefaultColor(Color.DARK_GRAY);
osLine.SetDefaultColor(Color.DARK_GRAY);

upper.AssignValueColor(CreateColor(dvrsi * 2.55, 0, 0));
lower.AssignValueColor(CreateColor(0,255- dvrsi * 2.55, 0));

#-- Clouds
AddCloud(dvrsiLine, mid_line, Color.DARK_GREEN, Color.DARK_RED);
AddCloud(dvrsiLine - (dvrsiLine-mid_line) / 1.5, mid_line, Color.DARK_GREEN, Color.CURRENT);
AddCloud(mid_line, mid_line - (mid_line - dvrsiLine) / 1.5, Color.DARK_RED, Color.CURRENT);

#-- bar Color

AssignPriceColor(if !colorBars then Color.CURRENT else
                 if dvrsiLine > 50 then Color.GREEN else
                 if dvrsiLine < 50 then Color.RED else Color.GRAY);

#-- END of CODE

 

[netarchitech]

@samer800 - Thank you so much...I really appreciate your time and effort to convert this indicator...

While I'm at it, I want to wish you all the best in your new endeavor...I hope we can look forward to seeing you around here from time to time...

Thanks again!

 

[RSC]

Good afternoon, I would like to know the possibility of incorporating a sound when the RSI line changes color, thank you.