MM Flow
FlowScripts

Perfected FlowScript

Rolling Sharpe Ratio

Rolling Sharpe Ratio V2 is indexed as 223_rolling_sharpe_ratio.flowscript. The exact FlowScript is viewable here; chart observe and trading automation use the current mmflow chart/recipe signal proxy until FlowScript v2 transpilation is available.

This exact FlowScript uses the v2 source dialect. It is viewable and connected to the chart/automation proxy, but direct editor execution needs the FlowScript v2 transpiler.

Dialect

flowscript-v2

Compatibility

flowscript-v2-needs-transpile

Position

offchart

Axis

true

Size

15.5 KB

Lines

362

Native Signal Candidates

4 source-level chart marker triggers extracted from guarded FlowScript v2 blocks.

4/4 guarded

Strong Sharpe

line 288:9

Trigger

(showShapes) && (crossUp)

Value

sharpe

Deps

crossUp:var, showShapes:input

Poor Sharpe

line 298:9

Trigger

(showShapes) && (crossDn)

Value

sharpe

Deps

crossDn:var, showShapes:input

Cross Zero Up

line 308:9

Trigger

(showShapes) && (crossZeroUp)

Value

sharpe

Deps

crossZeroUp:var, showShapes:input

Cross Zero Dn

line 318:9

Trigger

(showShapes) && (crossZeroDn)

Value

sharpe

Deps

crossZeroDn:var, showShapes:input

223_rolling_sharpe_ratio.flowscript

source path: kscripts/perfected/223_rolling_sharpe_ratio.flowscript · sha256:632f0403432bb7dd923e49f27ea1825eae15b630bbc6d19a922b82e898919486

hash verified
//@version=2
// ============================================================================
// Rolling Sharpe Ratio V2 — Production-Quality Risk-Adjusted Return Oscillator
// Author: BackQuant (@BackQuant)  |  Perfected by: kScript Perfection Engineer
// Tags: ADVANCED, #sharpe, #risk, #returns, #volatility, #regime
//
// Rolling-window Sharpe ratio with z-score normalization, dynamic regime
// detection, volatility-adjusted thresholds, color-coded fill, and shape
// markers for threshold crosses. Measures risk-adjusted return over a
// configurable lookback, with optional annualization.
//
// FORMULA FOUNDATION:
// 1. Sharpe Ratio: S = (E[R] − R_f) / σ(R)  per Sharpe (1994).
// 2. Rolling Sharpe: replaces unconditional expectation with rolling n-period
//    sample mean and sample standard deviation  per Various (2005).
// 3. Z-Score Normalization: z = (Sharpe − μ_Sharpe) / σ_Sharpe over a rolling
//    window  per Zhao & Palomar (2018) mean-reversion signal framework.
// 4. Dynamic Thresholds: thresholds adjusted by rolling Sharpe volatility
//    per Poterba & Summers (1988) mean-reversion intensity calibration.
// 5. Regime Detection: Strong risk-adjusted (S > upper), Poor (S < lower),
//    Neutral (between) — three-segment classification.
//
// RESEARCH BASIS:
//  • Sharpe, W. F. (1994), "The Sharpe Ratio", J. Portfolio Mgmt 21(1):49–58.
//    Formalized (R_p − R_f) / σ_p as the canonical risk-adjusted performance.
//  • Various (2005), "A Reality Check on Technical Trading Rule Profits in US
//    Futures Markets". Supports rolling-window estimators of mean & variance.
//  • Poterba & Summers (1988), "Mean Reversion in Stock Prices: Evidence and
//    Implications", JFE 22(1):27–59. Negative autocorrelation at medium horizons
//    supports dynamic threshold calibration to rolling volatility.
//  • Zhao & Palomar (2018), "Mean-Reverting Portfolio With Budget Constraint",
//    IEEE TSP. Z-score event triggers at ±2σ for statistical significance.
//  • Lo & MacKinlay (1988), "Stock Market Prices Do Not Follow Random Walks",
//    RFS 1(1):41–66. Variance ratio test; VR < 1 signals mean reversion.
// ============================================================================

define(
    title="Rolling Sharpe Ratio V2",
    position="offchart",
    axis=true
)

// ------------------------------------------------------------------------------
// User Inputs — grouped and constrained per production spec
// ------------------------------------------------------------------------------

