$ Pinescript Herrick Payoff Index (HPI)

//@version=5
indicator("My Herrick Payoff Index (HPI)", overlay=false) // overlay=false to plot in a separate pane

// Input for HPI smoothing length
length = input.int(10, title="HPI Smoothing Length", minval=1)

// Input for the Scaling Factor (adjusts the magnitude of HPI values for readability)
// This value depends on the typical price and volume of the asset.
// For stocks, it might be 1000 or 10000. For futures, it can be higher.
// The ta.hpi function in Pinescript may have its own internal scaling,
// but for explicit control or manual calculation, this would be important.
// For the built-in, we just need to provide the required series.
// Pinescript's ta.hpi() does not expose a scaling factor input, so it's handled internally.

// Fetch Open Interest data. Note: Open Interest is typically available for futures and some options.
// For regular stocks/forex, this might be `na` or correspond to `volume`.
// If openInterest is `na`, ta.hpi will typically use `volume` as a fallback or return `na`.
// Check your chart's data window for 'Open Interest' to confirm availability.
var float oi = openinterest // Use 'openinterest' built-in variable

// Calculate HPI using the built-in function
// The 'openinterest' built-in variable can be used directly.
// ta.hpi(open, high, low, close, volume, openinterest, length)
hpiValue = ta.hpi(open, high, low, close, volume, oi, length)

// Plot the HPI line
plot(hpiValue, title="HPI", color=color.blue, linewidth=2)

// Plot the Zero Line as a key reference point
hline(0, "Zero Line", color.gray, linestyle=hline.style_dotted)

// Optional: Add reference levels for visual clarity (subjective based on asset)
// These levels can indicate strong buying/selling pressure.
hline(500, "Upper Ref (+500)", color.green, linestyle=hline.style_dashed)
hline(-500, "Lower Ref (-500)", color.red, linestyle=hline.style_dashed)

// Highlight regions where HPI is positive (accumulation) or negative (distribution)
fill(hpiValue, 0, color=color.new(color.lime, 90), title="Accumulation Zone")
fill(hpiValue, 0, color=color.new(color.maroon, 90), title="Distribution Zone")

//@version=5
strategy("HPI Zero Line Crossover Strategy", overlay=true)

length = input.int(10, title="HPI Smoothing Length", minval=1)
var float oi = openinterest
hpiValue = ta.hpi(open, high, low, close, volume, oi, length)

plot(hpiValue, "HPI", color.blue, display=display.pane_only)
hline(0, "Zero Line", color.gray, linestyle=hline.style_dotted, display=display.pane_only)

// Long entry: HPI crosses above zero
longCondition = ta.crossover(hpiValue, 0)

// Short entry: HPI crosses below zero
shortCondition = ta.crossunder(hpiValue, 0)

if (longCondition)
    strategy.entry("Long HPI Cross", strategy.long)

if (shortCondition)
    strategy.entry("Short HPI Cross", strategy.short)

// Basic exit: opposite signal or fixed profit/loss
strategy.close("Long HPI Cross", when=shortCondition)
strategy.close("Short HPI Cross", when=longCondition)

//@version=5
strategy("HPI Divergence Strategy", overlay=true)

length = input.int(10, title="HPI Smoothing Length", minval=1)
var float oi = openinterest
hpiValue = ta.hpi(open, high, low, close, volume, oi, length)

plot(hpiValue, "HPI", color.blue, display=display.pane_only)
hline(0, "Zero Line", color.gray, linestyle=hline.style_dotted, display=display.pane_only)

// Simple divergence detection (conceptual, robust detection requires advanced pivot logic)
// This example looks for recent higher/lower swings in price and HPI.

// Bullish Divergence: Price lower low, HPI higher low
bullishDiv = close < close[1] and close[1] < close[2] and hpiValue > hpiValue[1] and hpiValue[1] > hpiValue[2]

// Bearish Divergence: Price higher high, HPI lower high
bearishDiv = close > close[1] and close[1] > close[2] and hpiValue < hpiValue[1] and hpiValue[1] < hpiValue[2]

// Plot shapes on the chart to indicate divergence
plotshape(bullishDiv, title="Bullish HPI Divergence", location=location.belowbar, color=color.new(color.green, 0), style=shape.triangleup, size=size.small)
plotshape(bearishDiv, title="Bearish HPI Divergence", location=location.abovebar, color=color.new(color.red, 0), style=shape.triangledown, size=size.small)

if (bullishDiv)
    strategy.entry("Long Divergence", strategy.long)
if (bearishDiv)
    strategy.entry("Short Divergence", strategy.short)

// Basic exit after a few bars or on opposite signal
strategy.exit("Long Divergence Exit", from_entry="Long Divergence", profit=close*0.02, loss=close*0.01)
strategy.exit("Short Divergence Exit", from_entry="Short Divergence", profit=close*0.02, loss=close*0.01)

//@version=5
strategy("HPI Trend Confirmation Strategy", overlay=true)

length = input.int(10, title="HPI Smoothing Length", minval=1)
var float oi = openinterest
hpiValue = ta.hpi(open, high, low, close, volume, oi, length)

plot(hpiValue, "HPI", color.blue, display=display.pane_only)
hline(0, "Zero Line", color.gray, linestyle=hline.style_dotted, display=display.pane_only)

// Price trend filter (e.g., using a long-term EMA)
priceMALength = input.int(50, title="Price MA Length", minval=1)
priceMA = ta.ema(close, priceMALength)

// Conditions for trend confirmation based on HPI and Price
// Long: Price above MA AND HPI is positive and rising
longConfirm = close > priceMA and hpiValue > 0 and hpiValue > hpiValue[1]

// Short: Price below MA AND HPI is negative and falling
shortConfirm = close < priceMA and hpiValue < 0 and hpiValue < hpiValue[1]

if (longConfirm)
    strategy.entry("Long Confirm", strategy.long)

if (shortConfirm)
    strategy.entry("Short Confirm", strategy.short)

// Basic exit: opposite signal or fixed profit/loss
strategy.close("Long Confirm", when=close < priceMA or hpiValue < 0)
strategy.close("Short Confirm", when=close > priceMA or hpiValue > 0)