Fonctions d'entrée de stratégie

Pour les stratégiesJavaScript, Python, etC++les langues, les fonctions d'entrée suivantes ont été définies pour la plateforme de négociation quantitative FMZ.

Nom de la fonction	Définition
main()	La fonction d'entrée, c'est la fonction principale de la stratégie.
onexit()	Il s'agit d'une fonction de nettoyage lorsque la sortie est normale, son temps d'exécution maximal est de 5 minutes, qui peut être laissé non déclaré; si le temps d'arrêt se produit, uninterrompreL'erreur sera signalée.onerror()La fonction est déclenchée en premier pendant la négociation en direct.onexit()la fonction ne sera plus activée.
onerror()	Il s'agit d'une fonction de sortie anormale, son temps d'exécution maximal est de 5 minutes, qui peut être laissé non déclaré.PythonetC++ne prennent pas en charge cette fonction, et la fonction n'est pas prise en charge par le système de backtesting.
init()	C'est une fonction d'initialisation, son programme de stratégie sera appelé automatiquement lorsqu'il commence à fonctionner, ce qui peut être laissé non déclaré.

Une sortie

onexit(), le traitement des travaux de nettoyage, avec un temps d'exécution maximal de 5 minutes, qui est réalisé par l'utilisateur.

function main(){
    Log("Start running, stop after 5 seconds, and execute onexit function!")
    Sleep(1000 * 5)
}

// onexit function implementation
function onexit(){
    var beginTime = new Date().getTime()
    while(true){
        var nowTime = new Date().getTime()
        Log("The program stops counting down..The cleaning starts and has passed:", (nowTime - beginTime) / 1000, "Seconds!")
        Sleep(1000)
    }
}

import time 
def main():
    Log("Start running, stop after 5 seconds, and execute onexit function!")
    Sleep(1000 * 5)

def onexit():
    beginTime = time.time() * 1000
    while True:
        ts = time.time() * 1000
        Log("The program stops counting down.The cleaning starts and has passed:", (nowTime - beginTime) / 1000, "Seconds!")
        Sleep(1000)

void main() {
    Log("Start running, stop after 5 seconds, and execute onexit function!");
    Sleep(1000 * 5);
}

void onexit() {
    auto beginTime = Unix() * 1000;
    while(true) {
        auto ts = Unix() * 1000;
        Log("The program stops counting down.The cleaning starts and has passed:", (nowTime - beginTime) / 1000, "Seconds!");
        Sleep(1000);
    }
}

Testez leonexit()fonction:

function main() {
    if (exchange.GetName().startsWith("Futures_")) {
        Log("The exchange is futures")
        exchange.SetContractType("swap")
    } else {
        Log("The exchange is spot")
    }

    if (IsVirtual()) { 
        try { 
            onTick()
        } catch (e) { 
            Log("error:", e)
        }  
    } else {
        onTick()
    }
}

function onTick() {
    while (true) {
        var ticker = exchange.GetTicker() 
        LogStatus(_D(), ticker ? ticker.Last : "--")
        Sleep(500) 
    } 
}

function onexit() { 
    Log("Execute the sweep function") 
}

def main():
    if exchange.GetName().startswith("Futures_"):
        Log("The exchange is futures")
    else:
        Log("The exchange is spot")

    if IsVirtual():
        try:
            onTick()
        except Exception as e:
            Log(e)
    else:
        onTick()

def onTick():
    while True:
        ticker = exchange.GetTicker()
        LogStatus(_D(), ticker["Last"] if ticker else "--")
        Sleep(500)

def onexit():
    Log("Execute the sweep function")

#include <iostream>
#include <exception>
#include <string>

void onTick() {
    while (true) {
        auto ticker = exchange.GetTicker();
        LogStatus(_D(), ticker);
        Sleep(500);
    } 
}

void main() {
    std::string prefix = "Futures_";
    bool startsWith = exchange.GetName().substr(0, prefix.length()) == prefix;
    if (startsWith) {
        Log("The exchange is futures");
        exchange.SetContractType("swap");
    } else {
        Log("The exchange is spot");
    }

    if (IsVirtual()) {
        try {
            onTick();
        } catch (...) {
            std::cerr << "Caught unknown exception" << std::endl;
        }        
    } else {
        onTick();
    }
}

void onexit() { 
    Log("Execute the sweep function");
}

Comme la stratégie dans le système de backtesting est généralement conçue comme une boucle sans fin, laonexit()La fonction mise en œuvre dans la stratégie d'exécution ne peut pas être activée dans le système de backtesting.onexit()la fonction peut être déclenchée par la détection de la marque de fin du système de backtesting (exception EOF).

init (()

L'utilisateur implémente la fonction d'initialisationinit(), qui exécutera automatiquement la fonctioninit()au début de la stratégie pour compléter la tâche d'initialisation.

function main(){
    Log("The first line of the code executed in the program!", "#FF0000")
    Log("Exit!")
}

// Initialization the function
function init(){     
    Log("Initialization!")
}

def main():
    Log("The first line of the code executed in the program!", "#FF0000")
    Log("Exit!")

def init():
    Log("Initialization!")

void main() {
    Log("The first line of the code executed in the program!", "#FF0000");
    Log("Exit!");
}

void init() {
    Log("Initialization!");
}

Une erreur.

Exécution de la fonctiononerror()Cette fonction ne prend pas en charge les stratégies écrites enPythonetC++Leonerror()La fonction peut prendre unemsgparamètre, qui est le message d'erreur qui est signalé lorsque l'exception est déclenchée.

function main() {
    var arr = []
    Log(arr[6].Close)  // A program exception is intentionally raised here.
}

function onerror(msg) {
    Log("error:", msg)
}

# not supported by python

// not supported by C++

Système de contre-test Cadre stratégique et fonctions de l'API