// --- Sharpe Settings ---
var lookback = input(name="lookback", type="number", defaultValue=60, label="Rolling Window (bars)", constraints={min: 10, max: 500, step: 5}, group="Sharpe Settings")
var riskFree = input(name="riskFree", type="number", defaultValue=0.0, label="Risk-Free Rate (annualized %)", constraints={min: 0.0, max: 20.0, step: 0.1}, group="Sharpe Settings")
var tradingDays = input(name="tradingDays", type="number", defaultValue=365, label="Trading Days per Year", constraints={min: 1, max: 365, step: 1}, group="Sharpe Settings")
var annualize = input(name="annualize", type="boolean", defaultValue=true, label="Annualize Sharpe", group="Sharpe Settings")

// --- Smoothing ---
var smoothLen = input(name="smoothLen", type="number", defaultValue=3, label="EMA Smoothing Length", constraints={min: 1, max: 50, step: 1}, group="Smoothing")
var signalLen = input(name="signalLen", type="number", defaultValue=20, label="Signal SMA Length", constraints={min: 2, max: 100, step: 1}, group="Smoothing")

// --- Z-Score ---
var zLookback = input(name="zLookback", type="number", defaultValue=100, label="Z-Score Lookback (bars)", constraints={min: 10, max: 500, step: 5}, group="Z-Score")
var useZScore = input(name="useZScore", type="boolean", defaultValue=true, label="Enable Z-Score Normalization", group="Z-Score")

// --- Thresholds ---
var upperBand = input(name="upperBand", type="number", defaultValue=2.0, label="Upper Guide Level", constraints={min: 0.5, max: 10.0, step: 0.1}, group="Thresholds")
var lowerBand = input(name="lowerBand", type="number", defaultValue=-2.0, label="Lower Guide Level", constraints={min: -10.0, max: -0.5, step: 0.1}, group="Thresholds")
var useDynamic = input(name="useDynamic", type="boolean", defaultValue=false, label="Dynamic Thresholds (volatility-adjusted)", group="Thresholds")
var volLookback = input(name="volLookback", type="number", defaultValue=50, label="Volatility Lookback", constraints={min: 10, max: 200, step: 5}, group="Thresholds")
var volMultiplier = input(name="volMultiplier", type="number", defaultValue=1.5, label="Volatility Multiplier", constraints={min: 0.5, max: 5.0, step: 0.1}, group="Thresholds")

// --- Display ---
var showLine = input(name="showLine", type="boolean", defaultValue=true, label="Show Sharpe Line", group="Display")
var showSignal = input(name="showSignal", type="boolean", defaultValue=true, label="Show Signal SMA", group="Display")
var showRibbon = input(name="showRibbon", type="boolean", defaultValue=true, label="Show Sharpe-Signal Ribbon Fill", group="Display")
var showHistogram = input(name="showHistogram", type="boolean", defaultValue=true, label="Show Momentum Histogram", group="Display")
var showZLine = input(name="showZLine", type="boolean", defaultValue=false, label="Show Z-Score Line", group="Display")
var showShapes = input(name="showShapes", type="boolean", defaultValue=true, label="Show Threshold Shapes", group="Display")

// --- Colors ---
var bullColor = input(name="bullColor", type="color", defaultValue="#26a69a", label="Strong Sharpe Color", group="Colors")
var bearColor = input(name="bearColor", type="color", defaultValue="#ef5350", label="Poor Sharpe Color", group="Colors")
var neutralColor = input(name="neutralColor", type="color", defaultValue="#9e9e9e", label="Neutral Color", group="Colors")
var signalColor = input(name="signalColor", type="color", defaultValue="#ffffff", label="Signal Line Color", group="Colors")
var zLineColor = input(name="zLineColor", type="color", defaultValue="#ffd54f", label="Z-Score Line Color", group="Colors")
var extremeBidColor = input(name="extremeBidColor", type="color", defaultValue="#00e676", label="Extreme Positive Color", group="Colors")
var extremeAskColor = input(name="extremeAskColor", type="color", defaultValue="#ff1744", label="Extreme Negative Color", group="Colors")

// ------------------------------------------------------------------------------
// Data Sources & NaN Guard
// ------------------------------------------------------------------------------
timeseries bars = ohlcv(symbol=currentSymbol, exchange=currentExchange)
timeseries px = bars.close

if (isnan(px[0])) {
    return
}

// ------------------------------------------------------------------------------
// Rolling Sharpe Ratio Computation
// ------------------------------------------------------------------------------
// S = (E[R] − R_f) / σ(R) where E[R] is rolling mean and σ(R) is rolling std.
// Per Sharpe (1994) and rolling-window estimators per Various (2005).

// Period returns from close
timeseries ret = px[1] > 0 ? (px - px[1]) / px[1] : 0.0

