Some useful TradingView Pinescript indicators from me

[qchartist]

These indicators have been converted by me and are not available in the public indicators database of tradingview

Code:

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

//@version=5
indicator(title="RD.COmbo", shorttitle="RD-Combo", overlay=false,
max_bars_back=2000, // Sufficient history for calculations, especially ForecastOsc
precision=2         // Adjust precision for plots if needed
)

// --- Input Parameters ---
bool DoAlertForEntry = input.bool(false, "Do Alert For Entry")
bool DoAlertForExit = input.bool(false, "Do Alert For Exit")
// HistorySize in MQL4 primarily limits the `start` loop iteration.
// In Pine Script, plots automatically handle historical data.
// We keep it as an input but it doesn't directly restrict plots.
int HistorySize_input = input.int(1000, "History Size", minval=100)
int ColorThreshold = input.int(5, "Color Threshold", minval=0, maxval=5)
float NoiseFilterRVI = input.float(0.03, "RVI Exit Threshold", minval=0.0, step=0.01) // MQL4 uses 0.2 in condition, but input is 0.03. Using input.
bool DebugLogger = input.bool(false, "Debug Logger (Console)")
bool DebugLoggerData = input.bool(false, "Debug Logger Data (Console)")

// --- Global variables for Signal State & Alerts ---
// `var` keyword ensures these variables retain their values across bars.
var int signalstate = 0 // 1 = Long, -1 = Short, 0 = Neutral
var bool didentryalert_pine = false
var bool didexitalert_pine = false

// --- ForecastOscillator Calculation Helper Functions ---

// Helper function to calculate the weighted sum for `wt`
f_calc_wt(src, len) =>
    float sum_val = 0.0
    // Iterate from the current bar's position `len - i` to access past `src` values.
    // MQL4 `Close[shift+length-i]` corresponds to `src[len - i]` for current bar `shift=0`.
    for i = 1 to len
        float tmp_coeff = i - (float(len) + 1.0) / 3.0
        sum_val += tmp_coeff * src[len - i]
    sum_val * 6.0 / (float(len) * (float(len) + 1.0))

// ForecastOscillator logic
f_forecast_osc_series(src_series, regress, t3, b) =>
    float b2 = b * b
    float b3 = b2 * b
    float c1 = -b3
    float c2 = (3 * (b2 + b3))
    float c3 = -3 * (2 * b2 + b + b3)
    float c4 = (1 + 3 * b + b3 + 3 * b2)
    float n = 1 + 0.5 * (float(t3) - 1)
    float w1 = 2 / (n + 1)
    float w2 = 1 - w1

    // Calculate wt for the current bar
    float wt = f_calc_wt(src_series, regress)

    // Ensure `wt` is not too close to zero to avoid division by zero
    float forecastosc = (src_series - wt) / (math.abs(wt) < 1e-10 ? 1e-10 : wt) * 100

    // T3 smoothing chain - these variables must persist across bars
    var float e1 = na
    var float e2 = na
    var float e3 = na
    var float e4 = na
    var float e5 = na
    var float e6 = na
   
    // Using nz() to handle initial `na` values
    e1 := w1 * forecastosc + w2 * nz(e1[1])
    e2 := w1 * e1 + w2 * nz(e2[1])
    e3 := w1 * e2 + w2 * nz(e3[1])
    e4 := w1 * e3 + w2 * nz(e4[1])
    e5 := w1 * e4 + w2 * nz(e5[1])
    e6 := w1 * e5 + w2 * nz(e6[1])
   
    float t3_fosc = c1 * e6 + c2 * e5 + c3 * e4 + c4 * e3
   
    [forecastosc, t3_fosc] // Return both series

// --- Pre-calculate Forecast Oscillator values ---
// Call the function on the 'close' series with MQL4's default parameters (15, 3, 0.7)
[Osc, Osct3] = f_forecast_osc_series(close, 15, 3, 0.7)


// --- Combo Indicator Logic (Translated from MQL4's Combo function) ---

// Calculate all necessary indicator values for the current bar.
// MQL4's `lookupidx` corresponds to `[0]` for the current bar in Pine.
float ma5 = ta.wma(close, 5)
float ma20 = ta.wma(close, 20)
float ma100 = ta.wma(close, 100)
float ma200 = ta.wma(close, 200)

float cci = ta.cci(close, 5)

// --- MANUAL RVI CALCULATION (REPLACEMENT FOR ta.rvi) ---
// RVI Main (period 1 from MQL4) = (Close - Open) / (High - Low)
float rvi_numerator_raw = close - open
float rvi_denominator_raw = high - low
float rvimain = rvi_denominator_raw != 0 ? rvi_numerator_raw / rvi_denominator_raw : 0.0

// RVI Signal (period 1 from MQL4 implies a 4-period SMA of the main RVI)
float rvisignal = ta.sma(rvimain, 4)
// --- END MANUAL RVI CALCULATION ---


// --- MANUAL ADX/DI CALCULATION (REPLACEMENT FOR ta.adx, ta.plus_di, ta.minus_di) ---
f_calculate_adx_di(len) =>
    // True Range
    tr1 = high - low
    tr2 = math.abs(high - close[1])
    tr3 = math.abs(low - close[1])
    tr = math.max(tr1, tr2, tr3)

    // Directional Movement
    up = high - high[1]
    down = low[1] - low

    plusDM = up > down and up > 0 ? up : 0
    minusDM = down > up and down > 0 ? down : 0

    // Smoothed True Range and Directional Movements using RMA (Wilders Smoothing)
    // ta.rma is the Pine Script equivalent of Wilders Smoothing
    smoothTR = ta.rma(tr, len)
    smoothPlusDM = ta.rma(plusDM, len)
    smoothMinusDM = ta.rma(minusDM, len)

    // Calculate DI+ and DI-
    plusDI = smoothTR != 0 ? smoothPlusDM / smoothTR * 100 : 0
    minusDI = smoothTR != 0 ? smoothMinusDM / smoothTR * 100 : 0

    // Calculate DX
    sumDI = plusDI + minusDI
    dx = sumDI != 0 ? math.abs(plusDI - minusDI) / sumDI * 100 : 0

    // Calculate ADX (smoothed DX)
    adx = ta.rma(dx, len)
   
    [adx, plusDI, minusDI]

// Apply the manual ADX/DI calculation for period 14
[adxmain, adxplus, adxminus] = f_calculate_adx_di(14)

// For previous bar values, we can simply use the `[1]` operator on the calculated series
float adxmain2 = adxmain[1]
float adxplus2 = adxplus[1]
float adxminus2 = adxminus[1]
// --- END MANUAL ADX/DI CALCULATION ---

// Forecast Oscillator values for current bar (already calculated as series `Osc` and `Osct3`)
float fcblue = Osc
float fcred = Osct3

// Initialize signal components
int maval = 0
int ccival = 0
int rvival = 0
int adxval = 0
int fcval = 0

// MA signal
if ma5 > ma20
    maval := 1
else if ma5 < ma20
    maval := -1

// CCI signal
if cci > 0
    ccival := 1
else if cci < 0
    ccival := -1
// Else ccival remains 0

// Forecast Oscillator signal
if fcblue > 0 and fcred > 0 and fcblue > fcred
    fcval := 1
else if fcblue < 0 and fcred < 0 and fcblue < fcred
    fcval := -1
// Else fcval remains 0

// RVI signal
if rvimain > 0 and rvisignal > 0 and rvimain - rvisignal > 0
    rvival := 1
else if rvimain < 0 and rvisignal < 0 and rvimain - rvisignal < 0
    rvival := -1
// Else rvival remains 0

// ADX signal
if adxmain > adxmain2 and adxplus > adxplus2 and adxmain > 20 and adxplus > 20
    adxval := 1
else if adxmain > adxmain2 and adxminus > adxminus2 and adxmain > 20 and adxminus > 20
    adxval := -1
// Else adxval remains 0

// Calculate the total combined signal strength
float val = maval + ccival + fcval + rvival + adxval

// --- Exit Signal Logic ---
// Note: MQL4 used a constant `0.2` for RVI exit threshold, but `NoiseFilterRVI` input was 0.03.
// We are using the `NoiseFilterRVI` input for consistency.
if signalstate != 0
    if signalstate == 1 and (rvimain < 0 or (rvisignal - rvimain) > NoiseFilterRVI)
        signalstate := 0 // Exit long
    if signalstate == -1 and (rvimain > 0 or (rvimain - rvisignal) > NoiseFilterRVI)
        signalstate := 0 // Exit short

// --- Debugging Output (to Pine Script console) ---
if DebugLogger or DebugLoggerData
    // Check for sufficient historical bars before logging to avoid errors with `[1]` etc.
    if bar_index >= math.max(14, 200) // At least 200 bars for MAs, 14 for ADX. Min 31+regress=46 for FO.
        if DebugLoggerData
            log.info("--------------------------------------------------------------------------")
            log.info("Time: {0}, Bar: {1}, MA 5/20/100/200: {2}/{3}/{4}/{5}",
                 timenow, bar_index, ma5, ma20, ma100, ma200)
            log.info("Time: {0}, Bar: {1}, CCI: {2}, RVI: {3}/{4}",
                 timenow, bar_index, cci, rvimain, rvisignal)
            log.info("Time: {0}, Bar: {1}, ADX(now): {2}/{3}/{4}",
                 timenow, bar_index, adxmain, adxplus, adxminus)
            log.info("Time: {0}, Bar: {1}, ADX(prev): {2}/{3}/{4}",
                 timenow, bar_index, adxmain2, adxplus2, adxminus2)
            log.info("Time: {0}, Bar: {1}, Forecast blue/red: {2}/{3}",
                 timenow, bar_index, fcblue, fcred)

        log.info("Time: {0}, Bar: {1}, MAtrend({2}) + CCI({3}) + FC({4}) + RVItrend({5}) + ADXtrend({6}) => {7} # trade state = {8}",
             timenow, bar_index, maval, ccival, fcval, rvival, adxval, val, signalstate)


// --- Determine Plot Values ---
// These are the buffers from MQL4 (Neutral, Short, Long, Signal)
float NeutralBuffer_val = 0.0
float LongSignalBuffer_val = 0.0
float ShortSignalBuffer_val = 0.0

if val >= ColorThreshold
    LongSignalBuffer_val := val
    signalstate := 1 // Set signalstate to long if conditions met
else if val <= -ColorThreshold
    ShortSignalBuffer_val := val
    signalstate := -1 // Set signalstate to short if conditions met
else
    NeutralBuffer_val := val // Neutral, between thresholds
    // If we're neutral, but previously in a signal, it might be an exit condition.
    // The `signalstate` is managed by the exit logic above.
    // So if the current `val` is neutral, but `signalstate` was set by an exit condition, it remains 0.
    // If `val` is neutral and there was no exit, `signalstate` also becomes 0.
    if math.abs(val) < ColorThreshold and signalstate != 0
        signalstate := 0 // If signal goes neutral and no specific RVI exit occurred, also reset.


// SignalBuffer: MQL4 uses `2 * signalstate`
float SignalBuffer_val = 2 * signalstate

// --- Plotting ---
// Removed minval and maxval as they are not recognized in your environment.
// The indicator will now auto-scale based on the values plotted.
plot(NeutralBuffer_val, title="Neutral", color=color.rgb(128, 128, 128), style=plot.style_columns, linewidth=2, histbase=0) // Gray
plot(ShortSignalBuffer_val, title="Short Signal", color=color.rgb(255, 69, 0), style=plot.style_columns, linewidth=2, histbase=0) // OrangeRed
plot(LongSignalBuffer_val, title="Long Signal", color=color.rgb(124, 252, 0), style=plot.style_columns, linewidth=2, histbase=0) // LawnGreen

plot(SignalBuffer_val, title="Signal Line", color=color.rgb(255, 215, 0), style=plot.style_line, linewidth=1) // Gold

// Plotting MQL4 levels (4 and -4) - these will still help visually define a range.
hline(4, "Level +4", color.rgb(100, 100, 100), linestyle=hline.style_dashed)
hline(-4, "Level -4", color.rgb(100, 100, 100), linestyle=hline.style_dashed)


// --- Alerting Logic ---
// MQL4: `SignalBuffer[0]!=0 && SignalBuffer[1]==0` for entry
// Pine: `SignalBuffer_val != 0 and SignalBuffer_val[1] == 0` for entry
if DoAlertForEntry and SignalBuffer_val != 0 and nz(SignalBuffer_val[1]) == 0
    if not didentryalert_pine
        alert("RD signals trade entry on " + syminfo.ticker + "/" + timeframe.period, alert.freq_once_per_bar)
        didentryalert_pine := true
