The parameter surface: Sharpe by fast length, one line per slow length

Name: The parameter surface: Sharpe by fast length, one line per slow length
Creator: Strasmore
Published: 2026-09-22
License: https://www.strasmore.com/terms/

Answered against 22 years of US equities and 12 years of US options data and published with the query that produced it. This result is stored as of 2026-09-22, from The Open-Source TradingView Optimizer.

as of 2026-09-22 ranking 6×4read in context →

The parameter surface: Sharpe by fast length, one line per slow length — 6 rows by 4 columns, computed 2026-09-22 from US exchange, SIP and OPRA data.
fast_ma	sharpe_slow_50	sharpe_slow_100	sharpe_slow_200
5	0.68	0.7	0.93
10	0.7	0.83	0.84
15	0.61	0.78	0.82
20	0.61	0.63	0.74
25	0.57	0.46	0.78
30	0.65	0.6	0.71

Rows × columns: 6 × 4
Computed: 2026-09-22
Completeness: No missing values
Source: US exchange, SIP and OPRA market data
Licence: Strasmore terms · free, no signup
Formats: JSON · CSV · the SQL below

What each column holds

Column definitions for The parameter surface: Sharpe by fast length, one line per slow length, derived from the stored result.
Column	Type	Range
`fast_ma`	number	5 to 30
`sharpe_slow_50`	number	0.57 to 0.7
`sharpe_slow_100`	number	0.46 to 0.83
`sharpe_slow_200`	number	0.71 to 0.93

Computed from Strasmore's warehouse of US exchange, SIP and OPRA market data. Equity prices are delayed; options greeks and implied volatility are end-of-day. This result is stored, not recomputed on load — it is exactly the numbers that were returned on 2026-09-22, and the query below is what returned them.

Run it yourself

This is the exact query behind the result above. Change a ticker, a date or a column and run it against the warehouse — no account, no key. The no-signup tier is smaller than the one this page was computed on; a query that reaches past it comes back saying which plan runs it.

WITH
    series AS
    (
        SELECT arraySort(r -> r.1, groupArray((date, toFloat64(close)))) AS rows_sorted
        FROM global_markets.stocks_daily_aggs
        WHERE ticker = 'SPY'
          AND date >= '2016-01-04'
          AND date <= '2025-06-30'
    ),
    grid AS
    (
        SELECT
            arrayMap(r -> r.2, rows_sorted) AS px,
            g.1                             AS fast,
            g.2                             AS slow
        FROM series
        ARRAY JOIN
        [
            (5, 50), (5, 100), (5, 150), (5, 200),
            (10, 50), (10, 100), (10, 150), (10, 200),
            (15, 50), (15, 100), (15, 150), (15, 200),
            (20, 50), (20, 100), (20, 150), (20, 200),
            (25, 50), (25, 100), (25, 150), (25, 200),
            (30, 50), (30, 100), (30, 150), (30, 200)
        ] AS g
    ),
    scored AS
    (
        SELECT
            fast,
            slow,
            arrayAvg(rets)
                / sqrt(arrayAvg(arrayMap(r -> r * r, rets)) - pow(arrayAvg(rets), 2))
                * sqrt(252) AS sharpe
        FROM
        (
            SELECT
                fast,
                slow,
                arrayMap(
                    i -> if(arrayAvg(arraySlice(px, i - fast + 1, fast)) > arrayAvg(arraySlice(px, i - slow + 1, slow)),
                            px[i + 1] / px[i] - 1,
                            0.0),
                    range(200, length(px))
                ) AS rets
            FROM grid
        )
    )
SELECT
    fast                                 AS fast_ma,
    round(maxIf(sharpe, slow = 50), 2)   AS sharpe_slow_50,
    round(maxIf(sharpe, slow = 100), 2)  AS sharpe_slow_100,
    round(maxIf(sharpe, slow = 200), 2)  AS sharpe_slow_200
FROM scored
GROUP BY fast
HAVING countIf(slow = 50) > 0
   AND countIf(slow = 100) > 0
   AND countIf(slow = 200) > 0
ORDER BY fast_ma

SQL to run

WITH
    series AS
    (
        SELECT arraySort(r -> r.1, groupArray((date, toFloat64(close)))) AS rows_sorted
        FROM global_markets.stocks_daily_aggs
        WHERE ticker = 'SPY'
          AND date >= '2016-01-04'
          AND date <= '2025-06-30'
    ),
    grid AS
    (
        SELECT
            arrayMap(r -> r.2, rows_sorted) AS px,
            g.1                             AS fast,
            g.2                             AS slow
        FROM series
        ARRAY JOIN
        [
            (5, 50), (5, 100), (5, 150), (5, 200),
            (10, 50), (10, 100), (10, 150), (10, 200),
            (15, 50), (15, 100), (15, 150), (15, 200),
            (20, 50), (20, 100), (20, 150), (20, 200),
            (25, 50), (25, 100), (25, 150), (25, 200),
            (30, 50), (30, 100), (30, 150), (30, 200)
        ] AS g
    ),
    scored AS
    (
        SELECT
            fast,
            slow,
            arrayAvg(rets)
                / sqrt(arrayAvg(arrayMap(r -> r * r, rets)) - pow(arrayAvg(rets), 2))
                * sqrt(252) AS sharpe
        FROM
        (
            SELECT
                fast,
                slow,
                arrayMap(
                    i -> if(arrayAvg(arraySlice(px, i - fast + 1, fast)) > arrayAvg(arraySlice(px, i - slow + 1, slow)),
                            px[i + 1] / px[i] - 1,
                            0.0),
                    range(200, length(px))
                ) AS rets
            FROM grid
        )
    )
SELECT
    fast                                 AS fast_ma,
    round(maxIf(sharpe, slow = 50), 2)   AS sharpe_slow_50,
    round(maxIf(sharpe, slow = 100), 2)  AS sharpe_slow_100,
    round(maxIf(sharpe, slow = 200), 2)  AS sharpe_slow_200
FROM scored
GROUP BY fast
HAVING countIf(slow = 50) > 0
   AND countIf(slow = 100) > 0
   AND countIf(slow = 200) > 0
ORDER BY fast_ma

⌘/Ctrl + Enter

Work with this data in your AI assistant

Opens ready to query, with this page's data. Free, no account.

Claude ChatGPT Gemini Muse Your own agent

More from this analysisThe Open-Source TradingView Optimizer

In-sample rank versus out-of-sample Sharpe, same 24 cells ranking 24×4 → A 24-cell moving-average grid on SPY, ranked by Sharpe ranking 24×2 → Buy-and-hold SPY: the same rule, scored year by year ranking 9×2 → US tickers trading in a June week, and how many still traded in June 2026 ranking 11×4 → A 20/50 moving-average crossover on SPY, year by year, against holding ranking 9×4 → Same rule, prior-session signal against same-session signal, SPY by year ranking 9×4 → See all 3,293 queries →