// Rolling mean and standard deviation of returns
timeseries meanR = sma(source=ret, period=lookback)
timeseries stdR = stddev(source=ret, period=lookback)

// Daily risk-free (annualized -> per-bar)
timeseries rfDaily = (riskFree / 100.0) / tradingDays

// Excess return per bar
timeseries excess = meanR - rfDaily

// Optional annualization factor
var barsPerDay = tradingDays
var barsPerYear = barsPerDay * 24
timeseries annFactor = annualize ? math.sqrt(barsPerYear) : 1.0

// Rolling Sharpe (raw). Guard against zero std.
var safeStd = stdR > 0 ? stdR : 1e-9
timeseries sharpeRaw = (excess * annFactor) / safeStd

// ------------------------------------------------------------------------------
// Smoothing & Signal
// ------------------------------------------------------------------------------
timeseries sharpe = ema(source=sharpeRaw, period=smoothLen)
timeseries signal = sma(source=sharpe, period=signalLen)

// Momentum histogram (Sharpe minus signal)
timeseries hist = sharpe - signal

// ------------------------------------------------------------------------------
// Z-Score Normalization (Zhao & Palomar 2018)
// ------------------------------------------------------------------------------
// z = (Sharpe − μ_Sharpe) / σ_Sharpe over rolling window.

var meanSharpe = sma(source=sharpe, period=zLookback)
var stdSharpe = stddev(source=sharpe, period=zLookback)
var safeStdSharpe = stdSharpe > 0 ? stdSharpe : 1.0
var zScore = useZScore ? (sharpe - meanSharpe) / safeStdSharpe : sharpe

// ------------------------------------------------------------------------------
// Dynamic Thresholds (Poterba & Summers 1988)
// ------------------------------------------------------------------------------
// Per Poterba & Summers (1988), mean-reversion intensity varies with volatility.
// We adjust upper/lower bands by rolling Sharpe standard deviation.

var sharpeVol = stddev(source=sharpe, period=volLookback)
var dynUpper = useDynamic ? math.min(10.0, upperBand + sharpeVol * volMultiplier) : upperBand
var dynLower = useDynamic ? math.max(-10.0, lowerBand - sharpeVol * volMultiplier) : lowerBand

// Guard: ensure dynamic bands never cross
if (dynUpper <= dynLower) {
    dynUpper = 2.0
    dynLower = -2.0
}

// ------------------------------------------------------------------------------
// Regime Detection
// ------------------------------------------------------------------------------
// Regime classification:
//   Strong risk-adjusted: sharpe > dynUpper
//   Poor risk-adjusted:   sharpe < dynLower
//   Neutral: everything else

var regimeStrong = sharpe > dynUpper
var regimePoor = sharpe < dynLower
var regimeNeutral = !regimeStrong && !regimePoor

var regimeColor = regimeStrong ? bullColor : (regimePoor ? bearColor : neutralColor)

// ------------------------------------------------------------------------------
// Static State Tracking (Session-level persistence)
// ------------------------------------------------------------------------------
static lastRegime = 0
static regimeChangeCount = 0
static sessionHighSharpe = -999999.0
static sessionLowSharpe = 999999.0
static crossUpCount = 0
static crossDnCount = 0
static lastBarIndex = 0

var currentBarIndex = bar_index[0]

if (!isnan(currentBarIndex) && currentBarIndex != lastBarIndex) {
    lastBarIndex = currentBarIndex

    if (sharpe > sessionHighSharpe) {
        sessionHighSharpe = sharpe
    }
    if (sharpe < sessionLowSharpe) {
        sessionLowSharpe = sharpe
    }

    var currentRegime = regimeStrong ? 1 : (regimePoor ? -1 : 0)
    if (lastRegime != currentRegime) {
        lastRegime = currentRegime
        regimeChangeCount = regimeChangeCount + 1
    }

    if (sharpe > dynUpper && !isnan(sharpe[1]) && sharpe[1] <= dynUpper) {
        crossUpCount = crossUpCount + 1
    }
    if (sharpe < dynLower && !isnan(sharpe[1]) && sharpe[1] >= dynLower) {
        crossDnCount = crossDnCount + 1
    }
}

// ------------------------------------------------------------------------------
// Plots — Multiple Visualization Types (Line, Bar, Fill, Shape, HLine)
// ------------------------------------------------------------------------------

// --- Zero line ---
hline(value=0, color="#ffffff20", width=1)

// --- Upper / Lower guide bands ---
hline(value=dynUpper, color=transparency(bullColor, 60), width=1)
hline(value=dynLower, color=transparency(bearColor, 60), width=1)