else
    didentryalert_pine := false // Reset alert flag when no entry signal

// MQL4: `SignalBuffer[0]==0 && SignalBuffer[1]!=0` for exit
// Pine: `SignalBuffer_val == 0 and SignalBuffer_val[1] != 0` for exit
if DoAlertForExit and SignalBuffer_val == 0 and nz(SignalBuffer_val[1]) != 0
    if not didexitalert_pine
        alert("RD signals trade exit on " + syminfo.ticker + "/" + timeframe.period, alert.freq_once_per_bar)
        didexitalert_pine := true
else
    didexitalert_pine := false // Reset alert flag when no exit signal

Code:

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

//@version=5
indicator(title="Weekly Pivot", shorttitle="WeeklyPivot", overlay=true)

//--- Global variables for pivot values (will retain their value across bars)
var float P_val  = na
var float S1_val = na
var float R1_val = na
var float S2_val = na
var float R2_val = na
var float S3_val = na
var float R3_val = na

//--- Global variables for labels (will hold label IDs)
var label P_label  = na
var label S1_label = na
var label R1_label = na
var label S2_label = na
var label R2_label = na
var label S3_label = na
var label R3_label = na

// --- Input for font size (from MQL4's fontsize)
var int fontsize_input = input.int(10, "Label Font Size", minval=6, maxval=24)

// --- Detect start of a new week (typically Monday, first bar of the week)
// `ta.change(time("W"))` returns true on the first bar of a new weekly period.
new_week = ta.change(time("W"))

// --- Get previous week's data
// request.security is used to fetch historical High, Low, and Close from the *completed* previous week.
// `[1]` refers to the previous weekly bar.
// `lookahead=barmerge.lookahead_on` ensures we get the value from the *closed* previous week.
[prev_w_high, prev_w_low, prev_w_close] = request.security(syminfo.tickerid, "W", [high[1], low[1], close[1]], lookahead=barmerge.lookahead_on)

// --- Main Calculation: Calculate pivots only on the first bar of a new week ---
if new_week
    // The current bar's open is the open of the new week.
    current_week_open = open

    // Calculate Pivot Points based on the MQL4 formula:
    // P = (Previous Week High + Previous Week Low + Current Week Open + Previous Week Close) / 4
    P_val  := (prev_w_high + prev_w_low + current_week_open + prev_w_close) / 4
    R1_val := (2 * P_val) - prev_w_low
    S1_val := (2 * P_val) - prev_w_high
    R2_val := P_val + (prev_w_high - prev_w_low)
    S2_val := P_val - (prev_w_high - prev_w_low)
    R3_val := (2 * P_val) + (prev_w_high - (2 * prev_w_low))
    S3_val := (2 * P_val) - ((2 * prev_w_high) - prev_w_low)

    // --- Create/Update Labels for Pivot Levels ---
    // If labels don't exist yet (first run of script, or after reset), create them.
    // Otherwise, update their position and value.
    if na(P_label) // Check if the main pivot label is 'na' to know if all labels need creating
        // Create labels with transparent background (`color.new(color.white, 100)`)
        P_label  := label.new(x=time, y=P_val, text="Weekly Pivot Point", xloc=xloc.bar_time, yloc=yloc.price,
                             color=color.new(color.white, 100), textcolor=color.rgb(255, 0, 255), size=size.small, style=label.style_label_left) // Magenta
        S1_label := label.new(x=time, y=S1_val, text="wS 1", xloc=xloc.bar_time, yloc=yloc.price,
                              color=color.new(color.white, 100), textcolor=color.rgb(65, 105, 225), size=size.small, style=label.style_label_left) // RoyalBlue
        R1_label := label.new(x=time, y=R1_val, text="wR 1", xloc=xloc.bar_time, yloc=yloc.price,
                              color=color.new(color.white, 100), textcolor=color.rgb(220, 20, 60), size=size.small, style=label.style_label_left) // Crimson
        S2_label := label.new(x=time, y=S2_val, text="wS 2", xloc=xloc.bar_time, yloc=yloc.price,
                              color=color.new(color.white, 100), textcolor=color.rgb(65, 105, 225), size=size.small, style=label.style_label_left) // RoyalBlue
        R2_label := label.new(x=time, y=R2_val, text="wR 2", xloc=xloc.bar_time, yloc=yloc.price,
                              color=color.new(color.white, 100), textcolor=color.rgb(220, 20, 60), size=size.small, style=label.style_label_left) // Crimson
        S3_label := label.new(x=time, y=S3_val, text="wS 3", xloc=xloc.bar_time, yloc=yloc.price,
                              color=color.new(color.white, 100), textcolor=color.rgb(46, 139, 87), size=size.small, style=label.style_label_left) // SeaGreen
        R3_label := label.new(x=time, y=R3_val, text="wR 3", xloc=xloc.bar_time, yloc=yloc.price,
                              color=color.new(color.white, 100), textcolor=color.rgb(46, 139, 87), size=size.small, style=label.style_label_left) // SeaGreen
   
    // Update labels (for existing ones, and for newly created ones on the same bar)
    label.set_xy(P_label, x=time, y=P_val)
    label.set_xy(S1_label, x=time, y=S1_val)
    label.set_xy(R1_label, x=time, y=R1_val)
    label.set_xy(S2_label, x=time, y=S2_val)
    label.set_xy(R2_label, x=time, y=R2_val)
    label.set_xy(S3_label, x=time, y=S3_val)
    label.set_xy(R3_label, x=time, y=R3_val)

    // Update label text if you want to include values (MQL4 only used fixed text)
    // For example: `label.set_text(P_label, "Weekly Pivot Point: " + str.tostring(P_val))`
    // But sticking to MQL4 original, fixed text is used.

    // Update font size (MQL4 only sets this on init, but we can make it dynamic here if desired)
    // For a constant font size, it's better to pass it directly to label.new and avoid updating every week.
    // However, if we added an input for fontsize, we would set it here.
    // Example: label.set_size(P_label, f_get_label_size(fontsize_input))
    // For now, size.small is hardcoded based on MQL4's fontsize=10.

// --- Plotting the Pivot Lines ---
// The `P_val`, `S1_val`, etc. variables retain their last calculated value thanks to `var`.
// This makes them horizontal lines spanning the entire week until a new calculation occurs.

plot(P_val,  title="Weekly Pivot Point", color=color.rgb(255, 0, 255), linewidth=2, style=plot.style_line) // Magenta
plot(S1_val, title="W_S 1",              color=color.rgb(65, 105, 225), linewidth=2, style=plot.style_line) // RoyalBlue
plot(R1_val, title="W_R 1",              color=color.rgb(220, 20, 60),  linewidth=2, style=plot.style_line) // Crimson
plot(S2_val, title="W_S 2",              color=color.rgb(65, 105, 225), linewidth=2, style=plot.style_line) // RoyalBlue
plot(R2_val, title="W_R 2",              color=color.rgb(220, 20, 60),  linewidth=2, style=plot.style_line) // Crimson
plot(S3_val, title="W_S 3",              color=color.rgb(46, 139, 87),  linewidth=2, style=plot.style_line) // SeaGreen
plot(R3_val, title="W_R 3",              color=color.rgb(46, 139, 87),  linewidth=2, style=plot.style_line) // SeaGreen

Code:

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

//@version=5
indicator(title="Weighted WCCI", shorttitle="Weighted WCCI", overlay=false)

//--- Input Parameters ---
TCCIp       = input.int(7, "Turbo CCI Period", minval=1)
CCIp        = input.int(13, "CCI Period", minval=1)
overbslevel = input.float(200.0, "Overbought/Oversold Level")
triglevel   = input.float(50.0, "Trigger Level")
weight      = input.float(1.0, "Weight")

//--- Pine Script Buffers (variables for plotting) ---
var float ExtMapBuffer1 = na // Turbo CCI (Red)
var float ExtMapBuffer2 = na // CCI (DodgerBlue)
var float ExtMapBuffer3 = na // CCI Histogram (CadetBlue)
var float ExtMapBuffer4 = na // Overbought Level (Red)
var float ExtMapBuffer5 = na // Oversold Level (Red)
var float ExtMapBuffer6 = na // Trigger Level (RoyalBlue)
var float ExtMapBuffer7 = na // Negative Trigger Level (RoyalBlue)
var float ExtMapBuffer8 = na // Zero Level (PaleGreen)

//--- Global variables for trend tracking (mimicking MQL4's trend_counter and trend string) ---
var int trend_counter = 0
var string trend = "ZERO"

//--- Main Calculation ---
// MQL4's iCCI(NULL,0,Period,PRICE_TYPICAL,shift) translates to ta.cci(hlc3, Period)[shift]
// MQL4's iATR(NULL,0,Period,shift) translates to ta.atr(Period)[shift]

// Calculate CCI and Turbo CCI for the current bar (shift = 0 in MQL4)
float currentCCI  = ta.cci(hlc3, CCIp)
float currentTCCI = ta.cci(hlc3, TCCIp)

// Calculate ATR for the current bar (shift = 0 in MQL4)
float atr7  = ta.atr(7)
float atr49 = ta.atr(49)

float Kw = 0.0

if weight == 0
    Kw := 0.0
else
    Kw := weight * (atr7 / atr49)
    currentCCI  := currentCCI * Kw
    currentTCCI := currentTCCI * Kw

// Clamp values as per MQL4 logic
if currentTCCI > overbslevel + 50
    currentTCCI := overbslevel + 50
if currentCCI > overbslevel + 50
    currentCCI := overbslevel + 50
if currentCCI < -overbslevel - 50
    currentCCI := -overbslevel - 50
if currentTCCI < -overbslevel - 50
    currentTCCI := -overbslevel - 50

// Assign values to plotting variables
ExtMapBuffer1 := currentTCCI
ExtMapBuffer2 := currentCCI
ExtMapBuffer3 := currentCCI // Used for histogram
ExtMapBuffer4 := overbslevel
ExtMapBuffer5 := -overbslevel
ExtMapBuffer6 := triglevel
ExtMapBuffer7 := -triglevel
ExtMapBuffer8 := 0.0

// --- Trend Logic (for comment only) ---
// Pine Script executes on every bar, so we handle previous bar state with `[1]` or `var` variables.
// The MQL4 `shift==0` logic applies to the current bar.
if barstate.islast
    // Let's replicate the MQL4 logic as closely as possible for the `trend` string and `trend_counter`.
    // It is important to note that MQL4's `trend` variable is a global.
    // In Pine, `var` ensures persistence across bars.

    if currentCCI > 0
        if trend[1] == "UP" // Using [1] to get the value from the *previous* bar
            trend_counter := trend_counter[1] + 1
        else
            trend_counter := 1
            trend := "UP"
    else if currentCCI < 0 // Assuming MQL4 implied `currentCCI < 0` for "DOWN"
        if trend[1] == "DOWN"
            trend_counter := trend_counter[1] + 1
        else
            trend_counter := 1
            trend := "DOWN"
    else // currentCCI == 0 or very close
        trend_counter := 1
        trend := "ZERO"

    // The MQL4 'Comment' function for status bar text is removed for Pine compatibility
    // You can see the `trend` and `trend_counter` values in the Data Window when hovering over the indicator.


//--- Plotting ---
// Plot 0: Turbo CCI
// Changed color.red to color.rgb(255, 0, 0)
plot(ExtMapBuffer1, title="Turbo CCI", color=color.rgb(255, 0, 0), style=plot.style_line, linewidth=1)

// Plot 1: CCI
// Changed color.dodgerBlue to color.rgb(30, 144, 255)
plot(ExtMapBuffer2, title="CCI", color=color.rgb(30, 144, 255), style=plot.style_line, linewidth=3)

// Plot 2: CCI Histogram
// Changed color.cadetBlue to color.rgb(95, 158, 160)
plot(ExtMapBuffer3, title="CCI Histogram", color=color.rgb(95, 158, 160), style=plot.style_columns)

