RSI

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

//@version=6
indicator("RSI", overlay = false, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500, max_bars_back = 5000)

// -----------------------------------------------------------------------------
// Constants
// -----------------------------------------------------------------------------
color AQUA_COLOR       = #4CC9F0
color PURPLE_COLOR     = #3F37C9
color LIGHT_GRAY_COLOR = #364156

// -----------------------------------------------------------------------------
// Common Variables
// -----------------------------------------------------------------------------
series float src = close

// -----------------------------------------------------------------------------
// DRO – Dominant Cycle Calculation
// -----------------------------------------------------------------------------
var int   max_array_size   = 15
var float[] ziggyzags      = array.new_float(0)
var float[] zzl            = array.new_float(0)
var float[] cycles         = array.new_float(0)
var int   dir1             = 0
var int   lastPivot        = 0
var int   lastPivotDistance= 0
float     domcycle         = 0.0
int       fastLength       = 3
int       slowLength       = 50
int       zigPeriod        = 30

add_to_zigzag(ptr, value, bindex) =>
    array.unshift(ptr, bindex)
    array.unshift(ptr, value)
    if array.size(ptr) > max_array_size
        array.pop(ptr)
        array.pop(ptr)

update_zigzag(ptr, value, bindex, dir) =>
    if array.size(ptr) == 0
        add_to_zigzag(ptr, value, bindex)
    else
        if (dir == 1 and value > array.get(ptr, 0)) or (dir == -1 and value < array.get(ptr, 0))
            array.set(ptr, 0, value)
            array.set(ptr, 1, bindex)
        0.

float ppo = 100.0 * (ta.ema(src, fastLength) - ta.ema(src, slowLength)) / ta.ema(src, slowLength)

int   leftBars     = zigPeriod - 1
float ph           = ta.pivothigh(ppo, leftBars, 0)
float pl           = ta.pivotlow (ppo, leftBars, 0)
bool  isPivotHigh  = not na(ph) and ph == ppo
bool  isPivotLow   = not na(pl) and pl == ppo
float highs        = isPivotHigh ? ph : na
float lows         = isPivotLow  ? pl : na

iff_1 = bool(lows) and na(highs) ? -1 : dir1
dir1 := bool(highs) and na(lows) ? 1 : iff_1

dir1changed = ta.change(dir1)

if bool(highs) or bool(lows)
    if bool(dir1changed)
        add_to_zigzag(ziggyzags, dir1 == 1 ? highs : lows, bar_index)
    else
        update_zigzag(ziggyzags, dir1 == 1 ? highs : lows, bar_index, dir1)

float currentZigVal   = array.size(ziggyzags) >= 2 ? array.get(ziggyzags, 0) : na
int   currentZigPoint = array.size(ziggyzags) >= 2 ? int(array.get(ziggyzags, 1)) : na

var float prevZigVal   = na
var int   prevZigPoint = na
bool      zigChanged   = (currentZigVal != prevZigVal) or (currentZigPoint != prevZigPoint)

prevZigVal   := currentZigVal
prevZigPoint := currentZigPoint

if array.size(ziggyzags) >= 6 and zigChanged
    float val   = array.get(ziggyzags, 0)
    int   point = int(array.get(ziggyzags, 1))
    float val1  = array.get(ziggyzags, 2)
    int   point1= int(array.get(ziggyzags, 3))

    var float lastVal1   = na
    var int   lastPoint1 = na
    bool      pivotInnerChanged = (val1 != lastVal1) or (point1 != lastPoint1)

    lastVal1   := val1
    lastPoint1 := point1

    lastPivotDistance := point - lastPivot
    lastPivot         := point1

    if not pivotInnerChanged
        if array.size(zzl) > 1
            float lastDistance = array.get(zzl, 1)
        if array.size(zzl) > 0
            array.shift(zzl)
        0.
    else
        if array.size(zzl) > 0
            lastPivotDistance := point - lastPivot
            0
        else
            if array.size(zzl) > 0
                array.shift(zzl)
            0
        0.

    array.unshift(zzl, lastPivotDistance)

if array.size(zzl) > max_array_size
    array.pop(zzl)

if array.size(zzl) > 3
    array.clear(cycles)
    for i = 1 to array.size(zzl) - 2
        float z1 = array.get(zzl, i)
        float z2 = array.get(zzl, i + 1)
        cycles.push(z1 + z2)
    domcycle := array.median(cycles)

// -----------------------------------------------------------------------------
// Adaptive RSI
// -----------------------------------------------------------------------------
int   adaptiveLen  = int(na(domcycle) or domcycle <= 0 ? 21 : domcycle)
float crsi         = 0.0
int   cyclelen     = adaptiveLen / 2
int   vibration    = 10
float leveling     = 10.0
int   cyclicmemory = adaptiveLen * 2

float torque     = 2.0 / (vibration + 1)
float phasingLag = (vibration - 1) / 2.0

var float up = 0.0
up := (math.max(ta.change(src), 0) + (cyclelen - 1) * nz(up[1])) / cyclelen

var float down = 0.0
down := (-math.min(ta.change(src), 0) + (cyclelen - 1) * nz(down[1])) / cyclelen

float rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - 100 / (1 + up / down)

crsi := torque * (2 * rsi - rsi[phasingLag]) + (1 - torque) * nz(crsi[1])

float lmax = -999999.0
float lmin =  999999.0

for i = 0 to cyclicmemory - 1
    if nz(crsi[i], -999999.0) > lmax
        lmax := nz(crsi[i])
        lmax
    else
        if nz(crsi[i], 999999.0) < lmin
            lmin := nz(crsi[i])
            lmin

float mstep = (lmax - lmin) / 100
float aperc = leveling / 100

float db = 0.0
for steps = 0 to 100
    float testvalue = lmin + mstep * steps
    float above     = 0
    float below     = 0

    for m = 0 to cyclicmemory - 1
        below := below + (crsi[m] < testvalue ? 1 : 0)
        below

    float ratio = below / cyclicmemory

    if ratio >= aperc
        db := testvalue
        break
    else
        continue

float ub = 0.0
for steps = 0 to 100
    float testvalue = lmax - mstep * steps
    float above     = 0

    for m = 0 to cyclicmemory - 1
        above := above + (crsi[m] >= testvalue ? 1 : 0)
        above

    float ratio = above / cyclicmemory

    if ratio >= aperc
        ub := testvalue
        break
    else
        continue

// -----------------------------------------------------------------------------
// Render
// -----------------------------------------------------------------------------
hline(30, color = color.new(LIGHT_GRAY_COLOR, 50), linestyle = hline.style_dashed)
hline(50, color = color.new(LIGHT_GRAY_COLOR, 30), linestyle = hline.style_dashed)
hline(70, color = color.new(LIGHT_GRAY_COLOR, 50), linestyle = hline.style_dashed)

plot(db,   "Low Band",  color = PURPLE_COLOR, display = display.pane)
plot(ub,   "High Band", color = PURPLE_COLOR, display = display.pane)
plot(crsi, "RSI",       color = AQUA_COLOR,   display = display.pane)

// -----------------------------------------------------------------------------
// Alert Conditions
// -----------------------------------------------------------------------------
alertcondition(ta.cross(crsi, db),  title="CRSI Crosses Low Band",  message="CRSI crossed the Low Band")
alertcondition(ta.cross(crsi, ub),  title="CRSI Crosses High Band", message="CRSI crossed the High Band")
alertcondition(ta.cross(crsi, 50),  title="CRSI Crosses 50",       message="CRSI crossed 50")