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.
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
//@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
)
}