Description du mécanisme de backtesting du niveau de simulation quantitative de l’inventeur

• ### 1 - Retour sur l’architecture

La stratégie de l’inventeur est un processus de contrôle complet, qui consiste à effectuer des enquêtes en continu à une certaine fréquence. Les données renvoyées par l’API de transaction de chaque situation sont également en fonction du moment de l’appel et simulent le fonctionnement réel.

• 2 Différence entre la détection de niveau analogue et la détection de niveau disque

  • #### Rétro-mesure au niveau de l’analogie

  Le repérage de niveau analogique est une simulation d’une séquence de temps d’insertion de données de ticker dans la barre de données de la barre K de base, selon un algorithme dans un cadre composé de valeurs de la barre de données de la barre K de base, les valeurs maximale, minimale, d’ouverture et de fermeture.

  • #### Retour au niveau du disque

  La rétroaction au niveau du disque est la valeur réelle des données au niveau du ticker dans la séquence de temps de la barre. Pour les stratégies basées sur des données au niveau du ticker, l’utilisation de la rétroaction au niveau du disque est plus proche de la valeur réelle. Les tickers sont des données enregistrées en temps réel, et non générées par simulation.

• 3 - Système de rétroaction de niveau analogique - ligne K inférieure

Il n’y a pas d’option de ligne K sous-jacente pour la détection au niveau du disque (parce que les données de ticker sont réelles, aucune ligne K sous-jacente n’est utilisée pour simuler la génération). Dans le cas d’une simulation au niveau de l’analogie, le ticker généré par la simulation de données K-lignes. Ces données K-lignes sont les lignes K-lignes. Dans le cas d’une simulation au niveau de l’analogie, la période de ligne K-ligne de base doit être inférieure à la période d’appel de l’API pour obtenir des lignes K-lignes lors de l’exécution de la stratégie.

• ### 4, comment les lignes K sous-jacentes génèrent des données de ticker

Le mécanisme de génération des tickers analogiques de la ligne K de base est le même que celui de MT4.

• ### 5/ L’algorithme qui génère les données des tickers

Les algorithmes pour simuler les données de tick sur les lignes K sous-jacentes sont les suivants:

function recordsToTicks(period, num_digits, records) {
    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
}

Par conséquent, les fluctuations de prix sur la séquence temporelle peuvent survenir lors de l’utilisation de la rétro-évaluation au niveau de l’analogie.