// Plot 3: Overbought Level (Red)
// Changed color.red to color.rgb(255, 0, 0)
plot(ExtMapBuffer4, title="Overbought Level", color=color.rgb(255, 0, 0), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 4: Oversold Level (Red)
// Changed color.red to color.rgb(255, 0, 0)
plot(ExtMapBuffer5, title="Oversold Level", color=color.rgb(255, 0, 0), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 5: Trigger Level (RoyalBlue)
// Changed color.royalBlue to color.rgb(65, 105, 225)
plot(ExtMapBuffer6, title="Trigger Level (+)", color=color.rgb(65, 105, 225), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 6: Negative Trigger Level (RoyalBlue)
// Changed color.royalBlue to color.rgb(65, 105, 225)
plot(ExtMapBuffer7, title="Trigger Level (-)", color=color.rgb(65, 105, 225), style=plot.style_line, linewidth=1, show_last=5000)

// Plot 7: Zero Level (PaleGreen)
// Changed color.paleGreen to color.rgb(152, 251, 152)
plot(ExtMapBuffer8, title="Zero Level", color=color.rgb(152, 251, 152), style=plot.style_line, linewidth=1, show_last=5000)

Code:

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

//@version=5
indicator("SwamiRSI_v1", shorttitle="SwamiRSI_v1", overlay=false)

//--- Input Parameters ---
var int g_visualMode  = input.int(0, "Visual Mode (0=original, 1=trend)", minval=0, maxval=1)
var int g_priceType   = input.int(0, "Applied Price (0=Close, 1=Open, 2=High, 3=Low, 4=Median, 5=Typical; 6=Weighted)", minval=0, maxval=6)
var int g_startLength = input.int(12, "RSI Start Period", minval=1)
var int g_endLength   = input.int(48, "RSI End Period", minval=1)
var int g_sampleLength = input.int(48, "Sample RSI Period (0=off)", minval=0)
var int g_smooth      = input.int(5, "Smoothing Period", minval=1)
var color g_upTrendColor  = input.color(color.lime, "UpTrend Color")
var color g_dnTrendColor  = input.color(color.red, "DownTrend Color")
var color g_flatColor     = input.color(color.yellow, "Flat Color (if CLR_NONE, 2 Color Mix)")
var int g_scaleMode   = input.int(1, "Scale Mode (0=J.Ehlers, 1=0...100)", minval=0, maxval=1)
var int g_swamiBars   = input.int(100, "Swami Bars (-1=off, 0=all Bars, >0=any number)")

// --- Helper Functions ---

// Get applied price based on input
f_get_price(priceType) =>
    switch priceType
        0 => close
        1 => open
        2 => high
        3 => low
        4 => (high + low) / 2
        5 => (high + low + close) / 3
        6 => (open + high + low + close) / 4
        => close // Default to close if invalid type

// Custom EMA function to mimic MQL4 behavior more closely
// It stores previous EMA value in a separate buffer for state management across bars
// `ema_array`: an array that stores the previous EMA value for each 'index' (used by MQL4's ema[][2])
// `price_val`: the current price value for the EMA calculation
// `period`: the EMA period
// `idx`: the index within the ema_array to store the value (corresponds to MQL4's `index` argument)
f_ema(ema_array, price_val, period, idx) =>
    prev_ema_val = array.get(ema_array, idx)
    current_ema_val = if bar_index == 0 or na(prev_ema_val)
        price_val
    else
        prev_ema_val + 1.0 / period * (price_val - prev_ema_val)
    array.set(ema_array, idx, current_ema_val)
    current_ema_val

// Custom _RSI calculation (mimics MQL4 logic)
// `index`: corresponds to the 'i' in the MQL4 loop, used for array indexing
// `change`: current price change (price[0] - price[1])
// `period`: RSI period (StartLength + index)
// `ema_array`: array to pass to the f_ema function
// `swamisize`: from MQL4's swamisize global
f_custom_rsi(index, change, period, ema_array, swamisize) =>
    totChg = math.abs(change)

    // MQL4's EMA function uses `ema[index][0]` and `ema[index][1]`, and `prevtime[index]`
    // Here, we use indices for `ema_array`:
    // NetChgAvg uses `index` (0 to swamisize-1)
    // TotChgAvg uses `index + swamisize`
    // Final RSI EMA uses `index + 2*swamisize`
    netChgAvg = f_ema(ema_array, change, period, index)
    totChgAvg = f_ema(ema_array, totChg, period, index + swamisize)

    chgRatio = if totChgAvg != 0
        netChgAvg / totChgAvg
    else
        0.0

    rsiVal = f_ema(ema_array, 2 * chgRatio + 0.5, g_smooth, index + 2 * swamisize)

    math.max(0, math.min(1, rsiVal)) // Clamp between 0 and 1

// --- Global Variables (converted from MQL4's global arrays) ---
var float[] g_ema = na // Will be initialized on first bar
var int[] g_trend = na   // Will be initialized on first bar

var float g_fuzzWidth = na
var float g_maxValue = na
var float g_minValue = na

var int g_swamisize = na
var float g_priceCurrent = na
var float g_pricePrevious = na

// --- For Box Management ---
// We need a global array to store all created boxes so we can delete them.
var box[] all_swami_boxes = array.new_box(0)

// --- Main Calculation ---
g_priceCurrent := f_get_price(g_priceType)
g_pricePrevious := f_get_price(g_priceType)[1] // Price of the previous bar

// Initialize/resize arrays and set initial values on first bar
if bar_index == 0
    g_swamisize := g_endLength - g_startLength + 1
    // Corrected lines: Directly assign newly created arrays
    g_ema := array.new_float(g_swamisize * 3, na) // Initialize with 'na' values
    g_trend := array.new_int(g_swamisize, 0)     // Initialize with 0s

    if g_sampleLength > 0
        g_sampleLength := math.max(g_startLength, g_sampleLength)
        g_sampleLength := math.min(g_endLength, g_sampleLength)

    if g_scaleMode == 0 // J. Ehlers mode
        g_fuzzWidth := 1.0
        g_maxValue := float(g_endLength)
        g_minValue := float(g_startLength)
    else // 0-100 mode
        g_fuzzWidth := 100.0 / (g_endLength - g_startLength)
        g_maxValue := 100.0
        g_minValue := 0.0

// Variables for plotting
var float rsiPlot = na
var float sumRSIPlot = na

// Only calculate if enough bars are available
if bar_index >= g_endLength
    currentChange = g_priceCurrent - g_pricePrevious

    swamiSum = 0.0
    swamiRSI_values = array.new_float(g_swamisize) // Temporary array for current bar's SwamiRSI values

    for i = 0 to g_swamisize - 1
        currentRsiPeriod = g_startLength + i
       
        // Calculate the custom RSI (clamped between 0 and 1)
        rsi_value_clamped = f_custom_rsi(i, currentChange, currentRsiPeriod, g_ema, g_swamisize)

        if g_visualMode == 0 // Original mode
            array.set(swamiRSI_values, i, rsi_value_clamped)
            swamiSum += rsi_value_clamped
        else // Trend mode
            // Get the trend state from the previous bar's calculation (stored in g_trend)
            current_trend_state = array.get(g_trend, i)
           
            if rsi_value_clamped > 0.5
                current_trend_state := 1
            else if rsi_value_clamped < 0.5
                current_trend_state := 0
           
            array.set(g_trend, i, current_trend_state) // Update global trend array for next bar
            array.set(swamiRSI_values, i, float(current_trend_state))
            swamiSum += float(current_trend_state)

    if g_scaleMode == 0 // J. Ehlers mode
        if g_sampleLength > 0
            // Find the index for sampleLength
            sampleIndex = g_sampleLength - g_startLength
            rsiPlot := float(g_startLength) + (float(g_swamisize) - 1.0) * array.get(swamiRSI_values, sampleIndex)
        else
            rsiPlot := na // If SampleLength is 0, MQL4 also seems to not plot RSI
        sumRSIPlot := float(g_startLength) + (float(g_swamisize) - 1.0) * (swamiSum / float(g_swamisize))
    else // 0-100 mode
        if g_sampleLength > 0
            // Find the index for sampleLength
            sampleIndex = g_sampleLength - g_startLength
            rsiPlot := 100.0 * array.get(swamiRSI_values, sampleIndex)
        else
            rsiPlot := na // If SampleLength is 0, MQL4 also seems to not plot RSI
        sumRSIPlot := 100.0 * (swamiSum / float(g_swamisize))

    // --- Dynamic Rectangle Plotting (Swami Bars) ---
    plot_boxes = false
    if g_swamiBars == 0
        plot_boxes = true // Plot on all bars
    else if g_swamiBars > 0 and bar_index >= (last_bar_index - g_swamiBars)
        plot_boxes = true // Plot for the last 'g_swamiBars' bars

    // Clear all existing boxes at the start of the current bar's calculation
    // or if the indicator is re-initializing (barstate.isfirst)
    if barstate.islast or barstate.isfirst
        // Added check for array size before looping to prevent out-of-bounds error
        if array.size(all_swami_boxes) > 0
            // Iterate through our stored box IDs and delete them
            for i = 0 to array.size(all_swami_boxes) - 1
                box.delete(array.get(all_swami_boxes, i))
        // Clear the array after deleting objects (can always clear an empty array safely)
        array.clear(all_swami_boxes)

    if plot_boxes
        for i = 0 to g_swamisize - 1
            currentSwamiRSI = array.get(swamiRSI_values, i)
            barColor = color.new(color.white, 0) // Initialize with a dummy color and full transparency

            isFlatColorNone = (g_flatColor == color.new(color.fuchsia, 0)) // Using fuchsia as proxy for CLR_NONE

            if isFlatColorNone // This implies a 2-color mix (UpTrendColor and DnTrendColor)
                r1 = color.r(g_dnTrendColor) + currentSwamiRSI * (color.r(g_upTrendColor) - color.r(g_dnTrendColor))
                g1 = color.g(g_dnTrendColor) + currentSwamiRSI * (color.g(g_upTrendColor) - color.g(g_dnTrendColor))
                b1 = color.b(g_dnTrendColor) + currentSwamiRSI * (color.b(g_upTrendColor) - color.b(g_dnTrendColor))
                barColor := color.rgb(math.round(r1), math.round(g1), math.round(b1))
            else // 3 Color Mix with FlatColor
                if currentSwamiRSI >= 0.5
                    r1 = color.r(g_upTrendColor) + 2 * (1 - currentSwamiRSI) * (color.r(g_flatColor) - color.r(g_upTrendColor))
                    g1 = color.g(g_upTrendColor) + 2 * (1 - currentSwamiRSI) * (color.g(g_flatColor) - color.g(g_upTrendColor))
                    b1 = color.b(g_upTrendColor) + 2 * (1 - currentSwamiRSI) * (color.b(g_flatColor) - color.b(g_upTrendColor))
                    barColor := color.rgb(math.round(r1), math.round(g1), math.round(b1))
                else
                    r1 = color.r(g_dnTrendColor) + 2 * currentSwamiRSI * (color.r(g_flatColor) - color.r(g_dnTrendColor))
                    g1 = color.g(g_dnTrendColor) + 2 * currentSwamiRSI * (color.g(g_flatColor) - color.g(g_dnTrendColor))
                    b1 = color.b(g_dnTrendColor) + 2 * currentSwamiRSI * (color.b(g_flatColor) - color.b(g_dnTrendColor))
                    barColor := color.rgb(math.round(r1), math.round(g1), math.round(b1))

            currentValue = if g_scaleMode == 0
                float(i + g_startLength)
            else
                float(i) * g_fuzzWidth

            // Create the box and store its ID in our global array
            newBox = box.new(time[0], currentValue - 0.5 * g_fuzzWidth,
                             time, currentValue + 0.5 * g_fuzzWidth,
                             border_color=barColor, border_width=0, bgcolor=color.new(barColor, 50))
            array.push(all_swami_boxes, newBox) // Add the new box ID to our array
    else
        // If not plotting boxes for this bar, ensure all boxes are deleted
        if bar_index == last_bar_index and g_swamiBars == -1
            // Added check for array size before looping
            if array.size(all_swami_boxes) > 0
                for i = 0 to array.size(all_swami_boxes) - 1
                    box.delete(array.get(all_swami_boxes, i))
            array.clear(all_swami_boxes)


// --- Plotting the Lines ---
plot(rsiPlot, "SwamiRSI_Sample", color.rgb(139, 0, 139), style=plot.style_line, linewidth=2) // DarkOrchid
plot(sumRSIPlot, "SummaryRSI", color.rgb(210, 105, 30), style=plot.style_line, linewidth=2) // Chocolate

// Plot horizontal lines for min/max values
plot(g_minValue, "Min Value", color.gray, style=plot.style_stepline)
plot(g_maxValue, "Max Value", color.gray, style=plot.style_stepline)

Code:

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

//@version=5
indicator("Past Regression Deviated", overlay=true)

// Input parameters
var int lrLength = input.int(500, "LR Length (bars back)", minval=1)
var float stdChannel1 = input.float(1.0, "Std Channel 1 Multiplier", minval=0.0)
var float stdChannel2 = input.float(2.0, "Std Channel 2 Multiplier", minval=0.0)
var float stdChannel3 = input.float(3.0, "Std Channel 3 Multiplier", minval=0.0)

// Function to calculate Linear Regression coefficients (a and b)
// Returns [a, b] for y = a + b*x, where x=0 is the *oldest* bar in the window
// and x=length-1 is the *current* bar in the window.
f_linreg_coeffs(source, length) =>
    if length <= 1
        [float(na), float(na), float(na)] // Return a, b, and a flag for denominator == 0
    else
        sumY = 0.0
        sumX = 0.0
        sumXY = 0.0
        sumX2 = 0.0
        for i = 0 to length - 1
            val = source[i]
            // 'x' here represents the position within the current `length` window,
            // with 0 being the oldest bar in the window, and `length - 1` being the newest (current bar).
            x = float(length - 1 - i)
            sumY += val
            sumXY += val * x
            sumX += x
            sumX2 += x * x
       
        denominator = length * sumX2 - sumX * sumX
       
        if denominator == 0
            [float(na), float(na), float(na)]
        else
            b = (length * sumXY - sumX * sumY) / denominator
            a = (sumY - b * sumX) / length
            [a, b, 1.0] // Return coefficients and success flag

// Function to calculate Standard Deviation
// Takes source series, regression coefficients (a, b), and length
calc_stddev(source, a_coeff, b_coeff, length) =>
    sumSquaredDev = 0.0
    count = 0
   
    if na(a_coeff) or na(b_coeff)
        0.0 // Cannot calculate if coefficients are NA

    for i = 0 to length - 1
        // 'x_val' is the position within the current `length` window for this bar `i`
        // where 0 is the oldest bar and `length - 1` is the current bar.
        x_val = float(length - 1 - i)
       
        // Calculate the LR value at this specific bar using the computed 'a' and 'b'
        lr_val_at_i = a_coeff + b_coeff * x_val
       
        dev = math.abs(source[i] - lr_val_at_i)
        sumSquaredDev += dev * dev
        count += 1
   
    if count <= 1
        0.0
    else
        math.sqrt(sumSquaredDev / (count - 1))

// Declare variables to store the calculated values
var float meanBuffer = na
var float lrPrice1 = na // This corresponds to the start of the LR line (oldest point in range)
var float currentStdDev = na

// Calculate on each historical bar and the last bar
if barstate.islast or barstate.isconfirmed
    // Get the regression coefficients for the current window
    [a_lr, b_lr, success_flag] = f_linreg_coeffs(close, lrLength)

    if not na(success_flag) // Only proceed if coefficients were calculated successfully
        // meanBuffer corresponds to the LR value at the current bar (newest point in range)
        meanBuffer := a_lr + b_lr * (lrLength - 1)
       
        // lrPrice1 corresponds to the LR value at the oldest bar in the range
        lrPrice1 := a_lr
       
        // Calculate standard deviation using the obtained coefficients
        currentStdDev := calc_stddev(close, a_lr, b_lr, lrLength)
    else
        meanBuffer := na
        lrPrice1 := na
        currentStdDev := na


// Plotting
plot(meanBuffer, "Mean", color.white)
//plot(meanBuffer + (stdChannel1 * currentStdDev), "1st Std up", color.white)
//plot(meanBuffer - (stdChannel1 * currentStdDev), "1st Std down", color.white)
//plot(meanBuffer + (stdChannel2 * currentStdDev), "2nd Std up", color.white)
//plot(meanBuffer - (stdChannel2 * currentStdDev), "2nd Std down", color.white)
plot(meanBuffer + (stdChannel3 * currentStdDev), "3rd Std up", color.white)
plot(meanBuffer - (stdChannel3 * currentStdDev), "3rd Std down", color.white)

Code:

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

//@version=5
indicator("Monthly Pivot Points", overlay=true)

// --- Function to get monthly OHLC ---
var float last_month_high = na
var float last_month_low = na
var float last_month_close = na
var float this_month_open = na

var float P = na
var float S1 = na
var float R1 = na
var float S2 = na
var float R2 = na
var float S3 = na
var float R3 = na

var int lastMonth = na
newMonth = (month != month[1])

// Track highest/lowest of previous month
if newMonth
    last_month_close := close[1]
    this_month_open := open
    last_month_high := high[1]
    last_month_low := low[1]
    for i = 1 to 500
        if (month[i] != month)
            last_month_high := math.max(last_month_high, high[i])
            last_month_low := math.min(last_month_low, low[i])
        else
            break
    P := (last_month_high + last_month_low + this_month_open + last_month_close) / 4
    R1 := (2 * P) - last_month_low
    S1 := (2 * P) - last_month_high
    R2 := P + (last_month_high - last_month_low)
    S2 := P - (last_month_high - last_month_low)
    R3 := (2 * P) + (last_month_high - 2 * last_month_low)
    S3 := (2 * P) - ((2 * last_month_high) - last_month_low)

// Extend pivots through the month
Pline = P
S1line = S1
R1line = R1
S2line = S2
R2line = R2
S3line = S3
R3line = R3

// Plot lines
plot(Pline, title="Monthly Pivot", color=color.red, linewidth=2)
plot(S1line, title="S1", color=color.blue, linewidth=1)
plot(R1line, title="R1", color=color.green, linewidth=1)
plot(S2line, title="S2", color=color.blue, linewidth=1)
plot(R2line, title="R2", color=color.green, linewidth=1)
plot(S3line, title="S3", color=color.orange, linewidth=1)
plot(R3line, title="R3", color=color.orange, linewidth=1)

Code:

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

//@version=5
indicator("Mogalef Bands", overlay=true)

// === Inputs ===
lp = input.int(25, title="Linear Regression Period")
sp = input.int(30, title="StdDev Period")

// === Helper function: Linear Regression ===
linear_regression(src, len) =>
    var float slope = na
    var float intercept = na
    float sumX = 0
    float sumY = 0
    float sumXY = 0
    float sumX2 = 0

    for i = 0 to len - 1
        sumX += i
        sumY += src[i]
        sumXY += i * src[i]
        sumX2 += i * i

    divisor = (len * sumX2 - sumX * sumX)
    slope := divisor == 0 ? 0 : (len * sumXY - sumX * sumY) / divisor
    intercept := (sumY - slope * sumX) / len

    // Value at bar zero (most recent)
    intercept + slope * (len - 1)

// === Build arrays for LinReg and StdDev ===
var float[] linreg_arr = array.new_float()
var float[] stddev_arr = array.new_float()

linreg_val = linear_regression(close, lp)
array.unshift(linreg_arr, linreg_val)
if array.size(linreg_arr) > 500
    array.pop(linreg_arr)

stddev_val = ta.stdev(array.get(linreg_arr, 0), sp)
array.unshift(stddev_arr, stddev_val)
if array.size(stddev_arr) > 500
    array.pop(stddev_arr)

// === Calculate bands ===
hiband = linreg_val + stddev_val * 2
loband = linreg_val - stddev_val * 2
median = (hiband + loband) / 2

// === Apply the Mogalef override logic ===
hiband_prev = nz(hiband[1])
loband_prev = nz(loband[1])
linreg_prev = nz(linreg_val[1])

hiband := (linreg_val < hiband_prev and linreg_val > loband_prev) ? hiband_prev : hiband
loband := (linreg_val < hiband_prev and linreg_val > loband_prev) ? loband_prev : loband
median := (hiband + loband) / 2

// === Plot bands ===
plot(hiband, color=color.red, title="Upper Band", style=plot.style_line)
plot(loband, color=color.green, title="Lower Band", style=plot.style_line)
plot(median, color=color.blue, title="Median", style=plot.style_line)

Code:

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

//@version=5
indicator("MA Channels FiboEnv Mid", overlay=true)

// === INPUT PARAMETERS ===
barsCount     = input.int(1000, title="Bars Count")
maPeriod      = input.int(55, title="MA Period")
maType        = input.string("SMA", title="MA Type", options=["SMA", "EMA", "SMMA", "LWMA"])
priceSource   = input.string("Median", title="Price Source", options=["Close", "Open", "High", "Low", "Median", "Typical", "Weighted"])
maShift       = input.int(0, title="MA Shift")

// === PRICE SOURCE ===
src = switch priceSource
    "Close" => close
    "Open" => open
    "High" => high
    "Low" => low
    "Median" => hl2
    "Typical" => (high + low + close) / 3
    "Weighted" => (high + low + close + close) / 4

// === MA FUNCTION ===
getMA(source, length) =>
    switch maType
        "SMA" => ta.sma(source, length)
        "EMA" => ta.ema(source, length)
        "SMMA" => ta.rma(source, length)
        "LWMA" => ta.wma(source, length)

// === CALCULATE RANGE OVER LAST barsCount BARS ===
var float maxDev = na
var float minDev = na

if bar_index >= barsCount + maPeriod
    maxDev := 0.0
    minDev := 0.0
    for i = 0 to barsCount
        ma_i = getMA(src[i], maPeriod)
        top = high[i] - ma_i
        bottom = low[i] - ma_i
        maxDev := math.max(maxDev, top)
        minDev := math.min(minDev, bottom)

// === FIBO OFFSETS ===
inc4 = math.abs(maxDev) > math.abs(minDev) ? maxDev : minDev
inc1 = (maxDev - minDev) * 0.118
inc2 = (maxDev - minDev) * 0.264
inc3 = (maxDev - minDev) * 0.5

// === BASE MA ===
baseMA = getMA(src[maShift], maPeriod)

// === CHANNEL LEVELS ===
fibUp100 = baseMA + inc3
fibDn23  = baseMA + inc2
fibDn38  = baseMA + inc1
fib50    = baseMA
fibUp38  = baseMA - inc1
fibUp23  = baseMA - inc2
fibDn100 = baseMA - inc3

// === PLOT ===
plot(fibUp100, title="FibMA Up 100%", color=color.purple)
plot(fibDn23,  title="FibMA Down 23.5%", color=color.purple)
plot(fibDn38,  title="FibMA Down 38.2 / Up 61.8%", color=color.purple)
plot(fib50,    title="FibMA 50%", color=color.purple)
plot(fibUp38,  title="FibMA Up 38.2 / Down 61.8%", color=color.purple)
plot(fibUp23,  title="FibMA Up 23.5%", color=color.purple)
plot(fibDn100, title="FibMA Down 100%", color=color.purple)

Code:

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

//@version=5
indicator("BB-HL", overlay=true)

// === INPUTS ===
per   = input.int(200, title="Period")
nDev  = input.float(2.0, title="Deviation Multiplier")

// === CALCULATIONS ===
medianPrice = hl2
ma = ta.sma(medianPrice, per)

// Compute squared deviation using max of High and Low deviation from MA
highDev = math.pow(high - ma, 2)
lowDev  = math.pow(low - ma, 2)
devMax  = math.max(highDev, lowDev)

// Rolling average of max squared deviation
devAvg = 0.0
devSum = 0.0

// Use a manual loop to simulate rolling sum of devMax
var float[] devBuffer = array.new_float()

// Update the buffer each bar
if bar_index > 0
    array.push(devBuffer, devMax)
    if array.size(devBuffer) > per
        array.shift(devBuffer)

// Compute rolling average from buffer
if array.size(devBuffer) >= per
    for i = 0 to array.size(devBuffer) - 1
        devSum := devSum + array.get(devBuffer, i)
    devAvg := devSum / per

// Standard deviation and bands
stdev = math.sqrt(devAvg)
upper = ma + nDev * stdev
lower = ma - nDev * stdev

// === PLOTS ===
plot(ma, title="MA", color=color.orange)
plot(upper, title="Upper Band", color=color.silver)
plot(lower, title="Lower Band", color=color.silver)

Code:

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

//@version=5
indicator("ATR Channels", overlay=true)

// === INPUTS ===
PeriodsATR   = input.int(18, title="ATR Period")
MA_Periods   = input.int(49, title="MA Period")
MA_type_opt  = input.string("SMA", title="MA Type", options=["SMA", "EMA", "WMA", "VWMA"])
Mult_Factor1 = input.float(1.6, title="Multiplier 1")
Mult_Factor2 = input.float(3.2, title="Multiplier 2")
Mult_Factor3 = input.float(4.8, title="Multiplier 3")

// === HELPER FUNCTIONS ===
get_ma(src, len) =>    MA_type_opt == "SMA"  ? ta.sma(src, len) :    MA_type_opt == "EMA"  ? ta.ema(src, len) :    MA_type_opt == "WMA"  ? ta.wma(src, len) :    MA_type_opt == "VWMA" ? ta.vwma(src, len) :    na

// === CORE CALCULATIONS ===
src = hlc3
atr = ta.atr(PeriodsATR)
ma = get_ma(src, MA_Periods)

// === CHANNEL LEVELS ===
ch1_upper = ma + Mult_Factor1 * atr
ch1_lower = ma - Mult_Factor1 * atr
ch2_upper = ma + Mult_Factor2 * atr
ch2_lower = ma - Mult_Factor2 * atr
ch3_upper = ma + Mult_Factor3 * atr
ch3_lower = ma - Mult_Factor3 * atr

// === PLOT ===
// Only the outermost bands are visible (like in your MQL4 indicator)
plot(ch3_upper, title="ATRu3", color=color.purple, linewidth=1)
plot(ch3_lower, title="ATRd3", color=color.purple, linewidth=1)

// Optional: Uncomment below to show inner bands too
//plot(ch1_upper, title="ATRu1", color=color.aqua, linewidth=1)
//plot(ch1_lower, title="ATRd1", color=color.aqua, linewidth=1)
//plot(ch2_upper, title="ATRu2", color=color.blue, linewidth=1)
//plot(ch2_lower, title="ATRd2", color=color.blue, linewidth=1)

// Optional: Plot the moving average line
//plot(ma, title="Moving Average", color=color.green)

Code:

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

//@version=5
indicator("TD Sequential", overlay=true)

var int numDown = 0
var int numUp = 0

pointSize = syminfo.mintick

// Recalculate TD counts
if close[1] < close[5]
    numDown += 1
else
    numDown := 0

if close[1] > close[5]
    numUp += 1
else
    numUp := 0

// Display Sell Setup (Down Count)
if (numDown > 0 and numDown < 10)
    label.new(bar_index[1], low[1] - 5 * pointSize, text=str.tostring(numDown), style=label.style_label_down, textcolor=color.red, size=size.small)
else if (numDown == 9)
    label.new(bar_index[1], low[1] - 5 * pointSize, text="9", style=label.style_label_down, textcolor=color.red, size=size.normal)
else if (close[1] < close[5] and numDown >= 10)
    label.new(bar_index[1], low[1] - 5 * pointSize, text=str.tostring(numDown), style=label.style_label_down, textcolor=color.orange, size=size.small)

// Display Buy Setup (Up Count)
if (numUp > 0 and numUp < 10)
    label.new(bar_index[1], high[1] + 10 * pointSize, text=str.tostring(numUp), style=label.style_label_up, textcolor=color.blue, size=size.small)
else if (numUp == 9)
    label.new(bar_index[1], high[1] + 10 * pointSize, text="9", style=label.style_label_up, textcolor=color.blue, size=size.normal)
else if (close[1] > close[5] and numUp >= 10)
    label.new(bar_index[1], high[1] + 10 * pointSize, text=str.tostring(numUp), style=label.style_label_up, textcolor=color.aqua, size=size.small)

Code:

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

//@version=5
indicator("CyAn 1 FT", overlay=false)

// === Input Parameters ===
lenth = input.int(5, title="Length")
maxbars = input.int(2000, title="Max Bars (not used in Pine)")

// === Recursive Buffers ===
var float aux_prev = 0.0
var float fish_prev = 0.0

// === Stochastic %K Calculation ===
k = ta.stoch(close, high, low, lenth)

// === Safe recursive update ===
var float aux = na
var float fish = na

if bar_index > lenth
    aux := 0.5 * ((k / 100.0 - 0.5) * 2) + 0.5 * aux_prev
    fish := 0.25 * math.log((1 + aux) / (1 - aux)) + 0.5 * fish_prev
    aux_prev := aux
    fish_prev := fish

// === Signal Line (1 bar lag) ===
signal = nz(fish[1])

// === Plotting ===
plot(aux, title="Aux", color=color.yellow, linewidth=2)
//plot(signal, title="Signal", color=color.red, linewidth=1)
hline(0.8, "Upper Level", color=color.yellow, linestyle=hline.style_dotted)
hline(-0.8, "Lower Level", color=color.yellow, linestyle=hline.style_dotted)

Code:

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

//@version=5
indicator("DVI_ValueChart", overlay=false)

var float dvi = na
midpoint = (high + low + high[1] + low[1] + high[2] + low[2] + high[3] + low[3] + high[4] + low[4]) / 10

dvu = (volume * (high - low) + volume[1] * (high[1] - low[1]) + volume[2] * (high[2] - low[2]) + volume[3] * (high[3] - low[3]) + volume[4] * (high[4] - low[4])) / 5 * 0.02

dv = volume * ((close - midpoint) / midpoint)
dv := dvu != 0 ? dv / dvu : 0

dvi := na(dvi[1]) ? dv : dvi[1] + dv

plot(dvi, title="DVI_ValueChart", color=color.aqua, linewidth=1)

Code:

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

//@version=5
indicator("Spud 2 (fixed)", overlay=false, max_bars_back=1000)

// Inputs
Per = input.int(15, minval=5, title="Period (must be multiple of 5)")
Pk = input.int(5, title="Pk")
Pd = input.int(3, title="Pd")
Ps = input.int(3, title="Ps")

factor = Per / 5

// Custom Stochastic Calculation on current bar using past bars only
customStoch() =>
    sumlo = 0.0
    sumhi = 0.0
    for j = 0 to Ps - 1
        barsBack = j * (Per / timeframe.multiplier)
        if barsBack <= bar_index
            clos1 = close[barsBack]
            pkLength = int(Pk * factor)
            highestHigh = ta.highest(high, pkLength)[barsBack]
            lowestLow = ta.lowest(low, pkLength)[barsBack]
            sumlo += clos1 - lowestLow
            sumhi += highestHigh - lowestLow
    sumhi <= 0 ? 100 : (sumlo / sumhi) * 100

// Linear regression on series data
lreg_series(buffer, length) =>
    if length <= 1
        na
    else
        Sx = 0.0
        Sy = 0.0
        Sxx = 0.0
        Sxy = 0.0
        for i = 0 to length - 1
            x = i * 1.0
            y = buffer[i]
            Sx += x
            Sy += y
            Sxx += x * x
            Sxy += x * y
        n = length * 1.0
        c = Sxx * n - Sx * Sx
        if c == 0
            na
        else
            beta = (n * Sxy - Sx * Sy) / c
            alpha = (Sy - beta * Sx) / n
            alpha

// Calculate SBuffer for current bar
SBuffer = customStoch()

// Calculate MaBuffer as linear regression of SBuffer over last Pd bars
MaBuffer = bar_index >= Pd - 1 ? lreg_series(SBuffer, Pd) : na

// Plot
//plot(SBuffer, color=color.gray, title="Stoch")
plot(MaBuffer, color=color.red, title="Ma")

Code:

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

//@version=5
indicator("TSI", overlay=false)

First_R = input.int(5, title="First EMA Period")
Second_S = input.int(8, title="Second EMA Period")

// Momentum (MTM)
mtm = close - close[1]
abs_mtm = math.abs(mtm)

// First smoothing
ema_mtm = ta.ema(mtm, First_R)
ema_abs_mtm = ta.ema(abs_mtm, First_R)

// Second smoothing
ema2_mtm = ta.ema(ema_mtm, Second_S)
ema2_abs_mtm = ta.ema(ema_abs_mtm, Second_S)

// TSI Calculation
tsi = 100 * ema2_mtm / ema2_abs_mtm

plot(tsi, title="TSI", color=color.yellow, linewidth=2)
hline(0, "Zero Line", color=color.gray)

Code:

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

//@version=5
indicator("Stochastic RSI [Ehlers]", overlay=false)

// === Input Parameters ===
rsiLength = input.int(5, title="RSI Length")
stocLength = input.int(5, title="Stochastic Length")
wmaLength = input.int(5, title="WMA Length")

// === Step 1: Calculate RSI ===
rsi = ta.rsi(close, rsiLength)

// === Step 2: Calculate Highest High and Lowest Low of RSI over Stochastic Length ===
hh = ta.highest(rsi, stocLength)
ll = ta.lowest(rsi, stocLength)

// === Step 3: Normalize RSI into Stochastic RSI ===
value1 = rsi - ll
value2 = hh - ll
value3 = value2 != 0 ? value1 / value2 : 0.0

// === Step 4: Smooth with WMA and scale ===
smoothed = ta.wma(value3, wmaLength)
stocRSI = 2.0 * (smoothed - 0.5)
trigger = stocRSI[1]

// === Plotting ===
plot(stocRSI, title="Stochastic RSI", color=color.red)
plot(trigger, title="Trigger", color=color.blue)
hline(0, color=color.gray, linestyle=hline.style_dotted)
hline(1, "Upper", color=color.gray, linestyle=hline.style_dashed)
hline(-1, "Lower", color=color.gray, linestyle=hline.style_dashed)

Code:

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

//@version=5
indicator("Anchored VWAP with Deviation Bands", overlay=true)

show_custom = input.bool(true, "Show Custom")
startfrom = input.time(timestamp("01 Jan 2020 00:00 +0000"), "Start From")
deviation_band_1 = input.float(1.0, "Deviation Band 1")

// Anchored region
var float cum_vp = na
var float cum_vol = na

// Reset at the anchor point
if (na(cum_vol))
    cum_vp := 0.0
    cum_vol := 0.0

is_after_start = time >= startfrom

vp = volume * hlc3

cum_vp := is_after_start ? cum_vp + vp : na
cum_vol := is_after_start ? cum_vol + volume : na

anchored_vwap = is_after_start and cum_vol != 0 ? cum_vp / cum_vol : na

// Store historical VWAP for deviation calculation
var float[] vwap_series = array.new_float()

if is_after_start
    array.unshift(vwap_series, anchored_vwap)
    if array.size(vwap_series) > bar_index
        array.pop(vwap_series)

// Calculate standard deviation from the anchored point
var float std_dev = na
if is_after_start and array.size(vwap_series) > 1
    float mean = anchored_vwap
    float sum_sq_diff = 0.0
    for i = 0 to array.size(vwap_series) - 1
        float val = array.get(vwap_series, i)
        sum_sq_diff += math.pow(val - mean, 2)
    std_dev := math.sqrt(sum_sq_diff / array.size(vwap_series))

upper_band = show_custom and not na(anchored_vwap) ? anchored_vwap + deviation_band_1 * std_dev : na
lower_band = show_custom and not na(anchored_vwap) ? anchored_vwap - deviation_band_1 * std_dev : na

plot(upper_band, color=color.red, title="Upper Band")
plot(lower_band, color=color.red, title="Lower Band")
plot(show_custom ? anchored_vwap : na, color=color.green, title="Anchored VWAP")

[qchartist]

Code:

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

//@version=5
indicator(title="Corona Trend Vigor v2.1", shorttitle="CTV v2.1", overlay=false,
     format=format.price, precision=2)

// --- Inputs ---
var TimeFrame = input.timeframe("0", "Time Frame") // "0" means current chart's timeframe
var PriceMode = input.int(4, "Price Mode (0-10)", minval=0, maxval=10)
var LineColor = input.color(color.blue, "Line Color")
var FuzzR = input.int(0, "Fuzz Red (0-255)", minval=0, maxval=255)
var FuzzG = input.int(0, "Fuzz Green (0-255)", minval=0, maxval=255)
var FuzzB = input.int(255, "Fuzz Blue (0-255)", minval=0, maxval=255)
var VisualMode = input.int(0, "Visual Mode (0-TV+Corona, 1-TV, 2-Corona)", minval=0, maxval=2)
var CoronaBars = input.int(1000, "Corona Bars (0 for all)", minval=0)

// --- Constants ---
float pi = math.atan(1) * 4

// --- Global Variables (using var for persistence across bars) ---
var float[] Q = array.new_float(60, 0.0)
var float[] I = array.new_float(60, 0.0)
var float[] Real = array.new_float(60, 0.0)
var float[] Imag = array.new_float(60, 0.0)
var float[] Ampl = array.new_float(60, 0.0)
var float[] DB = array.new_float(60, 0.0)
var float[] OldI = array.new_float(60, 0.0)
var float[] OlderI = array.new_float(60, 0.0)
var float[] OldQ = array.new_float(60, 0.0)
var float[] OlderQ = array.new_float(60, 0.0)
var float[] OldReal = array.new_float(60, 0.0)
var float[] OlderReal = array.new_float(60, 0.0)
var float[] OldImag = array.new_float(60, 0.0)
var float[] OlderImag = array.new_float(60, 0.0)
var float[] OldDB = array.new_float(60, 0.0)
var float[] Raster = array.new_float(51, 0.0)
var float[] OldRaster = array.new_float(51, 0.0)

var float FuzzWidth = 0.4 // Global constant

var int mcnt_bars = 0
var int per = 30 // MQL4 default

// --- Helper Functions ---

// Custom Heiken Ashi calculation
f_heiken_ashi(tf, price_type, bar_index_offset) =>
    // Determine the actual timeframe string for request.security
    string actual_tf = tf == "0" ? timeframe.period : tf
    
    // Get current bar's OHLC data for the specified timeframe using request.security
    [o, h, l, c] = request.security(syminfo.tickerid, actual_tf, [open, high, low, close], lookahead=barmerge.lookahead_on)

    // Using `var` to store HA values persistently, similar to MQL4 arrays
    var float ha_close = 0.0
    var float ha_open = 0.0
    var float ha_high = 0.0
    var float ha_low = 0.0

    // HA Close
    current_ha_close = (o + h + l + c) / 4.0
    
    // HA Open
    // For the very first bar, ha_open[1] and ha_close[1] will be na, so use nz()
    current_ha_open = bar_index == 0 ? (o + c) / 2.0 : (nz(ha_open[1]) + nz(ha_close[1])) / 2.0

    // HA High
    current_ha_high = math.max(h, current_ha_open, current_ha_close)

    // HA Low
    current_ha_low = math.min(l, current_ha_open, current_ha_close)
    
    // Update `var` HA values for next bar's calculation
    ha_close := current_ha_close
    ha_open := current_ha_open
    ha_high := current_ha_high
    ha_low := current_ha_low
    
    // Return the requested HA price type
    float ha_val = 0.0
    if price_type == 0 // haClose
        ha_val := current_ha_close
    else if price_type == 1 // haOpen
        ha_val := current_ha_open
    else if price_type == 2 // haHigh
        ha_val := current_ha_high
    else if price_type == 3 // haLow
        ha_val := current_ha_low
    
    ha_val

// Custom Median function (for series)
// Now accepts a 'series float' and creates a temporary array from its history.
f_median(input_series, count) =>
    // Return 'na' if there aren't enough bars for the 'count' period
    if bar_index < count - 1
        na
    else
        // Create a temporary array to hold the last 'count' values from the series
        temp_arr = array.new_float(count)
        
        // Populate the array with values from the series_input
        // input_series[0] is current, input_series[1] is 1 bar ago, etc.
        for i = 0 to count - 1
            array.set(temp_arr, i, input_series[i])

        array.sort(temp_arr)
        
        float median_val = 0.0
        int num = math.round(float(count - 1) / 2.0)
        
        if (count % 2) > 0 // Odd number of elements
            median_val := array.get(temp_arr, num)
        else // Even number of elements
            median_val := (array.get(temp_arr, num) + array.get(temp_arr, num + 1)) / 2.0
        
        median_val

// Function to get price based on PriceMode
f_get_price_series(mode, tf) =>
    // Determine the actual timeframe string for request.security
    string actual_tf = tf == "0" ? timeframe.period : tf

    // Request OHLC data from the specified timeframe unconditionally.
    [o, h, l, c] = request.security(syminfo.tickerid, actual_tf, [open, high, low, close], lookahead=barmerge.lookahead_on)

    // Calculate Heiken Ashi components unconditionally
    float ha_close_val = f_heiken_ashi(actual_tf, 0, 0)
    float ha_open_val  = f_heiken_ashi(actual_tf, 1, 0)
    float ha_high_val  = f_heiken_ashi(actual_tf, 2, 0)
    float ha_low_val   = f_heiken_ashi(actual_tf, 3, 0)

    // Use a switch statement to select the correct price series based on `mode`
    float price_series_val = switch mode
        0  => c              // Close
        1  => o              // Open
        2  => h              // High
        3  => l              // Low
        4  => (h + l) / 2    // Median Price (H+L)/2
        5  => (h + l + c) / 3 // Typical Price (H+L+C)/3
        6  => (h + l + c * 2) / 4 // Weighted Close (H+L+C*2)/4
        7  => ha_close_val   // Heiken Ashi Close
        8  => ha_open_val    // Heiken Ashi Open
        9  => ha_high_val    // Heiken Ashi High
        10 => ha_low_val     // Heiken Ashi Low
        => c // Default case (should not be reached due to input.int min/max)

    price_series_val

// --- Indicator Buffers (Pine Script equivalent: series variables) ---
var float TV_line = na // This will hold the main Trend Vigor line

// --- Main Calculation ---
// MQL4 `start()` function logic converted to Pine Script's bar-by-bar execution.

// Get price for the current timeframe and PriceMode
float current_price = f_get_price_series(PriceMode, TimeFrame)
float prev_price = f_get_price_series(PriceMode, TimeFrame)[1] // Price of previous bar on selected TF

// --- Calculate HP and SmoothHP ---
var float HP = 0.0 // MQL4: HP[y]
var float SmoothHP = 0.0 // MQL4: SmoothHP[y]
var float prev_HP = 0.0 // MQL4: HP[y-1]
var float prev_SmoothHP = 0.0 // MQL4: SmoothHP[y-1]
var float prev2_HP = 0.0
var float prev3_HP = 0.0
var float prev4_HP = 0.0
var float prev5_HP = 0.0

alpha1 = (1 - math.sin(2 * pi / 30)) / math.cos(2 * pi / 30)

// HP[y] = 0.5*(1 + alpha1)*(price[y] - price[y-1]) + alpha1*HP[y-1];
current_HP = 0.5 * (1 + alpha1) * (current_price - prev_price) + alpha1 * nz(prev_HP)

// SmoothHP[y] = (HP[y] + 2.0*HP[y-1] + 3.0*HP[y-2] + 3.0*HP[y-3] + 2.0*HP[y-4] + HP[y-5]) / 12.0;
current_SmoothHP = (current_HP + 2.0 * nz(prev_HP) + 3.0 * nz(prev2_HP) + 3.0 * nz(prev3_HP) + 2.0 * nz(prev4_HP) + nz(prev5_HP)) / 12.0

// MQL4 conditional: if(y < 6) SmoothHP[y] = price[y] - price[y-1]; if(y == 0) SmoothHP[y] = 0;
// Pine Script's `bar_index` handles initial bars:
if bar_index < 5 // Equivalent to y < 6 (as array indices are 0-based and [0] is current)
    current_SmoothHP := current_price - prev_price
if bar_index == 0
    current_SmoothHP := 0.0

// Update previous HP and SmoothHP for next bar's calculation
prev5_HP := prev4_HP
prev4_HP := prev3_HP
prev3_HP := prev2_HP
prev2_HP := prev_HP
prev_HP := current_HP
SmoothHP := current_SmoothHP // Assign to persistent SmoothHP variable

// --- Calculate Corona Trend Vigor ---
// MQL4's `y` is essentially `bar_index` in Pine Script.
float delta = -0.015 * (bar_index + 1) + 0.5
if delta < 0.1
    delta := 0.1

// Update OldI, OldQ, OldReal, OldImag, OldDB arrays for the current bar
for n = 11 to 59
    array.set(OlderI, n, array.get(OldI, n))
    array.set(OldI, n, array.get(I, n))
    array.set(OlderQ, n, array.get(OldQ, n))
    array.set(OldQ, n, array.get(Q, n))
    array.set(OlderReal, n, array.get(OldReal, n))
    array.set(OldReal, n, array.get(Real, n))
    array.set(OlderImag, n, array.get(OldImag, n))
    array.set(OldImag, n, array.get(Imag, n))
    array.set(OldDB, n, array.get(DB, n))

    float beta = math.cos(4 * pi / (n + 1))
    float gamma = 1.0 / math.cos(4 * pi * delta / (n + 1))
    float alpha = gamma - math.sqrt(gamma * gamma - 1)

    // Using `nz()` for previous bar's SmoothHP values as they are calculated on the current bar
    float prev_smoothHP_val = nz(SmoothHP[1])
    float prev2_smoothHP_val = nz(SmoothHP[2])

    array.set(Q, n, ((n + 1) / (4 * pi)) * (SmoothHP - prev_smoothHP_val))
    array.set(I, n, SmoothHP)

    float val_I = array.get(I, n)
    float val_OlderI = array.get(OlderI, n)
    float val_OldReal = array.get(OldReal, n)
    float val_OlderReal = array.get(OlderReal, n)
    
    float val_Q = array.get(Q, n)
    float val_OlderQ = array.get(OlderQ, n)
    float val_OldImag = array.get(OldImag, n)
    float val_OlderImag = array.get(OlderImag, n)

    array.set(Real, n, 0.5 * (1 - alpha) * (val_I - val_OlderI) + beta * (1 + alpha) * val_OldReal - alpha * val_OlderReal)
    array.set(Imag, n, 0.5 * (1 - alpha) * (val_Q - val_OlderQ) + beta * (1 + alpha) * val_OldImag - alpha * val_OlderImag)
    
    float real_val = array.get(Real, n)
    float imag_val = array.get(Imag, n)
    array.set(Ampl, n, real_val * real_val + imag_val * imag_val)


var float MaxAmpl = 0.0
// Find MaxAmpl
if bar_index > 11 // Need enough bars for initial calculations (similar to y > 11 in MQL4)
    MaxAmpl := array.get(Ampl, 11)
    for n = 11 to 59
        if array.get(Ampl, n) > MaxAmpl
            MaxAmpl := array.get(Ampl, n)

// Calculate DB values
if bar_index > 11
    for n = 11 to 59
        float dB_calc = 0.0
        if MaxAmpl != 0 and array.get(Ampl, n) / MaxAmpl > 0
            dB_calc := -10.0 * math.log10(0.01 / (1 - 0.99 * array.get(Ampl, n) / MaxAmpl))
        
        array.set(DB, n, 0.33 * dB_calc + 0.67 * array.get(OldDB, n))
        if array.get(DB, n) > 20
            array.set(DB, n, 20.0)

// Calculate Dominant Cycle (DC)
var float DC_val = 0.0 // MQL4: DC[y]
if bar_index > 11 // Needs enough bars for DB calculation
    float Num = 0.0
    float Denom = 0.0
    for n = 11 to 59
        if array.get(DB, n) <= 6
            Num := Num + (n + 1) * (20 - array.get(DB, n))
            Denom := Denom + (20 - array.get(DB, n))
    
    if Denom != 0
        DC_val := 0.5 * Num / Denom
    else if bar_index > 0
        DC_val := nz(DC_val[1]) // Equivalent to DC[y-1]

var float mDomCyc = 0.0 // MQL4: mDomCyc[y]
// We'll use series_DC directly as the input for f_median.
series_DC = DC_val // This remains a series float

// Ensure we have enough bars for the median calculation (current_bar_idx - i should be valid)
if bar_index >= 4 // For 5-period median, we need at least 4 previous bars (0-4)
    mDomCyc := f_median(series_DC, 5) // Call f_median with series_DC and count
else
    mDomCyc := nz(mDomCyc[1]) // Keep previous value or na if not enough bars

if mDomCyc < 6
    mDomCyc := 6.0

// Filter Bandpass component (IP)
var float IP_val = 0.0 // MQL4: IP[y]
var float prev_IP_val = 0.0
var float prev2_IP_val = 0.0
float delta1 = 0.1
float beta1 = math.cos(2 * pi / mDomCyc)
float gamma1 = 1.0 / math.cos(4 * pi * delta1 / mDomCyc)
float alpha2 = gamma1 - math.sqrt(gamma1 * gamma1 - 1)

// IP[y] = 0.5*(1 - alpha2)*(price[y] - price[y-2]) + beta1*(1 + alpha2)*IP[y-1] - alpha2*IP[y-2];
current_IP_calc = 0.5 * (1 - alpha2) * (current_price - nz(current_price[2])) + beta1 * (1 + alpha2) * nz(prev_IP_val) - alpha2 * nz(prev2_IP_val)

// Update previous IP values
prev2_IP_val := prev_IP_val
prev_IP_val := current_IP_calc
IP_val := current_IP_calc

// Quadrature component (Q1)
float Q1 = (mDomCyc / (2 * pi)) * (IP_val - nz(IP_val[1]))

// Pythagorean theorem to establish cycle amplitude (Ampl2)
float Ampl2 = math.sqrt(IP_val * IP_val + Q1 * Q1)

// Trend amplitude (Ratio)
var float Ratio_val = 0.0
int iDomCyc = math.round(mDomCyc)
float trend_val = current_price - nz(current_price[iDomCyc + 1]) // price[y-iDomCyc-1]

if trend_val != 0 and Ampl2 != 0
    Ratio_val := 0.33 * trend_val / Ampl2 + 0.67 * nz(Ratio_val[1])
if Ratio_val > 10
    Ratio_val := 10.0
if Ratio_val < -10
    Ratio_val := -10.0

var float mTV = 0.0 // MQL4: mTV[y]
mTV := 0.05 * (Ratio_val + 10)

// Clamp mTV
if mTV < 0.0
    mTV := 0.0
if mTV > 1.0
    mTV := 1.0

// Calculate Width for Raster
float Width = 0.01 // Default as per MQL4
if mTV >= 0.3 and mTV < 0.5
    Width := mTV - 0.3
else if mTV > 0.5 and mTV <= 0.7
    Width := -mTV + 0.7

// Calculate Raster values
for n = 1 to 50
    raster_n = 20.0 // Default value
    
    if n < math.round(50 * mTV)
        // MQL4: Raster[n] = 0.8*(MathPow(( 20*mTV - 0.4*n)/Width,0.85) + 0.2*OldRaster[n]);
        // Avoid division by zero if Width is 0
        pow_base = Width != 0 ? (20 * mTV - 0.4 * n) / Width : 0.0 // Handle Width=0
        if pow_base < 0
            pow_base := 0.0 // MathPow with negative base and non-integer exponent is complex. Clamp to 0 if negative.
        raster_n := 0.8 * (math.pow(pow_base, 0.85) + 0.2 * array.get(OldRaster, n))
    else if n > math.round(50 * mTV)
        // MQL4: Raster[n] = 0.8*(MathPow((-20*mTV + 0.4*n)/Width,0.85) + 0.2*OldRaster[n]);
        // Avoid division by zero if Width is 0
        pow_base = Width != 0 ? (-20 * mTV + 0.4 * n) / Width : 0.0 // Handle Width=0
        if pow_base < 0
            pow_base := 0.0 // Clamp to 0 if negative.
        raster_n := 0.8 * (math.pow(pow_base, 0.85) + 0.2 * array.get(OldRaster, n))
    else if n == math.round(50 * mTV)
        raster_n := 0.5 * array.get(OldRaster, n)

    if raster_n < 0
        raster_n := 0.0
    if raster_n > 20 or mTV < 0.3 or mTV > 0.7
        raster_n := 20.0
    
    array.set(Raster, n, raster_n)
    array.set(OldRaster, n, raster_n) // Update OldRaster for next bar


// --- Plotting Logic ---

// Main Trend Vigor line (TV)
TV_value = 20 * mTV - 10

// Determine the value to plot for TV_line, `na` if not visible
float plot_TV_line = if VisualMode == 0 or VisualMode == 1
    TV_value
else
    na

plot(plot_TV_line, title="Trend Vigor", color=LineColor, linewidth=2, style=plot.style_line, display=display.pane)

// Corona Visualization (Simplified Plotting)
// As previously discussed, exact replication of MQL4's OBJ_RECTANGLE for 50 items per bar
// in a separate pane is not directly supported by Pine Script.
// This version plots a single 'Corona Intensity' line with dynamic coloring.

// Calculate Corona Intensity values only if needed for plotting
float avg_raster = 0.0
if VisualMode == 0 or VisualMode == 2
    for n = 1 to 50
        avg_raster := avg_raster + array.get(Raster, n)
    avg_raster := avg_raster / 50.0

// Get individual RGB components of LineColor using color.r(), color.g(), color.b() functions
float line_r = color.r(LineColor)
float line_g = color.g(LineColor)
float line_b = color.b(LineColor)

int color1_comp = 0
int color2_comp = 0
int color3_comp = 0

// Replicate MQL4 color calculation logic
if avg_raster <= 10
    color1_comp := math.round(line_r + avg_raster * (FuzzR - line_r) / 10.0)
    color2_comp := math.round(line_g + avg_raster * (FuzzG - line_g) / 10.0)
    color3_comp := math.round(line_b + avg_raster * (FuzzB - line_b) / 10.0)
else // avg_raster > 10
    color1_comp := math.round(FuzzR * (2 - avg_raster / 10.0))
    color2_comp := math.round(FuzzG * (2 - avg_raster / 10.0))
    color3_comp := math.round(FuzzB * (2 - avg_raster / 10.0))

color corona_color = color.rgb(math.max(0, math.min(255, color1_comp)),
                         math.max(0, math.min(255, color2_comp)),
                         math.max(0, math.min(255, color3_comp)))

// Determine the value to plot for Corona Intensity, `na` if not visible
float plot_corona_intensity = if VisualMode == 0 or VisualMode == 2
    0 // Plotting at 0 for columns, as per original intent
else
    na

// Define the color for the Corona Intensity plot. This needs to be a series color.
// Use `na` if the plot is not visible.
color final_corona_color = if VisualMode == 0 or VisualMode == 2
    corona_color
else
    na

plot(plot_corona_intensity, title="Corona Intensity", color=final_corona_color, style=plot.style_columns, linewidth=1, display=display.pane)

// Plot indicator levels
hline(2, "Level +2", color=color.gray, linestyle=hline.style_dashed)
hline(-2, "Level -2", color=color.gray, linestyle=hline.style_dashed)

[qchartist]

Code:

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

//@version=5
indicator(title="TMA+CG", shorttitle="TMA+CG", overlay=true)

// --- Price Mode Constants ---
int PRICE_MODE_CLOSE = 0
int PRICE_MODE_OPEN = 1
int PRICE_MODE_HIGH = 2
int PRICE_MODE_LOW = 3
int PRICE_MODE_HL2 = 4  // (High + Low) / 2
int PRICE_MODE_HLC3 = 5 // (High + Low + Close) / 3
int PRICE_MODE_OHLC4 = 6 // (Open + High + Low + Close) / 4
int PRICE_MODE_WEIGHTED = 7 // (High + Low + Close * 2) / 4 - This matches MQL4's PRICE_WEIGHTED

// --- Inputs ---
string i_timeframe = input.timeframe("0", "Time Frame (0 for chart TF)")
int    i_halfLength = input.int(56, "Half Length", minval=1)
int    i_price = input.int(PRICE_MODE_WEIGHTED, "Price", options=[
     PRICE_MODE_CLOSE,
     PRICE_MODE_OPEN,
     PRICE_MODE_HIGH,
     PRICE_MODE_LOW,
     PRICE_MODE_HL2,
     PRICE_MODE_HLC3,
     PRICE_MODE_OHLC4,
     PRICE_MODE_WEIGHTED
     ])
float  i_bandsDeviations = input.float(2.5, "Bands Deviations", minval=0.0)
bool   i_interpolate = input.bool(true, "Interpolate")
bool   i_alertsOn = input.bool(false, "Enable Alerts")
bool   i_alertsOnCurrent = input.bool(false, "Alerts on Current Bar")
bool   i_alertsOnHighLow = input.bool(true, "Alerts on High/Low Penetration")
bool   i_alertsMessage = input.bool(true, "Show Alert Message")
bool   i_alertsSound = input.bool(false, "Play Alert Sound")
bool   i_alertsEmail = input.bool(false, "Send Alert Email")

// --- Global Variables (for alert suppression within the main loop) ---
var string g_previousAlert_msg = ""
var int g_previousAlert_time = 0    

// --- Helper Function: Get Price Series ---
f_get_price_series(mode, o, h, l, c) =>
    float price_val = switch mode
        PRICE_MODE_CLOSE    => c
        PRICE_MODE_OPEN     => o
        PRICE_MODE_HIGH     => h
        PRICE_MODE_LOW      => l
        PRICE_MODE_HL2      => (h + l) / 2
        PRICE_MODE_HLC3     => (h + l + c) / 3
        PRICE_MODE_OHLC4    => (o + h + l + c) / 4
        PRICE_MODE_WEIGHTED => (h + l + c * 2) / 4
        => c
    price_val

// --- Helper Function: Calculate TMA and Bands ---
// IMPORTANT: This calculation results in a centered TMA, which will cause repainting in Pine Script.
f_calculate_tma(price_series, halfLength, bandsDeviations) =>
    int hl = math.max(1, halfLength)
    int fullLength = 2 * hl + 1 // Total bars for calculation

    float tma_val = na
    float up_band = na
    float dn_band = na

    // We need enough bars in history to calculate the TMA
    // If not enough history, TMA will be 'na'
    if bar_index >= fullLength - 1 // Ensure we have at least 'fullLength' bars
        float current_tma_sum = 0.0
        float current_tma_sumw = 0.0

        // The TMA is now calculated considering data from 'fullLength - 1' bars back
        // to the current bar [0], effectively making it a lagging average.
        // The original formula looked into the "future" with price_series[-j].
        // To make it non-repainting, we must only use past data.
        // A common way to get a "Triangular" average in Pine is to smooth an SMA twice.
        // For a true "lagging" TMA as an approximation of the centered one without lookahead bias,
        // we can take a `2 * hl + 1` simple moving average and then average that result.

        // Approach 1: Double smoothed SMA (common approximation for non-repainting TMA)
        // Adjust the lengths slightly to match the original TMA concept as much as possible
        float sma1 = ta.sma(price_series, hl + 1) // First SMA
        tma_val := ta.sma(sma1, hl + 1) // Second SMA of the first SMA

        // For bands, we can use standard deviation of the current price around this lagging TMA
        float diff_sum_sq_up = 0.0
        float diff_sum_sq_dn = 0.0
        
        for i = 0 to fullLength - 1 // Iterate over the data points for standard deviation
            float price_diff = price_series[i] - tma_val
            if price_diff >= 0
                diff_sum_sq_up += math.pow(price_diff, 2)
            else
                diff_sum_sq_dn += math.pow(price_diff, 2)
        
        up_band := tma_val + bandsDeviations * math.sqrt(diff_sum_sq_up / fullLength)
        dn_band := tma_val - bandsDeviations * math.sqrt(diff_sum_sq_dn / fullLength)


    [tma_val, up_band, dn_band]

//---
//## Main Calculation and Plotting Logic
//---

string actual_tf = i_timeframe == "0" ? timeframe.period : i_timeframe

[o_tf, h_tf, l_tf, c_tf] = request.security(syminfo.tickerid, actual_tf, [open, high, low, close], lookahead=barmerge.lookahead_on)

float current_price_tf = f_get_price_series(i_price, o_tf, h_tf, l_tf, c_tf)

var float tmBuffer_val = na
var float upBuffer_val = na
var float dnBuffer_val = na

// Corrected: Use := for assignment to existing 'var' variables
if bar_index >= 0
    // Declare temporary variables on separate lines
    float _tma = na // Initialize with na, or 0.0 if you prefer
    float _up = na
    float _dn = na
    
    // Declare temporary variables on separate lines, as Pine Script requires
    
    
    // Assign the results from the function call to these temporary variables using tuple assignment with '='
    [temp_tma, temp_up, temp_dn] = f_calculate_tma(current_price_tf, i_halfLength, i_bandsDeviations)
    
    // Then assign them individually to the 'var' variables using the ':=' operator.
    tmBuffer_val := temp_tma
    upBuffer_val := temp_up
    dnBuffer_val := temp_dn

// Corrected plotting colors
plot(tmBuffer_val, title="TMA", color=color.new(color.gray, 0), linewidth=2, style=plot.style_line) // Using color.gray for DimGray
plot(upBuffer_val, title="Upper Band", color=color.new(color.red, 0), linewidth=1, style=plot.style_line)
plot(dnBuffer_val, title= "Lower Band", color=color.new(color.green, 0), linewidth=1, style=plot.style_line) // Using color.lime for LimeGreen

//---
//## Arrow Logic
//---

float prev_high_tf = h_tf[1]
float prev_low_tf = l_tf[1]
float prev_close_tf = c_tf[1]
float prev_open_tf = o_tf[1]
float prev_upBuffer = upBuffer_val[1]
float prev_dnBuffer = dnBuffer_val[1]

float atr_val = ta.atr(20)

bool up_arrow_fire = prev_high_tf > prev_upBuffer and prev_close_tf > prev_open_tf and c_tf[0] < o_tf[0]
//plotshape(up_arrow_fire ? h_tf[0] + atr_val : na,
     //title="Up Arrow", location=location.abovebar, color=color.new(color.blue, 0), style=shape.arrowup, size=size.small)

bool dn_arrow_fire = prev_low_tf < prev_dnBuffer and prev_close_tf < prev_open_tf and c_tf[0] > o_tf[0]
//plotshape(dn_arrow_fire ? l_tf[0] - atr_val : na,
     //title="Down Arrow", location=location.belowbar, color=color.new(color.red, 0), style=shape.arrowdown, size=size.small)

//---
//## Alert Logic
//---

// --- Main Calculation ---
// Get actual timeframe string for request.security
// This is the correct and only block for main calculations and plotting.
//actual_tf = i_timeframe == "0" ? timeframe.period : i_timeframe

// Request OHLC data from the specified timeframe unconditionally.
// This is valid because `request.security` is called once per bar in this function.
// `lookahead=barmerge.lookahead_on` is crucial for centered TMA calculations, but implies repainting.
//[o_tf, h_tf, l_tf, c_tf] = request.security(syminfo.tickerid, actual_tf, [open, high, low, close], lookahead=barmerge.lookahead_on)

// Get the price series for the selected Price Mode
//float current_price_tf = f_get_price_series(i_price, o_tf, h_tf, l_tf, c_tf)

// Declare the var variables to hold TMA and band values
//var float tmBuffer_val = na
//var float upBuffer_val = na
//var float dnBuffer_val = na

// Calculate TMA and Bands and assign to the var variables
// Note: Due to the centered nature of the MQL4 TMA, this will repaint.
//[tmBuffer_val, upBuffer_val, dnBuffer_val] = f_calculate_tma(current_price_tf, i_halfLength, i_bandsDeviations)

// --- Plotting ---
//plot(tmBuffer_val, title="TMA", color=color.new(color.gray, 0), linewidth=2, style=plot.style_line)
//plot(upBuffer_val, title="Upper Band", color=color.new(color.red, 0), linewidth=1, style=plot.style_line)
//plot(dnBuffer_val, title="Lower Band", color=color.new(color.green, 0), linewidth=1, style=plot.style_line)

// --- Arrows ---
// MQL4 arrows conditions use `i+1` (previous bar on current chart) and `i` (current bar on current chart).
// We need to use `[1]` for previous bar values and `[0]` (or no index) for current bar values.
// Ensure we have enough historical data for these lookbacks.

// Values from the previous bar on the requested timeframe (tf)
// These come from the `request.security` calls, so they are already aligned to `actual_tf`.
//float prev_high_tf = h_tf[1]
//float prev_low_tf = l_tf[1]
//float prev_close_tf = c_tf[1]
//float prev_open_tf = o_tf[1]
//float prev_upBuffer = upBuffer_val[1] // Get previous value of the var series
//float prev_dnBuffer = dnBuffer_val[1] // Get previous value of the var series

// ATR calculation for arrow offset. MQL4 used iATR(NULL,0,20,i) which usually means the current chart's ATR.
// If the selected timeframe `actual_tf` is different from the chart's timeframe,
// using `ta.atr` directly would compute ATR on the chart's timeframe.
// To compute ATR on `actual_tf`, we must request its OHLC series *again* for `ta.atr`.
//float atr_val = ta.atr(20) // Use chart's ATR for simplicity and typical usage.
// If actual_tf's ATR is needed:
// [o_atr_tf, h_atr_tf, l_atr_tf, c_atr_tf] = request.security(syminfo.tickerid, actual_tf, [open, high, low, close], lookahead=barmerge.lookahead_on)
// float atr_val = ta.atr(20, high=h_atr_tf, low=l_atr_tf, close=c_atr_tf)


// Corrected Arrow Plotting Logic
//bool up_arrow_fire = prev_high_tf > prev_upBuffer and prev_close_tf > prev_open_tf and c_tf[0] < o_tf[0]
//plotshape(up_arrow_fire ? h_tf[0] + atr_val : na,
  //   title="Up Arrow", location=location.abovebar, color=color.new(color.blue, 0), style=shape.arrowup, size=size.small)

//bool dn_arrow_fire = prev_low_tf < prev_dnBuffer and prev_close_tf < prev_open_tf and c_tf[0] > o_tf[0]
//plotshape(dn_arrow_fire ? l_tf[0] - atr_val : na,
  //   title="Down Arrow", location=location.belowbar, color=color.new(color.red, 0), style=shape.arrowdown, size=size.small)

[qchartist]

Code:

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

//@version=6
indicator("Sharpe Ratio Indicator (180)", shorttitle="Sharpe Ratio (180)", overlay=false)

// Input parameters
riskFreeRate = input.float(defval=0.04, title="Risk-Free Rate (annualized, in decimal)", minval=0.0)
lookback180 = input.int(defval=180, title="Lookback Period (180 Days)", minval=1)
OverValued = input.float(5.0)
UnderValued = input.float(-1.0)
CriticallyUnderValued = input.float(-3.0)

// Daily Return
dailyReturn = (close - close[1]) / close[1]

// Mean and Standard Deviation for Sharpe Ratio (180 days)
mean180 = ta.sma(dailyReturn, lookback180)
stdDev180 = ta.stdev(dailyReturn, lookback180) * math.sqrt(lookback180)
sharpe180 = (mean180 * 365 - riskFreeRate) / stdDev180

// Define valuation zones
isOverValued = sharpe180 > OverValued
isUnderValued = sharpe180 < UnderValued and sharpe180 > CriticallyUnderValued
isCriticallyUnderValued = sharpe180 < CriticallyUnderValued
isNeutral = not isOverValued and not isUnderValued and not isCriticallyUnderValued

// Assign plot colors based on valuation state
sharpeColor = isOverValued ? color.red : isUnderValued ? color.green : isCriticallyUnderValued ? color.blue : color.yellow

// Plot the Sharpe Ratio (180 days)
plot(sharpe180, color=sharpeColor, title="Sharpe Ratio (180)", linewidth=2)

// Highlighting Sharpe Zones
hline(OverValued, "Overvalued Zone", color=color.red, linestyle=hline.style_dashed)
hline(UnderValued, "Undervalued Zone", color=color.green, linestyle=hline.style_dashed)
hline(CriticallyUnderValued, "Critically Undervalued Zone", color.blue, hline.style_dashed)
hline(0, "Neutral Zone", color=color.gray, linestyle=hline.style_dotted)

[qchartist]

Code:

//@version=5
indicator("FFT Top Components (Individual Curves)", overlay=false)

int n = input.int(128, title="Sample Size", minval=32, maxval=512)
int topComponents = input.int(6, title="Top Components", minval=1, maxval=20)

var float[] priceBuffer = array.new_float(n, 0.0)
var int bufferIndex = 0

if bar_index >= n
    array.set(priceBuffer, bufferIndex, close)
    bufferIndex := (bufferIndex + 1) % n

var float[] amplitudes = array.new_float(n, 0.0)
var float[] phases = array.new_float(n, 0.0)

if bar_index >= n
    for k = 0 to n - 1
        float re = 0.0
        float im = 0.0
        for t = 0 to n - 1
            float val = array.get(priceBuffer, (bufferIndex + t) % n)
            float angle = 2.0 * math.pi * k * t / n
            re += val * math.cos(angle)
            im -= val * math.sin(angle)
        float amp = math.sqrt(re * re + im * im) / n
        float phase = re != 0 ? math.atan(im / re) : 0
        array.set(amplitudes, k, amp)
        array.set(phases, k, phase)

var float[] sortableAmps = array.new_float(0)
var int[] sortableIndices = array.new_int(0)

if bar_index >= n
    array.clear(sortableAmps)
    array.clear(sortableIndices)
    for i = 0 to n - 1
        array.push(sortableAmps, array.get(amplitudes, i))
        array.push(sortableIndices, i)

    int arraySize = array.size(sortableAmps)
    for i = 0 to arraySize - 2
        for j = i + 1 to arraySize - 1
            if array.get(sortableAmps, j) > array.get(sortableAmps, i)
                float tempAmp = array.get(sortableAmps, i)
                int tempIdx = array.get(sortableIndices, i)
                array.set(sortableAmps, i, array.get(sortableAmps, j))
                array.set(sortableIndices, i, array.get(sortableIndices, j))
                array.set(sortableAmps, j, tempAmp)
                array.set(sortableIndices, j, tempIdx)

// Predefine component series
var float comp0 = na
var float comp1 = na
var float comp2 = na
var float comp3 = na
var float comp4 = na
var float comp5 = na

if bar_index >= n
    int maxComp = math.min(topComponents - 1, array.size(sortableIndices) - 1)
   
    // Get the current time index within the buffer
    float currentTimeIndex = float(bufferIndex)
   
    for i = 0 to maxComp
        int idx = array.get(sortableIndices, i)
        float amp = array.get(amplitudes, idx)
        float phase = array.get(phases, idx)
       
        // Reconstruct component using cosine with corrected phase
        float angle = 2.0 * math.pi * idx * (currentTimeIndex - 1) / n
        float component = amp * math.cos(angle + phase)
       
        if i == 0
            comp0 := component
        if i == 1
            comp1 := component
        if i == 2
            comp2 := component
        if i == 3
            comp3 := component
        if i == 4
            comp4 := component
        if i == 5
            comp5 := component

// Plots (global scope)
//plot(comp0, title="Component 0", color=color.blue)
plot(comp1, title="Component 1", color=color.green)
plot(comp2, title="Component 2", color=color.red)
plot(comp3, title="Component 3", color=color.orange)
plot(comp4, title="Component 4", color=color.purple)
plot(comp5, title="Component 5", color=color.aqua)

Code:

//@version=5
indicator(title="Spectrometr", shorttitle="Spectrometr", overlay=false, format=format.price, precision=2)

// ——— Input Parameters
iPeriod     = input.int(240, title="Period")
iStartFrom  = input.int(1, title="Start From")
AddToObjName = input.string("1", title="Object Name Suffix")
HandlerColor = input.color(color.new(color.gray, 50), title="Handler Line Color")
TextColor    = input.color(color.new(color.gray, 50), title="Text Color")

// ——— Custom Variables
ObjNPref      = "Spectrometr_" + AddToObjName
LastLeftBar   = iStartFrom + iPeriod - 1
LastRightBar  = iStartFrom

// ——— Fourier Analysis Function
fFurie(arr) =>
    tN = array.size(arr)
    tM = int(tN / 2)
    aA = array.new<float>(tM, 0.0)
    aB = array.new<float>(tM, 0.0)
    aR = array.new<float>(tM, 0.0)

    for ti = 1 to tM - 1
        sumA = 0.0
        sumB = 0.0
        for tj = 0 to tN - 1
            val = array.get(arr, tj)
            sumA += val * math.sin(ti * 6.28 * tj / tN)
            sumB += val * math.cos(ti * 6.28 * tj / tN)
        array.set(aA, ti, 2 * sumA / tN)
        array.set(aB, ti, 2 * sumB / tN)
        array.set(aR, ti, math.sqrt(math.pow(array.get(aA, ti), 2) + math.pow(array.get(aB, ti), 2)))
    [aA, aB, aR]

// ——— Residuals and Fourier Component Calculation
residuals = array.new<float>()
fVals = array.new<float>(8, na)

if bar_index >= iPeriod
    // Collect price data
    prices = array.new<float>()
    for i = 0 to iPeriod - 1
        array.push(prices, close[i])

    // Estimate linear regression slope and intercept
    linreg_slope = ta.sma(ta.change(close), iPeriod)
    linreg_val   = ta.linreg(close, iPeriod, 0)

    // Compute residuals
    for i = 0 to iPeriod - 1
        lin_val = linreg_val + (iPeriod - 1 - i) * linreg_slope
        residual = close[i] - lin_val
        array.push(residuals, residual)

    // Apply Fourier transform
    [A, B, R] = fFurie(residuals)

    // Precompute 8 Fourier components
    for k = 1 to 8
        val = array.get(A, k) * math.sin(k * 6.28 * iPeriod / (iPeriod - 1)) +
              array.get(B, k) * math.cos(k * 6.28 * iPeriod / (iPeriod - 1))
        array.set(fVals, k - 1, val)

// ——— Plotting Fourier Components (Global Scope)
plot(array.get(fVals, 0), title="F_1", color=color.red, linewidth=2)
plot(array.get(fVals, 1), title="F_2", color=color.orange, linewidth=2)
plot(array.get(fVals, 2), title="F_3", color=color.yellow, linewidth=2)
plot(array.get(fVals, 3), title="F_4", color=color.lime, linewidth=2)
plot(array.get(fVals, 4), title="F_5", color=color.blue, linewidth=2)
plot(array.get(fVals, 5), title="F_6", color=color.new(color.blue, 50), linewidth=2)
plot(array.get(fVals, 6), title="F_7", color=color.new(color.purple, 50), linewidth=2)
plot(array.get(fVals, 7), title="F_8", color=color.gray, linewidth=2)

// ——— Drawing Line and Labels
if bar_index >= iPeriod
    line.new(x1=bar_index - LastLeftBar, y1=0, x2=bar_index - LastRightBar, y2=0,
             color=HandlerColor, style=line.style_dashed, width=3)

   // label.new(x=bar_index, y=0, text="Period: " + str.tostring(iPeriod),
     //         xloc=xloc.bar_index, yloc=yloc.price, style=label.style_label_left,
       //       color=color.white, textcolor=TextColor)

    //label.new(x=bar_index, y=0, text="StartFrom: " + str.tostring(iStartFrom),
      //        xloc=xloc.bar_index, yloc=yloc.price, style=label.style_label_right,
        //      color=color.white, textcolor=TextColor)