Beschreibung des Mechanismus für die Rückprüfung der FMZ-Simulationsstufe

Backtest-Architektur

Das FMZ-Plattform-Backtest-Programm ist ein kompletter Kontrollprozess, und das Programm befragt non-stop nach einer bestimmten Frequenz. Die von jedem Markt und Handel API zurückgegebenen Daten simuliert auch die tatsächliche Laufzeit nach der Anrufzeit. Es gehört zu denonTickDieonBarEin besserer Support für Backtests von Strategien auf der Grundlage vonTickerDaten (Strategie mit höherer Betriebsfrequenz).

Unterschied zwischen Simulations-Backtest und echten Markt-Backtest

• Zurückprüfung auf Simulationsebene

Der Simulationsniveau-Backtest basiert auf den unteren K-Liniendaten des Backtestsystems, und gemäß einem bestimmten Algorithmus wird die Interpolation der Tickerdaten im Rahmen der Werte der höchsten, niedrigsten, Eröffnungs- und Schlusskosten des gegebenen unteren K-Linienbalkens in diesenBarZeitreihen.

• Backtest auf dem realen Markt

Der reale Marktspiegel-Backtest ist die tatsächlichen Tickerebene inBarBei Strategien, die auf Tickerebene basieren, ist die Verwendung von Backtests auf dem realen Marktniveau der Realität näher.

Simulationsstufe Backtest-Mechanismus-Untenlinie K

Für den echten Markt-Backtest gibt es keine Basis-K-Line-Option (weil Tickerdaten real sind, ist keine Basis-K-Line erforderlich, um die Erzeugung zu simulieren).

Im Simulations-Backtest werden die erzeugtentickerDiese K-Liniendaten sind die unteren K-Linien. Bei der tatsächlichen Verwendung des Simulations-Level-Backtests muss die Periode der unteren K-Line kleiner sein als die Periode, in der die API aufgerufen wird, um die K-Line zu erhalten, wenn die Strategie ausgeführt wird. Andernfalls werden die Daten aufgrund des großen Zyklus der unteren K-Line und der unzureichenden Anzahl der erzeugten Tickers verzerrt, wenn die API aufgerufen wird, um die K-Line des angegebenen Zeitraums zu erhalten. Wenn Sie den großen Zeitraum K-Line-Backtest verwenden, können Sie den unteren K-Line-Zyklus angemessen erhöhen.

Wie man Tickerdaten für die untere K-Zeile generiert

Der Mechanismus zur Erzeugung simulierter Tickers auf der unteren K-Linie ist derselbe wie die berühmte Handelssoftware MetaTrader 4

Algorithmuscode für die Erstellung von Tickerdaten

Spezifischer Algorithmus zur Simulation von Tickdaten aus den unteren K-Liniendaten:

function recordsToTicks(period, num_digits, records) {
    // http://www.metatrader5.com/en/terminal/help/tick_generation
    if (records.length == 0) {
        return []
    }
    var ticks = []
    var steps = [0, 2, 4, 6, 10, 12, 16, 18, 23, 25, 27, 29]
    var pown = Math.pow(10, num_digits)

    function pushTick(t, price, vol) {
        ticks.push([Math.floor(t), Math.floor(price * pown) / pown, vol])
    }

    for (var i = 0; i < records.length; i++) {
        var T = records[i][0]
        var O = records[i][1]
        var H = records[i][2]
        var L = records[i][3]
        var C = records[i][4]
        var V = records[i][5]
        if (V > 1) {
            V = V - 1
        }
        if ((O == H) && (L == C) && (H == L)) {
            pushTick(T, O, V)
        } else if (((O == H) && (L == C)) || ((O == L) && (H == C))) {
            pushTick(T, O, V)
        } else if ((O == C) && ((O == L) || (O == H))) {
            pushTick(T, O, V / 2)
            pushTick(T + (period / 2), (O == L ? H : L), V / 2)
        } else if ((C == H) || (C == L)) {
            pushTick(T, O, V / 2)
            pushTick(T + (period * 0.382), (C == L ? H : L), V / 2)
        } else if ((O == H) || (O == L)) {
            pushTick(T, O, V / 2)
            pushTick(T + (period * 0.618), (O == L ? H : L), V / 2)
        } else {
            var dots = []
            var amount = V / 11
            pushTick(T, O, amount)
            if (C > O) {
                dots = [
                    O - (O - L) * 0.75,
                    O - (O - L) * 0.5,
                    L,
                    L + (H - L) / 3.0,
                    L + (H - L) * (4 / 15.0),
                    H - (H - L) / 3.0,
                    H - (H - L) * (6 / 15.0),
                    H,
                    H - (H - C) * 0.75,
                    H - (H - C) * 0.5,
                ]
            } else {
                dots = [
                    O + (H - O) * 0.75,
                    O + (H - O) * 0.5,
                    H,
                    H - (H - L) / 3.0,
                    H - (H - L) * (4 / 15.0),
                    H - (H - L) * (2 / 3.0),
                    H - (H - L) * (9 / 15.0),
                    L,
                    L + (C - L) * 0.75,
                    L + (C - L) * 0.5,
                ]
            }
            for (var j = 0; j < dots.length; j++) {
                pushTick(T + period * (steps[j + 1] / 30.0), dots[j], amount)
            }
        }
        pushTick(T + (period * 0.98), C, 1)
    }
    return ticks
}

Bei der Anwendung des Simulations-Backtests werden daher Preissprünge in der Zeitreihe auftreten.