// --- Sharpe Line (regime-colored) ---
if (showLine) {
    plotLine(
        value=sharpe,
        width=2,
        colors=[regimeColor],
        label=["Rolling Sharpe"],
        desc=["Rolling-window Sharpe ratio (EMA-smoothed). Regime-colored."]
    )
}

// --- Signal SMA ---
if (showSignal) {
    plotLine(
        value=signal,
        width=1,
        colors=[signalColor],
        label=["Signal SMA"],
        desc=["SMA of smoothed Sharpe ratio (" + signalLen + ")"]
    )
}

// --- Sharpe-Signal Ribbon Fill ---
if (showRibbon) {
    var ribbonBull = sharpe > signal
    plotLine(
        value=[sharpe, signal],
        width=1,
        colors=[transparency(bullColor, 30), transparency(bearColor, 30)],
        colorIndex=ribbonBull ? 0 : 1,
        fill=true,
        label=["Sharpe", "Signal"],
        desc=["Fill between Sharpe and Signal SMA"]
    )
}

// --- Momentum Histogram ---
if (showHistogram) {
    var histBull = hist >= 0
    plotBar(
        value=hist,
        colors=[transparency(bullColor, 60), transparency(bearColor, 60)],
        colorIndex=histBull ? 0 : 1,
        width=1,
        label=["Sharpe Momentum"],
        desc=["Histogram of Sharpe minus Signal SMA"]
    )
}

// --- Z-Score Line ---
if (showZLine && useZScore) {
    plotLine(
        value=zScore,
        width=1,
        colors=[zLineColor],
        label=["Z-Score"],
        desc=["Z-score of smoothed Sharpe ratio (" + zLookback + "-bar lookback)"]
    )
}

// --- Threshold Cross Shapes ---
if (showShapes) {
    var crossUp = sharpe > dynUpper && !isnan(sharpe[1]) && sharpe[1] <= dynUpper
    var crossDn = sharpe < dynLower && !isnan(sharpe[1]) && sharpe[1] >= dynLower
    var crossZeroUp = sharpe > 0 && !isnan(sharpe[1]) && sharpe[1] <= 0
    var crossZeroDn = sharpe < 0 && !isnan(sharpe[1]) && sharpe[1] >= 0

    if (crossUp) {
        plotShape(
            value=sharpe,
            shape="triangleup",
            color=extremeBidColor,
            width=3,
            label=["Strong Sharpe"],
            desc=["Sharpe crossed above upper threshold — strong risk-adjusted return"]
        )
    }
    if (crossDn) {
        plotShape(
            value=sharpe,
            shape="triangledown",
            color=extremeAskColor,
            width=3,
            label=["Poor Sharpe"],
            desc=["Sharpe crossed below lower threshold — poor risk-adjusted return"]
        )
    }
    if (crossZeroUp) {
        plotShape(
            value=sharpe,
            shape="circle",
            color=bullColor,
            width=2,
            label=["Cross Zero Up"],
            desc=["Sharpe crossed above zero — positive excess return"]
        )
    }
    if (crossZeroDn) {
        plotShape(
            value=sharpe,
            shape="circle",
            color=bearColor,
            width=2,
            label=["Cross Zero Dn"],
            desc=["Sharpe crossed below zero — negative excess return"]
        )
    }
}

// ------------------------------------------------------------------------------
// Regime Table (last bar only)
// ------------------------------------------------------------------------------
if (isLastBar) {
    var regimeText = regimeStrong ? "STRONG" : (regimePoor ? "POOR" : "NEUTRAL")
    var regimeTextColor = regimeStrong ? bullColor : (regimePoor ? bearColor : neutralColor)
    var upperText = useDynamic ? "Dynamic Upper: " + dynUpper : "Static Upper: " + upperBand
    var lowerText = useDynamic ? "Dynamic Lower: " + dynLower : "Static Lower: " + lowerBand

    plotTable(
        data=[
            ["Rolling Sharpe V2", regimeText],
            ["Sharpe", sharpe[0]],
            ["Signal", signal[0]],
            ["Momentum", hist[0]],
            ["Z-Score", zScore[0]],
            [upperText, lowerText],
            ["Session High", sessionHighSharpe],
            ["Session Low", sessionLowSharpe]
        ],
        position="top_right",
        headerRow=true,
        headerColumn=true,
        textColor="#e2e8f0",
        headerTextColor="#ffffff",
        backgroundColor=transparency("#0f172a", 40),
        headerBackgroundColor=transparency("#1e293b", 40),
        borderColor=transparency("#334155", 40),
        borderWidth=1,
        fontSize=10,
        cellPadding=4
    )
}