Advanced Gold Oscillator Indicator

Built by Grok

Working!

//@version=6

// Gold Sell Oscillator - Advanced ML Edition (v6)

indicator("Gold Sell Oscillator Advanced ML", overlay=false)

// Input Parameters

rsiPeriod = input.int(14, "RSI Period", minval=1)

rsiOverbought = input.int(70, "RSI Overbought Level", minval=50, maxval=100)

macdFast = input.int(12, "MACD Fast", minval=1)

macdSlow = input.int(26, "MACD Slow", minval=1)

macdSignal = input.int(9, "MACD Signal", minval=1)

bbPeriod = input.int(20, "Bollinger Period", minval=1)

bbDev = input.float(2.5, "Bollinger Deviation", minval=0.1, step=0.1)

volPeriod = input.int(20, "Volume MA Period", minval=1)

adxPeriod = input.int(14, "ADX Period", minval=1)

lookback = input.int(100, "ML Lookback Period", minval=10)

neighbors = input.int(7, "Number of Neighbors", minval=1, maxval=15)

smoothingPeriod = input.int(5, "Smoothing Period", minval=1)

// Technical Indicators

rsi = ta.rsi(close, rsiPeriod)

[macdLine, signalLine, _] = ta.macd(close, macdFast, macdSlow, macdSignal)

[bbUpper, bbMiddle, bbLower] = ta.bb(close, bbPeriod, bbDev)

volMA = ta.sma(volume, volPeriod)

// Manual ADX Calculation

plusDM = math.max(high - high[1], 0)

minusDM = math.max(low[1] - low, 0)

tr = ta.tr(true)

plusDI = 100 * ta.rma(plusDM, adxPeriod) / ta.rma(tr, adxPeriod)

minusDI = 100 * ta.rma(minusDM, adxPeriod) / ta.rma(tr, adxPeriod)

dx = 100 * math.abs(plusDI - minusDI) / math.max(plusDI + minusDI, 0.0001)

adxValue = ta.rma(dx, adxPeriod)

// Current Feature Set (Normalized)

currentRsi = (rsi - 50) / 50

currentPricePos = (close - bbMiddle) / (bbUpper - bbLower)

currentMacdDiff = (macdLine - signalLine) / math.abs(close * 0.01)

currentVolRatio = volume / volMA

currentAdx = (adxValue - 25) / 25

// Historical Data Arrays

var float[] pastReturns = array.new_float(lookback)

var float[] pastRsi = array.new_float(lookback)

var float[] pastPricePos = array.new_float(lookback)

var float[] pastMacdDiff = array.new_float(lookback)

var float[] pastVolRatio = array.new_float(lookback)

var float[] pastAdx = array.new_float(lookback)

// Update Historical Data

for i = 0 to lookback - 2

    if i == 0

        prevClose = close[2]

        returnValue = prevClose != 0 ? (close[1] - prevClose) / prevClose : 0.0

        array.set(pastReturns, i, returnValue)

        array.set(pastRsi, i, (rsi[1] - 50) / 50)

        bbRange = bbUpper[1] - bbLower[1]

        array.set(pastPricePos, i, bbRange != 0 ? (close[1] - bbMiddle[1]) / bbRange : 0.0)

        array.set(pastMacdDiff, i, (macdLine[1] - signalLine[1]) / math.abs(close[1] * 0.01))

        array.set(pastVolRatio, i, volMA[1] != 0 ? volume[1] / volMA[1] : 1.0)

        array.set(pastAdx, i, (adxValue[1] - 25) / 25)

    else

        array.set(pastReturns, i, array.get(pastReturns, i-1))

        array.set(pastRsi, i, array.get(pastRsi, i-1))

        array.set(pastPricePos, i, array.get(pastPricePos, i-1))

        array.set(pastMacdDiff, i, array.get(pastMacdDiff, i-1))

        array.set(pastVolRatio, i, array.get(pastVolRatio, i-1))

        array.set(pastAdx, i, array.get(pastAdx, i-1))

// Weighted Distance Calculation

var float[] distances = array.new_float(lookback)

for i = 0 to lookback - 1

    rsiW = 0.3

    priceW = 0.25

    macdW = 0.2

    volW = 0.15

    adxW = 0.1

    rsiDiff = math.pow(currentRsi - array.get(pastRsi, i), 2) * rsiW

    priceDiff = math.pow(currentPricePos - array.get(pastPricePos, i), 2) * priceW

    macdDiff = math.pow(currentMacdDiff - array.get(pastMacdDiff, i), 2) * macdW

    volDiff = math.pow(currentVolRatio - array.get(pastVolRatio, i), 2) * volW

    adxDiff = math.pow(currentAdx - array.get(pastAdx, i), 2) * adxW

    totalDistance = math.sqrt(rsiDiff + priceDiff + macdDiff + volDiff + adxDiff)

    array.set(distances, i, totalDistance)

// k-Nearest Neighbors

sortedDistances = array.copy(distances)

array.sort(sortedDistances)

kNearestReturns = array.new_float(neighbors)

kNearestOutcomes = array.new_float(neighbors)

for i = 0 to neighbors - 1

    idx = array.indexof(distances, array.get(sortedDistances, i))

    array.set(kNearestReturns, i, array.get(pastReturns, idx))

    array.set(kNearestOutcomes, i, array.get(pastReturns, idx) < 0 ? 1 : 0)

// ML Sell Probability (0 to 1)

mlSellProb = array.sum(kNearestOutcomes) / neighbors

// Base Technical Conditions (Normalized to 0-1)

rsiScore = rsi >= rsiOverbought ? 1.0 : (rsi - 30) / (rsiOverbought - 30)

bbScore = close >= bbUpper ? 1.0 : math.max(0, (close - bbMiddle) / (bbUpper - bbMiddle))

volScore = volume > volMA * 2 ? 1.0 : math.max(0, (volume - volMA) / (volMA * 2))

macdScore = macdLine < signalLine ? 1.0 : math.max(0, (signalLine - macdLine) / math.abs(close * 0.01))

// Oscillator Calculation (Weighted Sum, 0-100)

oscRaw = (rsiScore * 25) + (bbScore * 25) + (volScore * 20) + (macdScore * 20) + (mlSellProb * 10)

oscillator = ta.sma(oscRaw, smoothingPeriod) // Smooth the output

// Plotting

plot(oscillator, title="Gold Sell Oscillator", color=color.red, linewidth=2)

hline(70, "Overbought", color=color.gray, linestyle=hline.style_dashed)

hline(30, "Oversold", color=color.gray, linestyle=hline.style_dashed)

// Alerts

alertcondition(oscillator > 70, title="Gold Sell Oscillator Overbought", message="Gold Sell Oscillator indicates potential selling opportunity!")