Renvoie le numéro de version actuel du système.
Numéro de version du système actuel, tel que3.6- Je ne sais pas.
chaîne
Version (en)
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
Le numéro de version du système est le numéro de version du programme du docker.
La fonction de sommeil, provoquant la pause du programme pendant une période de temps.
Le sommeil (milliseconde)
LemillisecondLe paramètre est utilisé pour définir la durée du sommeil et le nombre de millisecondes.
milliseconde
vrai
Numéro
function main() {
Sleep(1000 * 10) // Wait for 10 seconds
Log("Waited for 10 seconds")
}
def main():
Sleep(1000 * 10)
Log("Waited for 10 seconds")
void main() {
Sleep(1000 * 10);
Log("Waited for 10 seconds");
}
Par exemple, lors de l'exécution duSleep(1000)Il prend en charge les opérations avec un temps de sommeil inférieur à 1 milliseconde, par exemple le réglageSleep(0.1)Il prend en charge un paramètre minimum de0.000001, c'est-à-dire l'hibernation en nanoseconde, où 1 nanoseconde est égale à1e-6Des millisecondes.
Lors de l'écriture de stratégies dans lePythonLa langue, leSleep(millisecond)Il n'est pas recommandé d'utiliser letime.sleep(second)fonction dePythonC' est...timeC'est parce qu'en utilisant letime.sleep(second)fonction dans une stratégie fait attendre le programme de stratégie pendant une période de temps en fait lors du backtesting (pas sauter sur la série temporelle du système de backtesting), de sorte qu'il provoque la stratégie de backtest très lentement.
Déterminer si l'environnement de fonctionnement de la stratégie est un système de backtesting.
La stratégie renvoie une valeur réelle, par exemple:trueLa stratégie renvoie une valeur fausse, par exemple:falselorsqu'il est exécuté dans un environnement de négociation en direct.
Boole
C' est virtuel?
function main() {
if (IsVirtual()) {
Log("The current backtest system environment.")
} else {
Log("The current live trading environment.")
}
}
def main():
if IsVirtual():
Log("The current backtest system environment.")
else:
Log("The current live trading environment.")
void main() {
if (IsVirtual()) {
Log("The current backtest system environment.");
} else {
Log("The current live trading environment.");
}
}
Déterminer si l'environnement en cours est un système de backtesting, qui est utilisé pour être compatible avec la différence entre le backtesting et le trading en direct.
Envoyez un courriel.
Une livraison réussie d'un e-mail renvoie une valeur réelle, par exemple,true, et une livraison ratée renvoie une valeur fausse, par exemple,false- Je ne sais pas.
Boole
Mail ((smtpServeur, smtpNom d'utilisateur, smtpCode d'accès, mailTo, titre, corps)
Utilisé pour spécifier leSMTPl'adresse de service de l'expéditeur du courrier électronique.
Le serveur smtp
vrai
chaîne
Utilisé pour spécifier l'adresse e-mail de l'expéditeur.
Nom de l'utilisateur
vrai
chaîne
LeSMTPmot de passe de la boîte aux lettres de l'expéditeur.
Le mot de passe
vrai
chaîne
Utilisé pour spécifier l'adresse e-mail du destinataire.
Envoyer par mailTo
vrai
chaîne
Titre de courriel.
titre
vrai
chaîne
Le corps de l'email.
corps
vrai
chaîne
function main(){
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
}
def main():
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
void main() {
Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body");
}
LesmtpPasswordparamètre définit le mot de passe pour leSMTPle service, pas le mot de passe de la boîte aux lettres.
Lors du réglage dusmtpServerparamètre, si vous avez besoin de changer le port, vous pouvez ajouter le numéro de port directement dans le paramètresmtpServerPar exemple: courrier QQsmtp.qq.com:587, qui est disponible pour les tests.
Si une erreur est signalée:unencryped connection, vous devez modifier lesmtpServerde l'annéeMailLe format du paramètre est le suivant:ssl://xxx.com:xxx, par exemple, lesslméthode deSMTPpour le courrier QQ:ssl://smtp.qq.com:465ousmtp://xxx.com:xxx- Je ne sais pas.
Il ne fonctionne pas dans le système de backtesting.
Je ne sais pas.
Version asynchrone duMail function.
LeMail_Gofonction renvoie un objet concurrent immédiatement, et vous pouvez utiliser lewaitUne livraison courriel réussie renvoie une valeur vraie, par exemple,true, et une livraison ratée renvoie une valeur fausse, par exemple,false- Je ne sais pas.
objet
Mail_Go ((smtpServeur, smtpNom d'utilisateur, smtpCode de passe, mailTo, titre, corps)
Il est utilisé pour spécifier leSMTPl'adresse de service de l'expéditeur du courrier électronique.
Le serveur smtp
vrai
chaîne
Il est utilisé pour spécifier l'adresse e-mail de l'expéditeur.
Nom de l'utilisateur
vrai
chaîne
LeSMTPmot de passe de la boîte aux lettres de l'expéditeur.
Le mot de passe
vrai
chaîne
Il est utilisé pour spécifier l'adresse e-mail du destinataire.
Envoyer par mailTo
vrai
chaîne
Titre de courriel.
titre
vrai
chaîne
Le corps de l'email.
corps
vrai
chaîne
function main() {
var r1 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
var r2 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
var ret1 = r1.wait()
var ret2 = r2.wait()
Log("ret1:", ret1)
Log("ret2:", ret2)
}
# Not supported.
// Not supported.
Il ne fonctionne pas dans le système de backtesting.
{@fun/Global/Mail Mail} Je ne peux pas le faire
Filtrez les journaux d'erreur.
FixerErrorFilter (les filtres)
Chaîne d'expressions régulières. filtres vrai chaîne
function main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
}
def main():
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
void main() {
SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused");
}
Filtrer les erreurs courantes.
function main() {
// A random query for a non-existent order with an id of 123, allowing the interface to report an error deliberately
var order = exchange.GetOrder("123")
Log(order)
// Filter http502 errors, GetOrder interface errors, after setting the error filter, the second call to GetOrder will no longer report errors
SetErrorFilter("502:|GetOrder")
order = exchange.GetOrder("123")
Log(order)
}
def main():
order = exchange.GetOrder("123")
Log(order)
SetErrorFilter("502:|GetOrder")
order = exchange.GetOrder("123")
Log(order)
void main() {
TId orderId;
Order order = exchange.GetOrder(orderId);
Log(order);
SetErrorFilter("502:|GetOrder");
order = exchange.GetOrder(orderId);
Log(order);
}
Filtrer un message d'erreur d'interface.
Les journaux d'erreurs correspondant à cette expression régulière ne seront pas téléchargés dans le système de journaux. Vous pouvez l'appeler plusieurs fois (sans limite sur le nombre de fois) pour définir plusieurs conditions de filtre. Les expressions régulières définies plusieurs fois seront accumulées et prendront effet en même temps. Vous pouvez définir une chaîne vide pour réinitialiser l'expression régulière utilisée pour filtrer les journaux d'erreurs:SetErrorFilter("")Les journaux filtrés ne sont plus écrits dans le fichier de base de données correspondant à l'identifiant de trading en direct dans le répertoire docker pour éviter que les rapports d'erreur fréquents ne gonflent le fichier de base de données.
Obtenez l'identifiant du processus de négociation en direct.
Retourner l'identifiant du processus de négociation en direct. chaîne
Je ne peux pas.
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
J'ai reçu le dernier message d'erreur.
Dernier message d'erreur. chaîne
Obtenez la dernière erreur
function main(){
// Because the order number 123 does not exist, so there will be an error.
exchange.GetOrder("123")
var error = GetLastError()
Log(error)
}
def main():
exchange.GetOrder("123")
error = GetLastError()
Log(error)
void main() {
// Order ID type: TId, so you can't pass in a string, we place an order that doesn't meet the exchange specification to trigger
exchange.GetOrder(exchange.Buy(1, 1));
auto error = GetLastError();
Log(error);
}
Il ne fonctionne pas dans le système de backtesting.
Il reçoit la commande d'interaction stratégique.
Le format de la commande retournée estControlName:Data. ControlNameest le nom du contrôle, etDataest les données entrées dans la commande. Si la commande interactive n'a pas de boîtes d'entrée, de boîtes déroulantes et d'autres composants (par exemple, une commande de bouton sans boîtes d'entrée), le format de commande retourné estControlName, qui renvoie uniquement le nom du contrôle.
chaîne
Vous avez le commandement?
function main(){
while(true) {
var cmd = GetCommand()
if (cmd) {
Log(cmd)
}
Sleep(1000)
}
}
def main():
while True:
cmd = GetCommand()
if cmd:
Log(cmd)
Sleep(1000)
void main() {
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log(cmd);
}
Sleep(1000);
}
}
Détecte la commande d'interaction et utilise leLogfonction de sortie de la commande d'interaction lorsqu'elle est détectée.
function main() {
while (true) {
LogStatus(_D())
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
var arr = cmd.split(":")
if (arr[0] == "buy") {
Log("Buy, the control without number")
} else if (arr[0] == "sell") {
Log("Sell, the control with the number of:", arr[1])
} else {
Log("Other controls trigger:", arr)
}
}
Sleep(1000)
}
}
def main():
while True:
LogStatus(_D())
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
arr = cmd.split(":")
if arr[0] == "buy":
Log("Buy, the control without number")
elif arr[0] == "sell":
Log("Sell, the control with the number of:", arr[1])
else:
Log("Other controls trigger:", arr)
Sleep(1000)
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
void split(const string& s,vector<string>& sv,const char flag = ' ') {
sv.clear();
istringstream iss(s);
string temp;
while (getline(iss, temp, flag)) {
sv.push_back(temp);
}
return;
}
void main() {
while(true) {
LogStatus(_D());
auto cmd = GetCommand();
if (cmd != "") {
vector<string> arr;
split(cmd, arr, ':');
if(arr[0] == "buy") {
Log("Buy, the control without number");
} else if (arr[0] == "sell") {
Log("Sell, the control with the number of:", arr[1]);
} else {
Log("Other controls trigger:", arr);
}
}
Sleep(1000);
}
}
Par exemple, le contrôle interactif de stratégie ajoute un contrôle sans boîte d'entrée, le contrôle interactif est nommé:buy, les informations relatives à la description du contrôle sont les suivantes:buy, qui est une commande de bouton. Continuez en ajoutant une commande avec une boîte d'entrée. La commande interactive est nommée:sellet le message de description du contrôle est le suivant:sellLe code d'interaction est conçu dans la stratégie pour répondre aux différents contrôles d'interaction:
Il ne fonctionne pas dans le système de backtesting.
Obtenez la valeur de Meta écrite lors de la génération du code d'enregistrement de stratégie.
Metales données.
chaîne
Je suis désolée.
function main() {
// The maximum asset value of the denominated currency allowed by the strategy.
var maxBaseCurrency = null
// Get the metadata when creating the registration code.
var level = GetMeta()
// Detecting the conditions corresponding to Meta.
if (level == "level1") {
// -1 for unrestricted
maxBaseCurrency = -1
} else if (level == "level2") {
maxBaseCurrency = 10
} else if (level == "level3") {
maxBaseCurrency = 1
} else {
maxBaseCurrency = 0.5
}
while(1) {
Sleep(1000)
var ticker = exchange.GetTicker()
// Detect asset values
var acc = exchange.GetAccount()
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// Stop executing strategy trading logic
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!")
continue
}
// Other trading logic
// Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker)
}
}
def main():
maxBaseCurrency = null
level = GetMeta()
if level == "level1":
maxBaseCurrency = -1
elif level == "level2":
maxBaseCurrency = 10
elif level == "level3":
maxBaseCurrency = 1
else:
maxBaseCurrency = 0.5
while True:
Sleep(1000)
ticker = exchange.GetTicker()
acc = exchange.GetAccount()
if maxBaseCurrency != -1 and maxBaseCurrency < acc["Stocks"] + acc["FrozenStocks"]:
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!")
continue
# Other trading logic
# Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker)
void main() {
auto maxBaseCurrency = 0.0;
auto level = GetMeta();
if (level == "level1") {
maxBaseCurrency = -1;
} else if (level == "level2") {
maxBaseCurrency = 10;
} else if (level == "level3") {
maxBaseCurrency = 1;
} else {
maxBaseCurrency = 0.5;
}
while(1) {
Sleep(1000);
auto ticker = exchange.GetTicker();
auto acc = exchange.GetAccount();
if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
// Stop execution strategy trading logic.
LogStatus(_D(), "level:", level, "Positions exceeding the usage limit of the registration code will no longer execute the strategy trading logic!");
continue;
}
// Other trading logic
// Normal output of status bar information
LogStatus(_D(), "level:", level, "The strategy is working properly! ticker data: \n", ticker);
}
}
Exemple de scénario d'application: utilisationMetalimiter le montant des actifs exploités par la stratégie.
Scenario d'application: besoin de faire des limites de capital pour les différents locataires de stratégie.Metala valeur définie lors de la génération du code d'enregistrement ne doit pas dépasser 190 caractères et leGetMeta()La fonction ne prend en charge que le trading en direct.Meta) est défini lors de la génération d'un code d'enregistrement de stratégie,GetMeta()La fonction renvoie null. Elle ne fonctionne pas dans le système de backtesting.
Pour le primitifSocketl'accès, le soutientcp, udp, tls, unixPrise en charge de 4 protocoles de communication populaires:mqtt, nats, amqp, kafka. Prise en charge de la connexion aux bases de données:sqlite3, mysql, postgres, clickhouse.
LeDial()une fonction renvoie null s'il s'éteint. Un appel normal renvoie un objet de connexion qui a trois méthodes:read, writeetcloseLereadLa méthode est utilisée pour lire les données,writeLa méthode est utilisée pour envoyer des données etcloseméthode est utilisée pour fermer la connexion.
Lereadla méthode prend en charge les paramètres suivants:
ws.read().ws.read(2000)spécifie un temps d'arrêt de deux secondes (2000 millisecondes).-1signifie que la fonction renvoie immédiatement, indépendamment de la présence ou de l'absence de messages, par exemple:ws.read(-1)- Je ne sais pas.
Passer le paramètre-2signifie que la fonction renvoie immédiatement avec ou sans message, mais que seul le dernier message est renvoyé, et le message tamponné est écarté.ws.read(-2).read()Description du tampon de fonction:
Les données entrantes poussées par le protocole WebSocket peuvent entraîner une accumulation de données si l'intervalle de temps entre la stratégieread()Ces données sont stockées dans le tampon, qui a une structure de données d'une file d'attente avec un maximum de 2000.
| Scénario | Aucun paramètre | Paramètre: -1 | Paramètre: -2 | Paramètre: 2000, en millisecondes |
|---|---|---|---|---|
| Données déjà dans le tampon | Retournez les données les plus anciennes immédiatement | Retournez les données les plus anciennes immédiatement | Retournez les dernières données immédiatement | Retournez les données les plus anciennes immédiatement |
| Aucune donnée dans le tampon | Retourner lorsque les données sont bloquées | Retourner nul immédiatement | Retourner nul immédiatement | Attendre 2000 ms, retourner nul si aucune donnée, retourner nul si des données sont disponibles |
| La connexion WebSocket est déconnectée ou reconnectée par le sous-jacent | read() fonction renvoie la chaîne vide, c.-à-d.: |
objet
Numéro de téléphone (adresse) Numéro (adresse, délai d'attente)
Demandez une adresse. l'adresse vrai chaîne secondes de temps d'arrêt, temps d'arrêt faux Numéro
function main(){
// Dial supports tcp://，udp://，tls://，unix://protocol, you can add a parameter to specify the number of seconds for the timeout
var client = Dial("tls://www.baidu.com:443")
if (client) {
// write can be followed by a numeric parameter to specify the timeout, write returns the number of bytes successfully sent
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while (true) {
// read can be followed by a numeric parameter specifying the timeout in milliseconds. Returning null indicates an error or timeout or that the socket has been closed
var buf = client.read()
if (!buf) {
break
}
Log(buf)
}
client.close()
}
}
def main():
client = Dial("tls://www.baidu.com:443")
if client:
client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
while True:
buf = client.read()
if not buf:
break
Log(buf)
client.close()
void main() {
auto client = Dial("tls://www.baidu.com:443");
if(client.Valid) {
client.write("GET / HTTP/1.1\nConnection: Closed\n\n");
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
Log(buf);
}
client.close();
}
}
Exemple d'appel à la fonction Dial:
function main() {
LogStatus("Connecting...")
// Accessing WebSocket interface of Binance
var client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if (!client) {
Log("Connection failed, program exited")
return
}
while (true) {
// read returns only the data retrieved after the read call
var buf = client.read()
if (!buf) {
break
}
var table = {
type: 'table',
title: 'Ticker Chart',
cols: ['Currency', 'Highest', 'Lowest', 'Buy 1', 'Sell 1', 'Last traded price', 'Volume', 'Update time'],
rows: []
}
var obj = JSON.parse(buf)
_.each(obj, function(ticker) {
table.rows.push([ticker.s, ticker.h, ticker.l, ticker.b, ticker.a, ticker.c, ticker.q, _D(ticker.E)])
})
LogStatus('`' + JSON.stringify(table) + '`')
}
client.close()
}
import json
def main():
LogStatus("Connecting...")
client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
if not client:
Log("Connection failed, program exited")
return
while True:
buf = client.read()
if not buf:
break
table = {
"type" : "table",
"title" : "Ticker Chart",
"cols" : ['Currency', 'Highest', 'Lowest', 'Buy 1', 'Sell 1', 'Last traded price', 'Volume', 'Update time'],
"rows" : []
}
obj = json.loads(buf)
for i in range(len(obj)):
table["rows"].append([obj[i]["s"], obj[i]["h"], obj[i]["l"], obj[i]["b"], obj[i]["a"], obj[i]["c"], obj[i]["q"], _D(int(obj[i]["E"]))])
LogStatus('`' + json.dumps(table) + '`')
client.close()
void main() {
LogStatus("Connecting...");
auto client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
if(!client.Valid) {
Log("Connection failed, program exited");
return;
}
while(true) {
auto buf = client.read();
if(buf == "") {
break;
}
json table = R"({
"type" : "table",
"title" : "Ticker Chart",
"cols" : ["Currency", "Highest", "Lowest", "Buy 1", "Sell 1", "Last traded price", "Volume", "Update time"],
"rows" : []
})"_json;
json obj = json::parse(buf);
for(auto& ele : obj.items()) {
table["rows"].push_back({ele.value()["s"], ele.value()["h"], ele.value()["l"], ele.value()["b"], ele.value()["a"], ele.value()["c"],
ele.value()["q"], _D(ele.value()["E"])});
}
LogStatus("`" + table.dump() + "`");
}
client.close();
}
Pour accéder à l'interface WebSocket de Binance:
var ws = null
function main(){
var param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
// When calling Dial function, specify reconnect=true to set reconnection mode and payload to be the message sent when reconnecting. When the WebSocket connection is disconnected, it will reconnect and send messages automatically.
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
var pingCyc = 1000 * 20
var lastPingTime = new Date().getTime()
while(true){
var nowTime = new Date().getTime()
var ret = ws.read()
Log("ret:", ret)
if(nowTime - lastPingTime > pingCyc){
var retPing = ws.write("ping")
lastPingTime = nowTime
Log("Send : ping", "#FF0000")
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("exit")
}
import json
import time
ws = None
def main():
global ws
param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
pingCyc = 1000 * 20
lastPingTime = time.time() * 1000
while True:
nowTime = time.time() * 1000
ret = ws.read()
Log("ret:", ret)
if nowTime - lastPingTime > pingCyc:
retPing = ws.write("ping")
lastPingTime = nowTime
Log("Send: ping", "#FF0000")
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("exit")
auto objWS = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true");
void main() {
json param = R"({
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
})"_json;
objWS.write(param.dump());
if(objWS.Valid) {
uint64_t pingCyc = 1000 * 20;
uint64_t lastPingTime = Unix() * 1000;
while(true) {
uint64_t nowTime = Unix() * 1000;
auto ret = objWS.read();
Log("ret:", ret);
if(nowTime - lastPingTime > pingCyc) {
auto retPing = objWS.write("ping");
lastPingTime = nowTime;
Log("Send: ping", "#FF0000");
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
objWS.close();
Log("exit");
}
Accès à l'interface du ticker WebSocket OKX
var ws = null
function main(){
var param = {"sub": "market.btcusdt.detail", "id": "id1"}
ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
while(1){
var ret = ws.read()
Log("ret:", ret)
// Respond to heartbeat packet operations
try {
var jsonRet = JSON.parse(ret)
if(typeof(jsonRet.ping) == "number") {
var strPong = JSON.stringify({"pong" : jsonRet.ping})
ws.write(strPong)
Log("Respond to ping, send pong:", strPong, "#FF0000")
}
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("Execute the ws.close() function")
}
import json
ws = None
def main():
global ws
param = {"sub" : "market.btcusdt.detail", "id" : "id1"}
ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
while True:
ret = ws.read()
Log("ret:", ret)
# Respond to heartbeat packet operations
try:
jsonRet = json.loads(ret)
if "ping" in jsonRet and type(jsonRet["ping"]) == int:
strPong = json.dumps({"pong" : jsonRet["ping"]})
ws.write(strPong)
Log("Respond to ping, send pong:", strPong, "#FF0000")
except Exception as e:
Log("e:", e)
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("Execute the ws.close() function")
using namespace std;
void main() {
json param = R"({"sub" : "market.btcusdt.detail", "id" : "id1"})"_json;
auto ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + param.dump());
if(ws.Valid) {
while(true) {
auto ret = ws.read();
Log("ret:", ret);
// Respond to heartbeat packet operations
try
{
auto jsonRet = json::parse(ret);
if(jsonRet["ping"].is_number()) {
json pong = R"({"pong" : 0})"_json;
pong["pong"] = jsonRet["ping"];
auto strPong = pong.dump();
ws.write(strPong);
Log("Respond to ping, send pong:", strPong, "#FF0000");
}
} catch(exception &e)
{
Log("e:", e.what());
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
// ws.close();
Log("Execute the ws.close() function");
}
Accès à l'interface du ticker WebSocket de Huobi:
function getLogin(pAccessKey, pSecretKey, pPassphrase) {
// Signature function for login
var ts = (new Date().getTime() / 1000).toString()
var login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey) // exchange.HMAC has been deprecated and is temporarily supported. Please use the latest exchange.Encode function instead.
}]
}
return login
}
var client_private = null
function main() {
// Because the read function uses a timeout setting, filtering the timeout reports errors that would otherwise be output with redundant errors
SetErrorFilter("timeout")
// Position channel subscription information
var posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
var accessKey = "xxx"
var secretKey = "xxx"
var passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000) // When logging in, you cannot subscribe to private channels immediately, you need to wait for server response
client_private.write(JSON.stringify(posSubscribe))
if (client_private) {
var lastPingTS = new Date().getTime()
while (true) {
var buf = client_private.read(-1)
if (buf) {
Log(buf)
}
// Detect disconnection, reconnect
if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
Log("Disconnection detected, close connection, reconnect")
client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(JSON.stringify(posSubscribe))
}
// Send heartbeat packets
var nowPingTS = new Date().getTime()
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping")
lastPingTS = nowPingTS
}
}
}
}
function onexit() {
var ret = client_private.close()
Log("Close the connection!", ret)
}
import json
import time
def getLogin(pAccessKey, pSecretKey, pPassphrase):
ts = str(time.time())
login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey)
}]
}
return login
client_private = None
def main():
global client_private
SetErrorFilter("timeout")
posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
accessKey = "xxx"
secretKey = "xxx"
passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
if client_private:
lastPingTS = time.time() * 1000
while True:
buf = client_private.read(-1)
if buf:
Log(buf)
if buf == "" and client_private.write(json.dumps(posSubscribe)) == 0:
Log("Disconnection detected, close connection, reconnect")
ret = client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
nowPingTS = time.time() * 1000
if nowPingTS - lastPingTS > 10 * 1000:
client_private.write("ping")
lastPingTS = nowPingTS
def onexit():
ret = client_private.close()
Log("Close the connection!", ret)
auto client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
json getLogin(string pAccessKey, string pSecretKey, string pPassphrase) {
auto ts = std::to_string(Unix());
json login = R"({
"op": "login",
"args": [{
"apiKey": "",
"passphrase": "",
"timestamp": "",
"sign": ""
}]
})"_json;
login["args"][0]["apiKey"] = pAccessKey;
login["args"][0]["passphrase"] = pPassphrase;
login["args"][0]["timestamp"] = ts;
login["args"][0]["sign"] = exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey);
return login;
}
void main() {
SetErrorFilter("timeout");
json posSubscribe = R"({
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
})"_json;
auto accessKey = "xxx";
auto secretKey = "xxx";
auto passphrase = "xxx";
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
if (client_private.Valid) {
uint64_t lastPingTS = Unix() * 1000;
while (true) {
auto buf = client_private.read(-1);
if (buf != "") {
Log(buf);
}
if (buf == "") {
if (client_private.write(posSubscribe.dump()) == 0) {
Log("Disconnection detected, close connection, reconnect");
client_private.close();
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
}
}
uint64_t nowPingTS = Unix() * 1000;
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping");
lastPingTS = nowPingTS;
}
}
}
}
void onexit() {
client_private.close();
Log("exit");
}
Pour accéder à l'interface d'authentification WebSocket OKX
var client = null
function main() {
// client = Dial("sqlite3://:memory:") // Using an in-memory database
client = Dial("sqlite3://test1.db") // Open/connect to the database file in the docker's directory
// record handle
var sqlite3Handle = client.fd()
Log("sqlite3Handle:", sqlite3Handle)
// Querying tables in the database
var ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'")
Log(ret)
}
function onexit() {
Log("Execute client.close()")
client.close()
}
// Not supported
// Not supported
L'objet de connexion renvoyé par la fonction Dial lors de la connexion à une base de données possède deux fonctions de méthode qui lui sont propres:
exec(sqlString): Utilisé pour exécuter des instructions SQL de manière similaire à laDBExec() function.fd()Lefd()fonction renvoie une poignée (par exemple, la variable poignée est poignée) à utiliser par d'autres threads pour se reconnecter (même si l'objet créé par Dial a déjà été fermé par l'exécution duclose()La fonction de fermeture de la connexion) en passant la poignée dans leDial()la fonction, par exemple,Dial(handle)connexion de réutilisation.
Ce qui suit est un exemple de la fonction Dial se connectant à unsqlite3 database.Détails de laaddressparamètre, séparé par le|le symbole suivant l'adresse normale:wss://ws.okx.com:8443/ws/v5/publicS' il y en a|les caractères dans la chaîne de paramètres, puis||La partie après que ce sont quelques paramètres de paramètres de fonction, et chaque paramètre est connecté avec&Il s'agit par exemple dess5Les paramètres de substitution et de compression peuvent être définis ensemble comme suit:Dial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")
| Fonctions prises en charge par le paramètre d'adresse de la fonction Dial | Description du paramètre |
|---|---|
| Paramètres liés à la compression des données du protocole WebSocket: compress=valeur du paramètre | compresser est la méthode de compression, les options de paramètres compresser sont: gzip_raw, gzip, etc. Si la méthode gzip n'est pas gzip standard, vous pouvez utiliser la méthode étendue: gzip_raw |
| Paramètres liés à la compression des données du protocole WebSocket: mode=valeur du paramètre | mode est le mode de compression, le paramètre de mode peut être double, envoyer, recv. double est la compression bidirectionnelle, envoyer des données compressées, recevoir des données compressées. envoyer est envoyer des données compressées. recv est recevoir des données compressées, décompression locale. |
| Le protocole WebSocket définit les paramètres sous-jacents liés à la reconnexion automatique: reconnect=valeur du paramètre | reconnect est la définition de reconnect, reconnect=true est la définition de reconnect. |
| Le protocole WebSocket définit les paramètres sous-jacents liés à la reconnexion automatique: interval=valeur du paramètre | l'intervalle est l'intervalle de réessayage, en millisecondes, l'intervalle=10000 est l'intervalle de réessayage de 10 secondes, la valeur par défaut est de 1 seconde lorsqu'il n'est pas réglé, c'est-à-dire l'intervalle=1000. |
| Le protocole WebSocket définit les paramètres sous-jacents liés à la reconnexion automatique: charge utile=valeur du paramètre | payload est le message d'abonnement qui doit être envoyé lorsque le WebSocket est reconnecté, par exemple: payload=okokok. |
| Paramètres liés aux chaussettes5 proxy: proxy=valeur du paramètre | Proxy est le paramètre de paramètre de configuration de proxy ss5: socks5://name:pwd@192.168.0.1:1080, le nom est le nom d'utilisateur du serveur ss5, pwd est le mot de passe de connexion du serveur ss5, 1080 est le port de service ss5. |
LeDial()La fonction n'est prise en charge que pour le trading en direct.
Lors de la connexion à une base de données à l'aide de la fonction Dial, la chaîne de connexion est écrite en référence au projet de pilote de langage go pour chaque base de données.
| Base de données prise en charge | Projets moteurs | Chaîne de connexion | Les commentaires |
|---|---|---|---|
| - Je ne sais pas. | github.com/mattn/go-sqlite3 | sqlite3://fichier:test.db?cache=partagé et mode=mémoire | Lesqlite3://le préfixe indique qu'une base de données sqlite3 est utilisée, exemple d'appel:Dial("sqlite3://test1.db") |
| Je vais essayer. | github.com/go-sql-driver/mysql | Je suis désolée.localhost:3306) /votre base de données?charset=utf8mb4 | – |
| les produits de postgres | github.com/lib/pq | le nom de l'utilisateur et le nom de la base de données sslmode | – |
| maison de jeu | github.com/ClickHouse/clickhouse-go | Cliquez sur le lien suivant: | – |
Veuillez noter que lorsque lepayloadcontenus définis dans leaddressparamètre contient des caractères=ou d'autres caractères spéciaux, il peut affecter l'analyse de laaddressparamètre duDialfonction, comme dans l'exemple suivant.
Exemple d'appel à l'interface privée de backPack Exchange:
var client = null
function main() {
// Base64-encoded public key of the key pair, i.e. the access key configured on FMZ
var base64ApiKey = "xxx"
var ts = String(new Date().getTime())
var data = "instruction=subscribe×tamp=" + ts + "&window=5000"
// Since signEd25519 returns a base64 encoding, it contains the character "="
var signature = signEd25519(data)
// The payload may contain the character "=" after being encoded by JSON
payload = {
"method": "SUBSCRIBE",
"params": ["account.orderUpdate"],
"signature": [base64ApiKey, signature, ts, "5000"]
}
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
if (!client) {
Log("Connection failed, program exited")
return
}
while (true) {
var buf = client.read()
Log(buf)
}
}
function onexit() {
client.close()
}
function signEd25519(data) {
return exchange.Encode("ed25519.seed", "raw", "base64", data, "base64", "{{secretkey}}")
}
L'appel suivant dans le code fonctionne bien:
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
Si vous l'écrivez directement danspayload, il ne fonctionnera pas correctement, par exemple:
client = Dial("wss://ws.backpack.exchange|payload=" + JSON.stringify(payload))
À l'heure actuelle, seul JavaScript prend en charge l'utilisation demqtt, nats, amqp, etkafkaLe code de stratégie du langage JavaScript est utilisé comme exemple pour montrer l'utilisation des quatre protocoles:mqtt, nats, amqp, etkafka:
// We need to configure and deploy proxy servers for each protocol first.
// For the sake of demonstration, the subscription (read operation) and publishing (write operation) of the topic test_topic are all performed in the current strategy.
var arrConn = []
var arrName = []
function main() {
LogReset(1)
conn_nats = Dial("nats://admin@127.0.0.1:4222?topic=test_topic")
conn_mqtt = Dial("mqtt://127.0.0.1:1883?topic=test_topic")
conn_amqp = Dial("amqp://q:admin@127.0.0.1:5672/?queue=test_Queue")
conn_kafka = Dial("kafka://localhost:9092/test_topic")
arrConn = [conn_nats, conn_amqp, conn_mqtt, conn_kafka]
arrName = ["nats", "amqp", "mqtt", "kafka"]
while (true) {
for (var i in arrConn) {
var conn = arrConn[i]
var name = arrName[i]
// Write data
conn.write(name + ", time: " + _D() + ", test msg.")
// Read data
var readMsg = conn.read(1000)
Log(name + " readMsg: ", readMsg, "#FF0000")
}
Sleep(1000)
}
}
function onexit() {
for (var i in arrConn) {
arrConn[i].close()
Log("close", arrName[i], "connect")
}
}
Référence de la documentation détaillée:Exploration de FMZ: pratique du protocole de communication entre les stratégies de négociation en direct
Envoyez une demande Http.
Retourne les données de réponse de la requête.JSONstring, il peut être analysé par leJSON.parse()fonction dans leJavaScriptLa stratégie linguistique, et par lejson::parse()fonction dans leC++Si le débogage est réglé sur true dans la structure d'options, la valeur de retour est un objet (JSON); si le débogage est réglé sur false, la valeur de retour est une chaîne.
chaîne, objet
HttpQuery (URL) HttpQuery ((url, options)
L'URL de la demande HTTP. le nom de l'adresse vrai chaîne Par exemple, les paramètres liés aux requêtes HTTP peuvent être structurés comme suit:
{
method: "POST",
body: "a=10&b=20&c=30",
charset: "UTF-8",
cookie: "session_id=12345; lang=en",
profile: "chrome_103",
debug: false,
headers: {"TEST-HTTP-QUERY": "123"},
timeout: 1000
}
tlsDes empreintes digitales.
Les paramètres pris en charge comprennent les options suivantes:
Je ne sais pas."chrome_103", "chrome_104", "chrome_105", "chrome_106", "chrome_107", "chrome_108", "chrome_109", "chrome_110", "chrome_111", "chrome_112", "chrome_117"Je suis désolée.
- Je ne sais pas."safari_15_6_1", "safari_16_0", "safari_ipad_15_6", "safari_ios_15_5", "safari_ios_15_6", "safari_ios_16_0"Je suis désolée.
Je ne sais pas."firefox_102", "firefox_104", "firefox_105", "firefox_106", "firefox_108", "firefox_110", "firefox_117"Je suis désolée.
- Je ne sais pas."opera_89", "opera_90", "opera_91"Je suis désolée.
Je ne sais pas."zalando_android_mobile", "zalando_ios_mobile"Je suis désolée.
Je suis désolée."nike_ios_mobile", "nike_android_mobile"Je suis désolée.
le gratte-ciel:"cloudscraper"Je suis désolée.
Je suis désolé."mms_ios"Je suis désolée.
Je ne sais pas."mesh_ios", "mesh_ios_1", "mesh_ios_2", "mesh_android", "mesh_android_1", "mesh_android_2"Je suis désolée.
Confirmé:"confirmed_ios", "confirmed_android"Je suis désolée.
Ça va."okhttp4_android_7", "okhttp4_android_8", "okhttp4_android_9", "okhttp4_android_10", "okhttp4_android_11", "okhttp4_android_12", "okhttp4_android_13",true, leHttpQueryl'appel de la fonction renvoie le message de réponse complet.false, uniquement les donnéesBodyde la réponse est renvoyée.profilele champ peut être laissé de côté.les options faux objet
function main(){
// An example of GET access without parameters
var info = JSON.parse(HttpQuery("https://www.okx.com/api/v5/public/time"))
Log(info)
// An example of GET access with parameters
var ticker = JSON.parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"))
Log(ticker)
}
import json
import urllib.request
def main():
# HttpQuery does not support Python, you can use the urllib/urllib2 library instead
info = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/time").read().decode('utf-8'))
Log(info)
ticker = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/market/books?instId=BTC-USDT").read().decode('utf-8'))
Log(ticker)
void main() {
auto info = json::parse(HttpQuery("https://www.okx.com/api/v5/public/time"));
Log(info);
auto ticker = json::parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"));
Log(ticker);
}
Un exemple d'accès à l'interface API de ticker publique OKX.
function main() {
// Setting proxy and sending an http request for this time, no username, no password, this http request will be sent through the proxy
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/")
// Setting proxy and sending an http request for this time, enter the user name and password, only the current call to HttpQuery takes effect, and then call HttpQuery again ("http://www.baidu.com") so that the proxy will not be used.
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/")
}
# HttpQuery does not support Python, you can use the urllib/urllib2 library instead
void main() {
HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/");
HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/");
}
La fonction HttpQuery utilise des paramètres de proxy.
LeHttpQuery()fonction ne supporte queJavaScript, C++le langage,PythonLa langue peut être utiliséeurllibLa bibliothèque est utilisée pour envoyer directement des requêtes HTTP.HttpQuery()Il est principalement utilisé pour accéder aux interfaces de l'échange qui ne nécessitent pas de signature, telles que les interfaces publiques telles que les informations des tickers.HttpQuery()peut être utilisé dans le système de backtesting pour envoyer des demandes (uniquementGETLes tests en arrière-plan sont limités à l'utilisation de 20 visites à desURLs, etHttpQuery()Les visites vont mettre en cache les données.URLest consulté une deuxième fois, leHttpQuery()La fonction renvoie les données mises en cache et aucune autre demande de réseau n'est effectuée.
Je ne sais pas si je peux le faire.
Envoie une requête HTTP, une version asynchrone duHttpQuery function.
LeHttpQuery_Go()fonction retourne immédiatement un objet concurrent qui peut être utilisé pour obtenir le résultat d'une requête HTTP en utilisant lewaitLa méthodeJSON.parse()fonction peut être utilisée pour analyser leJSON.parse()fonction dans leJavaScriptLa stratégie de la langue.
objet
HttpQuery_Go (URL) HttpQuery_Go (URL, options)
L'URL de la demande HTTP. le nom de l'adresse vrai chaîne Par exemple, les paramètres liés aux requêtes HTTP peuvent être structurés comme suit:
{
method: "POST",
body: "a=10&b=20&c=30",
charset: "UTF-8",
cookie: "session_id=12345; lang=en",
// profile: "",
debug: false,
headers: {"TEST-HTTP-QUERY": "123"},
timeout: 1000
}
tls fingerprints.true, ceciHttpQuery_Gol'appel de la fonction renvoie le message de réponse complet.false, uniquement les donnéesBodyde la réponse est renvoyée.profilele champ peut être laissé de côté.les options faux objet
function main() {
// Create the first asynchronous thread
var r1 = HttpQuery_Go("https://www.okx.com/api/v5/market/tickers?instType=SPOT")
// Create the second asynchronous thread
var r2 = HttpQuery_Go("https://api.huobi.pro/market/tickers")
// Get the return value of the first asynchronous thread call
var tickers1 = r1.wait()
// Get the return value of the second asynchronous thread call
var tickers2 = r2.wait()
// Print results
Log("tickers1:", tickers1)
Log("tickers2:", tickers2)
}
# Not supported
// Not supported
Accès asynchrone à l'interface publique de l'échange pour les données de ticker agrégées.
LeHttpQuery_Go()fonction ne supporte queJavaScript, lePythonLa langue peut être utiliséeurllibLa bibliothèque est utilisée pour envoyer directement des requêtes HTTP.HttpQuery_Go()Il est principalement utilisé pour accéder aux interfaces qui ne nécessitent pas de signature sur l'échange, telles que les interfaces publiques telles que les informations de ticker.HttpQuery_Gofonction n'est pas prise en charge dans le système de backtesting.
{@fun/Global/HttpQuery HttpQuery} Je suis désolé
Cette fonction encode les données en fonction des paramètres transmis.
LeEncodefonction renvoie les données après le codage et le cryptage.
chaîne
Encode ((algo, format d'entrée, format de sortie, données) Encode ((algo, inputFormat, outputFormat, données, cléFormat, clé)
Le paramètrealgoest l'algorithme utilisé dans le calcul du codage.raw(aucun algorithme n'est utilisé), le "signe", algoIl prend également en charge: algosupporte également: algopeut être écrit comme ed25519.seedle calcul.
quelque chose
vrai
chaîne
Utilisé pour spécifier le format de données dudataParamètre.inputFormatle paramètre peut être défini comme l'un des paramètres suivants:raw, hex, base64, string. hexcodé, base64encodé, et outputFormatle paramètre peut être défini comme l'un des paramètres suivants:raw, hex, base64, string. hexcodé, base64encodé, et dataest les données à traiter.
données
vrai
chaîne
Utilisé pour spécifier le format de données dukeyParamètre.keyle paramètre peut être défini comme l'un des paramètres suivants:raw, hex, base64, string. hexcodé, base64encodé, et keyest la clé secrète utilisée pourHMACLe paramètrekeyest nécessaire lorsque le paramètrealgoest réglée sursignousignTxLekeyle paramètre n'est pas utilisé pourHMACle chiffrement lorsque lealgole paramètre est réglé sur
function main() {
Log(Encode("raw", "raw", "hex", "example", "raw", "123")) // 6578616d706c65
Log(Encode("raw", "raw", "hex", "example")) // 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")) // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", null, "123")) // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123")) // 313233
Log(Encode("raw", "raw", "base64", "123")) // MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")) // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
}
def main():
Log(Encode("raw", "raw", "hex", "example", "raw", "123")) # 6578616d706c65
Log(Encode("raw", "raw", "hex", "example", "", "")) # 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")) # 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123", "", "")) # 313233
Log(Encode("raw", "raw", "base64", "123", "", "")) # MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")) # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
void main() {
Log(Encode("raw", "raw", "hex", "example", "raw", "123")); // 6578616d706c65
Log(Encode("raw", "raw", "hex", "example")); // 6578616d706c65
Log(Encode("sha256", "raw", "hex", "example", "raw", "123")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "", "123")); // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
Log(Encode("sha256", "raw", "hex", "example", "string", "123")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("raw", "raw", "hex", "123")); // 313233
Log(Encode("raw", "raw", "base64", "123")); // MTIz
Log(Encode("sha256", "raw", "hex", "example", "hex", "313233")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz")); // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
}
Exemple d'appel à la fonction Encode.
function main(){
var ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello") // e4bda0e5a5bd
Log(ret1)
var ret2 = Encode("text.decoder.utf8", "hex", "string", ret1)
Log(ret2)
var ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello") // c4e3bac3
Log(ret3)
var ret4 = Encode("text.decoder.gbk", "hex", "string", ret3)
Log(ret4)
}
def main():
ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello", "", "") # e4bda0e5a5bd
Log(ret1)
ret2 = Encode("text.decoder.utf8", "hex", "string", ret1, "", "")
Log(ret2)
ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello", "", "") # c4e3bac3
Log(ret3)
ret4 = Encode("text.decoder.gbk", "hex", "string", ret3, "", "")
Log(ret4)
void main(){
auto ret1 = Encode("text.encoder.utf8", "raw", "hex", "hello"); // e4bda0e5a5bd
Log(ret1);
auto ret2 = Encode("text.decoder.utf8", "hex", "string", ret1);
Log(ret2);
auto ret3 = Encode("text.encoder.gbk", "raw", "hex", "hello"); // c4e3bac3
Log(ret3);
auto ret4 = Encode("text.decoder.gbk", "hex", "string", ret3);
Log(ret4);
}
Le paramètrealgoIl prend également en charge:
LeEncode()La fonction n'est prise en charge que pour le trading en direct.keyetkeyFormatles paramètres ne sont pas passés, alorskeyle chiffrement n'est pas utilisé.
Obtenez l'horodatage nanoseconde du moment actuel.
LeUnixNano()La fonction renvoie l'horodatage de la nanoseconde.
Numéro
UnixNano (en anglais)
function main() {
var time = UnixNano() / 1000000
Log(_N(time, 0))
}
def main():
time = UnixNano()
Log(time)
void main() {
auto time = UnixNano();
Log(time);
}
Si vous avez besoin d'obtenir des horodatages en millisecondes, vous pouvez utiliser le code suivant:
Je ne sais pas.
Obtenez l'horodatage du moment actuel au deuxième niveau.
Retourne l'horodatage de deuxième niveau. Numéro
Unix (()
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
Je ne sais pas si je peux vous aider.
Obtenez les informations du système de l'appareil où se trouve le dock.
Informations sur le système. chaîne
Je suis désolée.
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
Par exemple, un appel à laGetOS()fonction pour un docker exécuté sur leMac OSle système d'exploitation pourrait renvoyer:darwin/amd64Parce que les ordinateurs Apple ont plusieurs architectures matérielles.darwinest le nom de laMac OS system.
Calcule le hachage MD5 du paramètredata.
Valeur de hachage MD5. chaîne
MD5 (données)
Les données qui nécessitent un calcul MD5. données vrai chaîne
function main() {
Log("MD5", MD5("hello world"))
}
def main():
Log("MD5", MD5("hello world"))
void main() {
Log("MD5", MD5("hello world"));
}
On appelle leMD5("hello world")fonction, la valeur de retour est:5eb63bbbe01eeed093cb22bb8f5acdc3.
{@fun/Global/Encode Encode} Je suis désolé.
Fonctions d'interface de base de données.
Un objet contenant le résultat de l'exécution d'unLe secteurdéclaration, par exemple:
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
objet
DBExec ((sql)
Le secteurune chaîne d'instructions. Le secteur vrai chaîne
function main() {
var strSql = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
// Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"))
}
def main():
arr = [
":CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
ret = DBExec(strSql)
Log(ret)
# Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"))
void main() {
string strSql = ":CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
auto ret = DBExec(strSql);
Log(ret);
// Add a piece of data
Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// Query data
Log(DBExec(":SELECT * FROM TEST_TABLE;"));
}
Prise en charge de la base de données en mémoire, pourDBExecparamètres de fonction, siLe secteurLa déclaration commence par::Il convient aux opérations de base de données qui ne nécessitent pas d'enregistrement persistant, par exemple:
function main() {
var strSql = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
var ret = DBExec(strSql)
Log(ret)
}
def main():
arr = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
ret = DBExec(strSql)
Log(ret)
void main() {
string strSql = "CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
auto ret = DBExec(strSql);
Log(ret);
}
Créez une table.
function main() {
var strSql = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
].join("")
Log(DBExec(strSql))
// Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
// Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"))
// Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
// Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
}
def main():
arr = [
"CREATE TABLE TEST_TABLE(",
"TS INT PRIMARY KEY NOT NULL,",
"HIGH REAL NOT NULL,",
"OPEN REAL NOT NULL,",
"LOW REAL NOT NULL,",
"CLOSE REAL NOT NULL,",
"VOLUME REAL NOT NULL)"
]
strSql = ""
for i in range(len(arr)):
strSql += arr[i]
Log(DBExec(strSql))
# Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
# Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"))
# Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
# Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
void main() {
string strSql = "CREATE TABLE TEST_TABLE(\
TS INT PRIMARY KEY NOT NULL,\
HIGH REAL NOT NULL,\
OPEN REAL NOT NULL,\
LOW REAL NOT NULL,\
CLOSE REAL NOT NULL,\
VOLUME REAL NOT NULL)";
Log(DBExec(strSql));
// Add a piece of data
Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
// Query data
Log(DBExec("SELECT * FROM TEST_TABLE;"));
// Modify data
Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000));
// Delete data
Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110));
}
Ajouter, supprimer, vérifier et modifier les enregistrements dans le tableau.
La fonctionDBExec()Il peut utiliser la base de données de négociation en direct (base de données SQLite) en passant des paramètres.SQLiteLe système a réservé des tables dans la base de données de négociation en direct:kvdb, cfg, log, profit, chartNe pas utiliser ces tables.Les opérationsIl n'est pas recommandé d'effectuer de telles opérations, car elles peuvent provoquer des conflits dans le système.DBExec()La fonction n'est prise en charge que pour le trading en direct.
Je ne sais pas.
Créez un UUID.
Un UUID de 32 bits. chaîne
UUID (()
function main() {
var uuid1 = UUID()
var uuid2 = UUID()
Log(uuid1, uuid2)
}
def main():
uuid1 = UUID()
uuid2 = UUID()
Log(uuid1, uuid2)
void main() {
auto uuid1 = UUID();
auto uuid2 = UUID();
Log(uuid1, uuid2);
}
LeUUID()La fonction supporte uniquement le trading en direct.
Écoutez les événements, il revient quand il y a unWebSocketdonnées lisibles ou tâches simultanées, telles que:exchange.Go(), HttpQuery_Go(), etc. sont achevés.
Si l'objet retourné n'est pas une valeur nulle, leEventle type de déclencheur d'événement est contenu dans le contenu de retour.
{"Seq":1,"Event":"Exchange_GetTrades","ThreadId":0,"Index":3,"Nano":1682068771309583400}
objet
La boucle d'événement Le temps d'arrêt
Le paramètretimeoutest le paramètre de temps d'arrêt, en millisecondes.timeoutattend qu'un événement se produise avant de retourner s'il est défini sur 0, s'il est supérieur à 0, il définit l'événement en attendant un temps d'arrêt, et renvoie immédiatement l'événement le plus récent s'il est inférieur à 0.
Le temps mort
faux
Numéro
function main() {
var routine_getTicker = exchange.Go("GetTicker")
var routine_getDepth = exchange.Go("GetDepth")
var routine_getTrades = exchange.Go("GetTrades")
// Sleep(2000), if the Sleep statement is used here, it will cause the subsequent EventLoop function to miss the previous events, because after waiting for 2 seconds, the concurrent function has received the data, and the subsequent EventLoop listening mechanism started, it misses these events.
// These events will not be missed unless EventLoop(-1) is called at the beginning of the first line of code to first initialize the EventLoop's listening mechanism.
// Log("GetDepth:", routine_getDepth.wait()) If the wait function is called in advance to retrieve the result of a concurrent call to the GetDepth function, the event that the GetDepth function receives the result of the request will not be returned in the EventLoop function.
var ts1 = new Date().getTime()
var ret1 = EventLoop(0)
var ts2 = new Date().getTime()
var ret2 = EventLoop(0)
var ts3 = new Date().getTime()
var ret3 = EventLoop(0)
Log("The first concurrent task completed was:", _D(ts1), ret1)
Log("The second concurrent task completed was:", _D(ts2), ret2)
Log("The third concurrent task completed was:", _D(ts3), ret3)
Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())
}
import time
def main():
routine_getTicker = exchange.Go("GetTicker")
routine_getDepth = exchange.Go("GetDepth")
routine_getTrades = exchange.Go("GetTrades")
ts1 = time.time()
ret1 = EventLoop(0)
ts2 = time.time()
ret2 = EventLoop(0)
ts3 = time.time()
ret3 = EventLoop(0)
Log("The first concurrent task completed was:", _D(ts1), ret1)
Log("The second concurrent task completed was:", _D(ts2), ret2)
Log("The third concurrent task completed was:", _D(ts3), ret3)
Log("GetTicker:", routine_getTicker.wait())
Log("GetDepth:", routine_getDepth.wait())
Log("GetTrades:", routine_getTrades.wait())
void main() {
auto routine_getTicker = exchange.Go("GetTicker");
auto routine_getDepth = exchange.Go("GetDepth");
auto routine_getTrades = exchange.Go("GetTrades");
auto ts1 = Unix() * 1000;
auto ret1 = EventLoop(0);
auto ts2 = Unix() * 1000;
auto ret2 = EventLoop(0);
auto ts3 = Unix() * 1000;
auto ret3 = EventLoop(0);
Log("The first concurrent task completed was:", _D(ts1), ret1);
Log("The second concurrent task completed was:", _D(ts2), ret2);
Log("The third concurrent task completed was:", _D(ts3), ret3);
Ticker ticker;
Depth depth;
Trades trades;
routine_getTicker.wait(ticker);
routine_getDepth.wait(depth);
routine_getTrades.wait(trades);
Log("GetTicker:", ticker);
Log("GetDepth:", depth);
Log("GetTrades:", trades);
}
Le premier appel à laEventLoop()fonction dans le code initie le mécanisme pour cet événement écouté, et si le premierEventLoop()Le système sous-jacent enveloppe une structure de file d'attente qui cache un maximum de 500 callbacks d'événements.EventLoop()fonction n'est pas appelée à temps pour les retirer pendant l'exécution du programme, les appels ultérieurs d'événements en dehors du cache 500 seront perdus.EventLoop()fonction n'affectent pas la file d'attente de cache du système WebSocket sous-jacent ou les caches de fonctions simultanées telles queexchange.Go()Pour ces caches, il est toujours nécessaire d'utiliser les méthodes respectives pour récupérer les données.EventLoop()fonction pour les données qui ont été récupérées avant leEventLoop()Le but principal de l'analyse est deEventLoop()La fonction principale de la stratégie est d'informer la couche de stratégie que de nouvelles données réseau ont été reçues par le système sous-jacent.EventLoop()fonction renvoie un événement, passe juste à travers toutes les sources de données.exchange.Go()- Je vais essayer d'obtenir des données.EventLoop()La fonction supporte uniquement le trading en direct.
Écouter les événements dans le fil principal lorsqu'il est appelé depuis la fonction principalemain()Dans les stratégies écrites dans leJavaScriptLa langue, lethreading.Thread()fonction crée un thread, qui peut également être appelé dans la fonction d'exécution du thread
{@fun/Global/Dial Dial}, {@fun/Trade/exchange.Go exchange.Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
Le__Servefonction est utilisée pour créer le service Http, le service TCP et le service Websocket (basé sur le protocole Http).
Renvoie une chaîne qui enregistre l'adresse IP et le port du service créé.127.0.0.1:8088, [::]:8089.
une chaîne
__Serve (serveURI, traitement) __Service (serveURI, gestionnaire,... args)
LeserveURIparamètre est utilisé pour configurer le protocole, l'adresse IP, le port et d'autres paramètres de la liaison de service, tels quehttp://0.0.0.0:8088?gzip=true, c'est à dire,http://:8088?gzip=true.
serveURIréglage des paramètres tels quetcp://127.0.0.1:6666?tls=true; vous pouvez ajouter des certificats et des clés privées, commetls=true&cert_pem=xxxx&cert_key_pem=xxxx.serveURIparamètres, tels quehttp://127.0.0.1:6666?gzip=true; vous pouvez définir les paramètres de compression:gzip=true- Je ne sais pas.
LeserveURIparamètre est utilisé pour Https, tels quehttps://127.0.0.1:6666?tls=true&gzip=true; vous pouvez ajoutercert_pemetcert_key_pemles paramètres de chargement du certificat.serveURI
vrai
chaîne
LehandlerLe paramètre est utilisé pour passer dans la fonction de traitement du routage (protocole HTTP), la fonction de traitement des messages (protocole TCP) et la fonction de traitement du flux (Websocket).
La fonction de rappel passée par le paramètrehandlerpeut définir plusieurs paramètres, le premier paramètre étant l'objet ctx (objet contextuel).
le gestionnaire
vrai
fonction
Le paramètre réel de la fonction de rappel passé comme paramètrehandlerIl peut y avoir plusieurs paramètresarg, par exemple:
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
Les paramètres1, 2, 3Il est passé à l'appel__Serve()fonction correspondent aux paramètresa, b, cpassé dans la fonction de rappel.
arg faux chaîne, nombre, bool, objet, tableau, fonction, valeur nulle et autres types pris en charge par le système
function main() {
let httpServer = __Serve("http://:8088?gzip=true", function (ctx) {
Log("http connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
let path = ctx.path()
if (path == "/") {
ctx.write(JSON.stringify({
path: ctx.path(),
method: ctx.method(),
headers: ctx.headers(),
cookie: ctx.header("Cookie"),
remote: ctx.remoteAddr(),
query: ctx.rawQuery()
}))
} else if (path == "/tickers") {
let ret = exchange.GetTickers()
if (!ret) {
ctx.setStatus(500)
ctx.write(GetLastError())
} else {
ctx.write(JSON.stringify(ret))
}
} else if (path == "/wss") {
if (ctx.upgrade("websocket")) { // upgrade to websocket
while (true) {
let r = ctx.read(10)
if (r == "") {
break
} else if (r) {
if (r == "ticker") {
ctx.write(JSON.stringify(exchange.GetTicker()))
} else {
ctx.write("not support")
}
}
}
Log("websocket closed", ctx.remoteAddr())
}
} else {
ctx.setStatus(404)
}
})
let echoServer = __Serve("tcp://:8089", function (ctx) {
Log("tcp connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
while (true) {
let d = ctx.read()
if (!d) {
break
}
ctx.write(d)
}
Log("connect closed")
})
Log("http serve on", httpServer, "tcp serve on", echoServer)
for (var i = 0; i < 5; i++) {
if (i == 2) {
// test Http
var retHttp = HttpQuery("http://127.0.0.1:8088?num=123&limit=100", {"debug": true})
Log("retHttp:", retHttp)
} else if (i == 3) {
// test TCP
var tcpConn = Dial("tcp://127.0.0.1:8089")
tcpConn.write("Hello TCP Server")
var retTCP = tcpConn.read()
Log("retTCP:", retTCP)
} else if (i == 4) {
// test Websocket
var wsConn = Dial("ws://127.0.0.1:8088/wss|compress=gzip")
wsConn.write("ticker")
var retWS = wsConn.read(1000)
Log("retWS:", retWS)
// no depth
wsConn.write("depth")
retWS = wsConn.read(1000)
Log("retWS:", retWS)
}
Sleep(1000)
}
}
# Unsupported
// Unsupported
WebsocketVous pouvez définir une branche de routage dans le chemin et concevoir le code de mise en œuvre pourWebsocketVous pouvez consulter l'exemple de code dans cette section.La fonction de rappel passée par le paramètrehandlerIl reçoit unctxParamètre.ctxparamètre est un objet contextuel utilisé pour obtenir et écrire des données, avec les méthodes suivantes:
HTTP/1.1, tcp.http://127.0.0.1:8088?num=123, et la fonction de traitement de rappel passée par le paramètrehandlerrendements"123"quand?ctx.query("num")est appelé.User-Agentdans les titres de la demande en cours:ctx.header("User-Agent").GET, POST, etc.ctxobjet de contexte au protocole Websocket; renvoie une valeur booléenne (true) si le commutateur est réussi, et une valeur booléenne (fausse) si elle échoue.readCette méthode n'est pas prise en charge dans le protocole HTTP ordinaire.timeout_msen millisecondes.JSON.stringify()pour encoder l'objet JSON dans une chaîne de caractères et l'écrire.WebSocketprotocole, vous pouvez utiliser cette méthode pour passer la chaîne codée au client.{@fun/Global/HttpQuery HttpQuery}, {@fun/Global/HttpQuery_Go HttpQuery_Go} Vous pouvez utiliser le nom de domaine de l'utilisateur.
La structure de données est une table KV qui est sauvegardée en permanence dans le fichier de base de données locale du docker.
Les données de valeur de clé enregistrées en permanence dansk-vles paires de valeurs-clés.
chaîne, nombre, bool, objet, tableau, valeur nulle
Je ne sais pas. Je ne sais pas. - Je ne sais pas.
Le paramètrekest le nom de la clé dans la paire clé-valeur enregistrée et n'est pas sensible à la case.
K
faux
chaîne, valeur nulle
Le paramètrevest la valeur clé dans la paire clé-valeur enregistrée, qui peut être n'importe quelle donnée qui peut êtreJSONIl est en série.
v
faux
chaîne, nombre, bool, objet, tableau, valeur nulle
function main(){
// Set a global variable num with a value of 1
_G("num", 1)
// Change a global variable num to the value of the string ok
_G("num", "ok")
// Delete the global variable num
_G("num", null)
// Returns the value of the global variable num
Log(_G("num"))
// Delete all global variables
_G(null)
// Return to live trading ID
var robotId = _G()
}
def main():
_G("num", 1)
_G("num", "ok")
_G("num", None)
Log(_G("num"))
_G(None)
robotId = _G()
void main() {
_G("num", 1);
_G("num", "ok");
_G("num", NULL);
Log(_G("num"));
_G(NULL);
// Not support auto robotId = _G();
}
Une base de données distincte pour chaque transaction en direct, les données enregistrées par le_G()La fonction sera toujours présente si la stratégie est redémarrée ou si le docker cesse de fonctionner._G()Lorsque vous utilisez le_G()fonction de conserver les données enregistrées, il doit être utilisé de manière raisonnable en fonction de la mémoire et de l'espace disque dur du périphérique matériel, et ne doit pas être abusé.
Lorsque vous appelez le_G()Les paramètres sont passés dans le cadre d'une fonction de trading en direct et aucun paramètre n'est passé, le_G()Retourne leIdLes échanges en direct actuels._G()fonction, le paramètrevest passé comme nul pour indiquer la suppression de lak-vLorsque vous appelez le_G()fonction, seulement le paramètrekest passé dans la chaîne, et le_G()fonction renvoie la valeur de clé correspondant au paramètre enregistrékLorsque vous appelez le_G()fonction, seulement le paramètrekest passé en valeur nulle, indiquant que tous les enregistrements de lak-vLorsque la clé-valeur est supprimée,k-vles paires de clés-valeurs ont été sauvegardées de façon persistante,_G()la fonction est appelée à nouveau, en passant le nom de la clé qui a été sauvegardée de manière persistante comme paramètrek. Passer la nouvelle valeur de clé comme paramètrevJe vais le mettre à jour.k-vune paire clé-valeur.
Je ne sais pas.
Convertisse les horodatages en millisecondes ouDateobjets à des chaînes de temps.
Une chaîne temporelle. chaîne
Je suis désolé. _D (heure) _D (horodatage, fmt)
Marque d'heure en millisecondes ouDateJe suis un objet.
l' étiquette
faux
Numéro, objet
Format de la chaîne,JavaScriptFormat par défaut de la langue:yyyy-MM-dd hh:mm:ss; PythonFormat par défaut de la langue:%Y-%m-%d %H:%M:%S; C++Format par défaut de la langue:%Y-%m-%d %H:%M:%S- Je ne sais pas.
fmt
faux
chaîne
function main(){
var time = _D()
Log(time)
}
def main():
strTime = _D()
Log(strTime)
void main() {
auto strTime = _D();
Log(strTime);
}
Obtenez et imprimez la chaîne de temps courante:
function main() {
Log(_D(1574993606000))
}
def main():
# Running this code on a server in Beijing time: 2019-11-29 10:13:26 , a docker on another server in another region results in: 2019-11-29 02:13:26
Log(_D(1574993606))
void main() {
Log(_D(1574993606000));
}
L'horodatage est 1574993606000, en utilisant le code de conversion:
function main() {
Log(_D(1574993606000, "yyyy--MM--dd hh--mm--ss")) // 2019--11--29 10--13--26
}
def main():
# 1574993606 is timestamped in seconds.
Log(_D(1574993606, "%Y--%m--%d %H--%M--%S")) # 2019--11--29 10--13--26
void main() {
Log(_D(1574993606000, "%Y--%m--%d %H--%M--%S")); // 2019--11--29 10--13--26
}
Formatage avec le paramètrefmtest différente pourJavaScript, Python, etC++les langues, comme indiqué dans les exemples suivants:
Retourne la chaîne de temps en cours sans passer de paramètres._D()fonction dans lePythonDans le cas d'une stratégie, vous devez être conscient que les paramètres passés sont des horodatages de deuxième niveau (horodatages de niveau milliseconde dans les stratégies JavaScript et C++, où 1 seconde équivaut à 1000 millisecondes)._D()fonction pour analyser une chaîne d'heure avec un horodatage lisible dans le commerce en direct, vous devez faire attention au fuseau horaire et le réglage de l'heure du système d'exploitation où le programme docker est situé._D()fonction analyse un horodatage dans une chaîne de temps lisible en fonction de l'heure du système docker
Je ne sais pas si je peux vous aider.
Formater un numéro en virgule flottante.
Le numéro en virgule flottante formaté selon le réglage de précision. Numéro
_N() Nombre _N (numéro, précision)
Le numéro à virgule flottante à formater.
Numéro
vrai
Numéro
Le paramètre de précision de mise en formeprecisionest un entier, et le paramètreprecisionpar défaut à 4.
précision
faux
Numéro
function main(){
var i = 3.1415
Log(i)
var ii = _N(i, 2)
Log(ii)
}
def main():
i = 3.1415
Log(i)
ii = _N(i, 2)
Log(ii)
void main() {
auto i = 3.1415;
Log(i);
auto ii = _N(i, 2);
Log(ii);
}
Par exemple,_N(3.1415, 2)supprimera la valeur après3.1415deux décimales et la fonction renvoie3.14.
function main(){
var i = 1300
Log(i)
var ii = _N(i, -3)
// Check the logs and see that it is 1000
Log(ii)
}
def main():
i = 1300
Log(i)
ii = _N(i, -3)
Log(ii)
void main() {
auto i = 1300;
Log(i);
auto ii = _N(i, -3);
Log(ii);
}
Si vous avez besoin de changer tous les N chiffres à gauche de la virgule à 0, vous pouvez l'écrire comme ceci:
Le paramètreprecisionpeut être un entier positif, un entier négatif.
{@fun/Trade/exchange.SetPrecision échange.SetPrecision} Je suis désolé
Réessayez la fonction de tolérance à la défaillance de l'interface.
La valeur de retour de la fonction de rappel lorsqu'elle est exécutée. Tous les types sont pris en charge par le système saufvaleur logique fausseetvaleur nulle.
Je ne sais pas. Je ne sais pas.
Le paramètrepfnest une référence de fonction, qui est unefonction de rappel- Je ne sais pas.
pfn
vrai
fonction
Paramètres àles fonctions de rappel, il peut y avoir plusieurs paramètresarg. Le type et le nombre de paramètresargdépend des paramètres dufonction de rappelJe suis désolée.
arg
faux
chaîne, nombre, bool, objet, tableau, fonction, tous les types sont pris en charge par le système, tels que les valeurs nulles
function main(){
var ticker = _C(exchange.GetTicker)
// Adjust _C() function retry interval to 2 seconds
_CDelay(2000)
var depth = _C(exchange.GetDepth)
Log(ticker)
Log(depth)
}
def main():
ticker = _C(exchange.GetTicker)
_CDelay(2000)
depth = _C(exchange.GetDepth)
Log(ticker)
Log(depth)
void main() {
auto ticker = _C(exchange.GetTicker);
_CDelay(2000);
auto depth = _C(exchange.GetDepth);
Log(ticker);
Log(depth);
}
Pour les fonctions de tolérance à l'erreur sans paramètres:
function main(){
var records = _C(exchange.GetRecords, PERIOD_D1)
Log(records)
}
def main():
records = _C(exchange.GetRecords, PERIOD_D1)
Log(records)
void main() {
auto records = _C(exchange.GetRecords, PERIOD_D1);
Log(records);
}
Pour les fonctions dont les paramètres sont tolérants aux erreurs:
var test = function(a, b){
var time = new Date().getTime() / 1000
if(time % b == 3){
Log("Eligible!", "#FF0000")
return true
}
Log("Retry!", "#FF0000")
return false
}
function main(){
var ret = _C(test, 1, 5)
Log(ret)
}
import time
def test(a, b):
ts = time.time()
if ts % b == 3:
Log("Eligible!", "#FF0000")
return True
Log("Retry!", "#FF0000")
return False
def main():
ret = _C(test, 1, 5)
Log(ret)
// C++ does not support fault tolerance for custom functions in this way
Il peut également être utilisé pour la tolérance aux pannes des fonctions personnalisées:
Le_C()fonction continuera à appeler la fonction spécifiée jusqu'à ce qu'elle renvoie avec succès (la fonction référencée par le paramètrepfnrendementsNuloufauxQuand il est appelé, il recommence à appelerpfnPar exemple:_C(exchange.GetTicker). L'intervalle de réessayer par défaut est de 3 secondes, vous pouvez appeler le_CDelay()fonction pour régler l'intervalle de réessayage._CDelay(1000)Les moyens de modifier l'intervalle de réessayage du_C()fonction à 1 seconde.
La tolérance à la défaillance peut être effectuée pour, mais sans s'y limiter, les fonctions suivantes:
exchange.GetTicker()exchange.GetDepth()exchange.GetTrades()exchange.GetRecords()exchange.GetAccount()exchange.GetOrders()exchange.GetOrder()exchange.GetPositions()Tous peuvent être appelés par le_C()La fonction de tolérance aux défauts_C()la fonction n'est pas limitée à la fonction de tolérance à la défaillance énumérée ci-dessus, le paramètrepfnest une référence de fonction plutôt qu'un appel de fonction.
Notez qu'il est_C(exchange.GetTicker), pas_C(exchange.GetTicker()).Renvoie le nombre de périodes d'intersection du tableauarr1et le tableauarr2.
Le nombre de périodes transversales du tableauarr1et le tableauarr2- Je ne sais pas.
Numéro
_Cross ((arr1, arr2)
Les éléments sont des tableaux de typenumber- Je ne sais pas.
Arr1
vrai
séquence
Les éléments sont des tableaux de typenumber- Je ne sais pas.
Arr2
vrai
séquence
// Fast line indicator
var arr1 = [1,2,3,4,5,6,8,8,9]
// Slow line indicator
var arr2 = [2,3,4,5,6,7,7,7,7]
function main(){
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
}
arr1 = [1,2,3,4,5,6,8,8,9]
arr2 = [2,3,4,5,6,7,7,7,7]
def main():
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
void main() {
vector<double> arr1 = {1,2,3,4,5,6,8,8,9};
vector<double> arr2 = {2,3,4,5,6,7,7,7,7};
Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2));
Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1));
}
Un ensemble de données peut être simulé pour tester la fonction _Cross ((Arr1, Arr2):
Si la valeur de retour du_Cross()Si la fonction est un nombre positif, elle indique la période de pénétration ascendante, si elle est un nombre négatif, elle indique la période de pénétration descendante, 0 signifie la même chose que le prix actuel.Analyse et instructions d'utilisation concernant la fonction intégrée.
La fonctionJSONParse()est utilisé pour analyserJSON strings.
JSONJe suis un objet.
objet
JSONParse (s)
JSONUne corde.
s
vrai
chaîne
function main() {
let s1 = '{"num": 8754613216564987646512354656874651651358}'
Log("JSON.parse:", JSON.parse(s1)) // JSON.parse: {"num":8.754613216564988e+39}
Log("JSONParse:", JSONParse(s1)) // JSONParse: {"num":"8754613216564987646512354656874651651358"}
let s2 = '{"num": 123}'
Log("JSON.parse:", JSON.parse(s2)) // JSON.parse: {"num":123}
Log("JSONParse:", JSONParse(s2)) // JSONParse: {"num":123}
}
import json
def main():
s1 = '{"num": 8754613216564987646512354656874651651358}'
Log("json.loads:", json.loads(s1)) # json.loads: map[num:8.754613216564987e+39]
Log("JSONParse:", JSONParse(s1)) # JSONParse: map[num:8754613216564987646512354656874651651358]
s2 = '{"num": 123}'
Log("json.loads:", json.loads(s2)) # json.loads: map[num:123]
Log("JSONParse:", JSONParse(s2)) # JSONParse: map[num:123]
void main() {
auto s1 = "{\"num\":8754613216564987646512354656874651651358}";
Log("json::parse:", json::parse(s1));
// Log("JSONParse:", JSONParse(s1)); // The function is not supported.
auto s2 = "{\"num\":123}";
Log("json::parse:", json::parse(s2));
// Log("JSONParse:", JSONParse(s2)); // The function is not supported.
}
Les chaînes JSON avec de grandes valeurs peuvent être analysées correctement, et il analysera de grandes valeurs comme des types de chaînes.JSONParse()fonction n'est pas prise en charge dans le système de backtest.
Les journaux de sortie.
Je ne sais pas.
Le paramètremsgest le contenu de la sortie et le paramètremsgpeut être passé plus d'une fois.
Message à envoyer
faux
chaîne, nombre, bool, objet, tableau, tout type pris en charge par le système tel que nul.
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
Plusieursmsgles paramètres peuvent être passés:
function main() {
Log("Hello, FMZ Quant!@")
Sleep(1000 * 5)
// Add #ff0000 to the string to print the log in red and push the message
Log("Hello, #ff0000@")
}
def main():
Log("Hello, FMZ Quant!@")
Sleep(1000 * 5)
Log("Hello, #ff0000@")
void main() {
Log("Hello, FMZ Quant!@");
Sleep(1000 * 5);
Log("Hello, #ff0000@");
}
Il prend en charge la définition de la couleur du message de sortie, si nous utilisons la définition de la couleur et pousser en même temps, nous devons définir la couleur d'abord et utiliser@Le personnage doit être le dernier à pousser.
function main() {
Log("`data:image/png;base64,AAAA`")
}
def main():
Log("`data:image/png;base64,AAAA`")
void main() {
Log("`data:image/png;base64,AAAA`");
}
LeLog()Fonction de support d'impressionbase64les images codées, à commencer par`et se termine par`, par exemple:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
LeLog()La fonction supporte l'impression directe dePythonC' est...matplotlib.pyplotl'objet. Tant que l'objet contient lesavefigIl peut être imprimé directement à l'aide de laLogfonction, par exemple:
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
LeLog()La fonction supporte le changement de langue.Log()fonction produit du texte qui passe automatiquement à la langue correspondante en fonction du réglage de la langue sur la page de la plateforme, par exemple:
LeLog()La fonction produit un message de journal dans la zone de journal du système de négociation en direct ou de backtesting, et le journal est enregistré dans la base de données de négociation en direct lorsque la négociation en direct est en cours.Log()fonction produit un message de journal se terminant par le@Push à l'adresse e-mail, l'adresse WebHook, etc. configuré dans leAppuyez sur ParamètresLe transfert de messages n'est pas pris en charge parOutils de débogageLes règles de restriction spécifiques sont les suivantes: dans un cycle de 20 secondes d'une transaction en direct, seul le dernier message de push sera conservé et poussé, et les autres messages seront filtrés et non poussés (la sortie du journal de push par la fonction Log sera imprimée et affichée normalement dans la zone du journal).
PourWebHookPoussez, vous pouvez utiliser le programme de service écrit parGolang:
package main
import (
"fmt"
"net/http"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
RéglageWebHookdansAppuyez sur Paramètres: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ- Je ne sais pas.
Après avoir exécuté le texteGolangprogramme de service, nous commençons à exécuter la stratégie de trading en direct, ce qui suit est la stratégie écrite dansJavaScriptLa stratégie est basée sur l'exécution desLog()fonction et poussant le message:
function main() {
Log("msg", "@")
}
Un programme de service écrit dans leGolangle langage reçoit la commande et le programme de service imprime le message:
listen http://localhost:9090
req: {GET /data?data=Hello_FMZ HTTP/1.1 1 1 map[User-Agent:[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/xx.x.xxxx.xxx Safari/537.36] Accept-Encoding:[gzip]] {} <nil> 0 [] false 1XX.XX.X.XX:9090 map[] map[] <nil> map[] XXX.XX.XXX.XX:4xxx2 /data?data=Hello_FMZ <nil> <nil> <nil> 0xc420056300
{@fun/Log/LogReset LogReset}, {@fun/Log/LogVacuum LogVacuum} Je suis désolé
Enregistrez la valeur des profits et pertes, imprimez la valeur des profits et pertes et tracez la courbe de rendement sur la base de la valeur des profits et pertes.
LogProfit (profits) LogProfit ((profits,... arguments)
Le paramètreprofitest les données sur les recettes, qui sont données par l'algorithme de conception et le calcul de la stratégie.
le bénéfice
vrai
Numéro
Paramètre étendu permettant de produire des informations accessoires au journal des recettes,argLes paramètres peuvent être passés à plus d'un.
arg
faux
chaîne, nombre, bool, objet, tableau, tout type pris en charge par le système tel que nul.
function main() {
// Print 30 points on the earnings chart
for(var i = 0; i < 30; i++) {
LogProfit(i, '&')
Sleep(500)
}
}
def main():
for i in range(30):
LogProfit(i, '&')
Sleep(500)
void main() {
for(int i = 0; i < 30; i++) {
LogProfit(i, '&');
Sleep(500);
}
}
LeLogProfitfonction, si elle se termine par le caractère&, ne trace que le tableau des recettes et n'imprime pas le journal des recettes.
{@fun/Log/LogProfitReset LogProfitReset} Je ne peux pas le faire.
Effacez tous les journaux de revenus, les tableaux de revenus.
LogProfitReset (en anglais seulement) LogProfitReset (restez)
Leremainparamètre est utilisé pour spécifier le nombre d'entrées de journal (valeur entière) à conserver.
rester
faux
Numéro
function main() {
// Print 30 points on the revenue chart, then reset and keep only the last 10 points
for(var i = 0; i < 30; i++) {
LogProfit(i)
Sleep(500)
}
LogProfitReset(10)
}
def main():
for i in range(30):
LogProfit(i)
Sleep(500)
LogProfitReset(10)
void main() {
for(int i = 0; i < 30; i++) {
LogProfit(i);
Sleep(500);
}
LogProfitReset(10);
}
Je ne sais pas.
Informations de sortie dans la barre d'état du système de backtesting ou de la page de trading en direct.
LogStatus (en anglais)
Le paramètremsgest le contenu de la sortie et le paramètremsgpeut être passé plus d'une fois.
Message à envoyer
faux
chaîne, nombre, bool, objet, tableau, tout type pris en charge par le système tel que nul.
function main() {
LogStatus('This is a general status alert')
LogStatus('This is a status alert in red font #ff0000')
LogStatus('This is a multi-line status message \n I am the second line')
}
def main():
LogStatus('This is a general status alert')
LogStatus('This is a status alert in red font #ff0000')
LogStatus('This is a multi-line status message \n I am the second line')
void main() {
LogStatus("This is a general status alert");
LogStatus("This is a status alert in red font #ff0000");
LogStatus("This is a multi-line status message \n I am the second line");
}
Il prend en charge la définition de la couleur du contenu de sortie:
function main() {
var table = {type: 'table', title: 'Position information', cols: ['Column 1', 'Column 2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
// JSON serialization with the ` character on both sides, as a complex message format (support tables currently)
LogStatus('`' + JSON.stringify(table) + '`')
// Table information can also appear in multiple rows
LogStatus('First line of message\n`' + JSON.stringify(table) + '`\n third line of message')
// It supports multiple tables at the same time, will be displayed in a group with TAB
LogStatus('`' + JSON.stringify([table, table]) + '`')
// You can also construct a button in the form, and use the GetCommand strategy to receive the contents of the cmd attribute
var table = {
type: 'table',
title: 'Position operations',
cols: ['Column 1', 'Column 2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'Close out positions'}]
]
}
LogStatus('`' + JSON.stringify(table) + '`')
// Or construct a separate button
LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': 'Close out positions'}) + '`')
// Customizable button style (bootstrap's button attribute)
LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': 'Close out positions'}) + '`')
}
import json
def main():
table = {"type": "table", "title": "Position information", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('First line of message\n`' + json.dumps(table) + '`\n third line of message')
LogStatus('`' + json.dumps([table, table]) + '`')
table = {
"type" : "table",
"title" : "Position operations",
"cols" : ["Column 1", "Column 2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close out positions"}]
]
}
LogStatus('`' + json.dumps(table) + '`')
LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "Close out positions"}) + '`')
LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close out positions"}) + '`')
void main() {
json table = R"({"type": "table", "title": "Position information", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("First line of message\n`" + table.dump() + "`\n third line of message");
json arr = R"([])"_json;
arr.push_back(table);
arr.push_back(table);
LogStatus("`" + arr.dump() + "`");
table = R"({
"type" : "table",
"title" : "Position operations",
"cols" : ["Column 1", "Column 2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close out positions"}]
]
})"_json;
LogStatus("`" + table.dump() + "`");
LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "Close out positions"})"_json.dump() + "`");
LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close out positions"})"_json.dump() + "`");
}
Exemple de sortie de données dans la barre d'état:
function main() {
var table = {
type: "table",
title: "status bar button style",
cols: ["default", "original", "success", "info", "warning", "danger"],
rows: [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
}
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "status bar button style",
"cols": ["default", "original", "success", "info", "warning", "danger"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
}
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "status bar button style",
"cols": ["default", "original", "success", "info", "warning", "danger"],
"rows": [
[
{"type":"button", "class": "btn btn-xs btn-default", "name": "default"},
{"type":"button", "class": "btn btn-xs btn-primary", "name": "original"},
{"type":"button", "class": "btn btn-xs btn-success", "name": "success"},
{"type":"button", "class": "btn btn-xs btn-info", "name": "info"},
{"type":"button", "class": "btn btn-xs btn-warning", "name": "warning"},
{"type":"button", "class": "btn btn-xs btn-danger", "name": "danger"}
]
]
})"_json;
LogStatus("`" + table.dump() + "`");
}
Il prend en charge la conception de commandes de boutons dans la barre d'état (ancienne structure de boutons):
function main() {
var table = {
type: "table",
title: "Status bar button disable, description function test",
cols: ["Column 1", "Column 2", "Column 3"],
rows: []
}
var button1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"}
var button2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true}
var button3 = {"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": false}
table.rows.push([button1, button2, button3])
LogStatus("`" + JSON.stringify(table) + "`")
}
import json
def main():
table = {
"type": "table",
"title": "Status bar button disable, description function test",
"cols": ["Column 1", "Column 2", "Column 3"],
"rows": []
}
button1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"}
button2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": True}
button3 = {"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": False}
table["rows"].append([button1, button2, button3])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type": "table",
"title": "Status bar button disable, description function test",
"cols": ["Column 1", "Column 2", "Column 3"],
"rows": []
})"_json;
json button1 = R"({"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button"})"_json;
json button2 = R"({"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true})"_json;
json button3 = R"({"type": "button", "name": "button3", "cmd": "button3", "description": "This is the third button, set to enable", "disabled": false})"_json;
json arr = R"([])"_json;
arr.push_back(button1);
arr.push_back(button2);
arr.push_back(button3);
table["rows"].push_back(arr);
LogStatus("`" + table.dump() + "`");
}
Définir la fonction de description désactivée du bouton de la barre d'état (ancienne structure de bouton):
function test1() {
Log("Calling custom functions")
}
function main() {
while (true) {
var table = {
type: 'table',
title: 'operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['a', '1', {
'type': 'button',
'cmd': "CoverAll",
'name': 'Close out positions'
}],
['b', '1', {
'type': 'button',
'cmd': 10,
'name': 'Send values'
}],
['c', '1', {
'type': 'button',
'cmd': _D(),
'name': 'Calling functions'
}],
['d', '1', {
'type': 'button',
'cmd': 'test1',
'name': 'Calling custom functions'
}]
]
}
LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')
var str_cmd = GetCommand()
if (str_cmd) {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if(str_cmd == "test1") {
test1()
}
}
Sleep(500)
}
}
import json
def test1():
Log("Calling custom functions")
def main():
while True:
table = {
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": _D(),
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
str_cmd = GetCommand()
if str_cmd:
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if str_cmd == "test1":
test1()
Sleep(500)
void test1() {
Log("Calling custom functions");
}
void main() {
while(true) {
json table = R"({
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": "",
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
})"_json;
table["rows"][2][2]["cmd"] = _D();
LogStatus(_D(), "\n", "`" + table.dump() + "`");
auto str_cmd = GetCommand();
if(str_cmd != "") {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd);
if(str_cmd == "test1") {
test1();
}
}
Sleep(500);
}
}
En combinaison avec leGetCommand()fonction, construire la fonction d'interaction du bouton de la barre d'état (ancienne structure de bouton):
function main() {
var tbl = {
type: "table",
title: "operation",
cols: ["column1", "column2"],
rows: [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
while (true) {
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(1000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "operation",
"cols": ["column1", "column2"],
"rows": [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
while True:
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(1000)
void main() {
json tbl = R"({
"type": "table",
"title": "operation",
"cols": ["column1", "column2"],
"rows": [
["Open position operation", {"type": "button", "cmd": "open", "name": "open position", "input": {"name": "number of open positions", "type": "number", "defValue": 1}}],
["Close position operation", {"type": "button", "cmd": "coverAll", "name": "close all positions"}]
]
})"_json;
LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
while(true) {
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(1000);
}
}
Les données d'entrée sont également prises en charge lors de la construction de boutons de barre d'état pour l'interaction, et les commandes d'interaction sont capturées par leGetCommand()Il y a une fonction qui fonctionne.inputles éléments (ancienne structure de bouton) à la structure de données de la commande de bouton dans la barre d'état, par exemple en ajoutant"input": {"name": "number of open positions", "type": "number", "defValue": 1}à{"type": "button", "cmd": "open", "name": "open position"}provoquera l'apparition d'une fenêtre contextuelle avec un contrôle de boîte d'entrée lorsque le bouton est cliqué (la valeur par défaut dans la boîte d'entrée est 1, qui est les données définies pardefValueVous pouvez entrer des données à envoyer avec la commande de bouton. Par exemple, lorsque le code de test suivant s'exécute, après avoir cliqué sur le bouton "open positionGetCommand()la fonction va alors capturer le message:open:111.
function main() {
var tbl = {
type: "table",
title: "Demonstrate grouping button control",
cols: ["operation"],
rows: []
}
// Creating a grouping button control structure
var groupBtn = {
type: "button",
cmd: "open",
name: "open positions",
group: [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": true}
]
}
// test button 1
var testBtn1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."}
var testBtn2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}}
// Add groupBtn to tbl
tbl.rows.push([groupBtn])
// It supports multiple buttons in a cell of a status bar table, i.e. the data in a cell is an array of button structures: [testBtn1, testBtn2].
tbl.rows.push([[testBtn1, testBtn2]])
while (true) {
LogStatus("`" + JSON.stringify(tbl) + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + JSON.stringify(groupBtn) + "`")
var cmd = GetCommand()
if (cmd) {
Log("cmd:", cmd)
}
Sleep(5000)
}
}
import json
def main():
tbl = {
"type": "table",
"title": "Demonstrate grouping button control",
"cols": ["operation"],
"rows": []
}
groupBtn = {
"type": "button",
"cmd": "open",
"name": "open positions",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": True}
]
}
testBtn1 = {"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."}
testBtn2 = {"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}}
tbl["rows"].append([groupBtn])
tbl["rows"].append([[testBtn1, testBtn2]])
while True:
LogStatus("`" + json.dumps(tbl) + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + json.dumps(groupBtn) + "`")
cmd = GetCommand()
if cmd:
Log("cmd:", cmd)
Sleep(5000)
void main() {
json tbl = R"({
"type": "table",
"title": "Demonstrate grouping button control",
"cols": ["operation"],
"rows": []
})"_json;
json groupBtn = R"({
"type": "button",
"name": "open positions",
"cmd": "open",
"group": [
{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "market order|pending order"},
{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
{"name": "boolean", "description": "yes/no|boolean", "type": "boolean", "defValue": true}
]})"_json;
json testBtn1 = R"({"type": "button", "name": "button1", "cmd": "button1", "description": "This is the first button."})"_json;
json testBtn2 = R"({"type": "button", "name": "button2", "cmd": "button2", "description": "This is the second button.", "input": {"name": "number of positions opened", "type": "number", "defValue": 1}})"_json;
tbl["rows"].push_back({groupBtn});
tbl["rows"].push_back({{testBtn1, testBtn2}});
while(true) {
LogStatus("`" + tbl.dump() + "`", "\n", "The grouping button control can also be set directly on the status bar in addition to being set on the status bar form:", "`" + groupBtn.dump() + "`");
auto cmd = GetCommand();
if(cmd != "") {
Log("cmd:", cmd);
}
Sleep(5000);
}
}
Il prend en charge les commandes de boutons regroupés (vieille structure de boutons), fonctionnellement compatibles avecLes boutons de la barre d'état qui prennent en charge la saisie de donnéesLes commandes interactives sont finalement capturées par leGetCommand()La différence est qu'avec le"group"paramétrage de champ, lorsque le bouton est cliqué pour déclencher l'interaction, la boîte de dialogue qui apparaît sur la page contient un ensemble degroupedes contrôles d'entrée configurés pour entrer un groupe de données à la fois.
Quelques points à noter sur le"group"champ dans la structure du bouton de commande de la barre d'état et du bouton de groupe:
typeLes propriétés en groupe ne prennent en charge que les quatre types suivants, etdefValueproperty est la valeur par défaut.
|symbole pour séparer chaque option dans une liste déroulante telle qu'elle est définie.
"name": "tradePrice@orderType==1"La mise en place, qui rend leCommerce Prixcontrôle d'entrée disponible uniquement lorsque leordreTypesla commande déroulante est sélectionnéeOrdonnance en attente.|des symboles pour séparer le contenu de la description en chinois et en anglais.name, descriptionen groupe etname, descriptiondans la structure des boutons n'ont pas les mêmes définitions même si elles ont les mêmes noms de champ.
La définition denameLa définition de "groupe" est également différente de celle de "groupe".namedans l'entrée.Log("cmd:", cmd)Déclaration dans l'exemple suivant:cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, c'est-à-dire ce qui est retourné par leGetCommand()fonction lorsqu'une interaction se produit:open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.typela propriété du bouton de commande prend en charge uniquement:"button"Je suis désolée.
Les commandes à bouton qui prennent en charge les données d'entrée, c'est-à-dire les commandes avec leinputl'ensemble des propriétés,typepropriété dans les informations de configuration de lainputle champ prend en charge plusieurs types de contrôle.
Consultez les exemples suivants:function main() {
// Status bar button control (set input field to implement) testBtn1 button triggered by the page in the drop-down box control using the options field to set options, using the defValue field to set the default options. This is different from the other examples in this chapter, which use defValue to set the options directly.
var testBtn1 = {
type: "button",
name: "testBtn1",
cmd: "cmdTestBtn1",
input: {name: "testBtn1ComboBox", type: "selected", options: ["A", "B"], defValue: 1}
}
/*
Status bar button control (set input field implementation) testBtn2 button triggered by the page in the drop-down box control using the options field to set the options, options field in the options field not only supports the string,
the use of the ```{text: "description", value: "value"}``` structure is also supported. Use the defValue field to set the default option, which can be multiple choice (multiple choice via array structure). Multiple choice requires setting the additional field multiple to a true value.
*/
var testBtn2 = {
type: "button",
name: "testBtn2",
cmd: "cmdTestBtn2",
input: {
name: "testBtn2MultiComboBox",
type: "selected",
description: "Implementing dropdown box multi-selection",
options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}],
defValue: ["A", "C"],
multiple: true
}
}
// Status bar grouping button control (set group field implementation) testBtn3 button triggered by the page in the drop-down box control using the options field to set options, also supports the direct use of defValue set options.
var testBtn3 = {
type: "button",
name: "testBtn3",
cmd: "cmdTestBtn3",
group: [
{name: "comboBox1", label: "labelComboBox1", description: "Dropdown box 1", type: "selected", defValue: 1, options: ["A", "B"]},
{name: "comboBox2", label: "labelComboBox2", description: "Dropdown box 2", type: "selected", defValue: "A|B"},
{name: "comboBox3", label: "labelComboBox3", description: "Dropdown box 3", type: "selected", defValue: [0, 2], multiple: true, options: ["A", "B", "C"]},
{
name: "comboBox4",
label: "labelComboBox4",
description: "Dropdown box 4",
type: "selected",
defValue: ["A", "C"],
multiple: true,
options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}, {text: "Option D", value: "D"}]
}
]
}
while (true) {
LogStatus("`" + JSON.stringify(testBtn1) + "`\n", "`" + JSON.stringify(testBtn2) + "`\n", "`" + JSON.stringify(testBtn3) + "`\n")
var cmd = GetCommand()
if (cmd) {
Log(cmd)
}
Sleep(5000)
}
}
import json
def main():
testBtn1 = {
"type": "button",
"name": "testBtn1",
"cmd": "cmdTestBtn1",
"input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
}
testBtn2 = {
"type": "button",
"name": "testBtn2",
"cmd": "cmdTestBtn2",
"input": {
"name": "testBtn2MultiComboBox",
"type": "selected",
"description": "Implementing dropdown box multi-selection",
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": True
}
}
testBtn3 = {
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown box 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown box 2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown box 3", "type": "selected", "defValue": [0, 2], "multiple": True, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "Dropdown box 4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": True,
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option D", "value": "D"}]
}
]
}
while True:
LogStatus("`" + json.dumps(testBtn1) + "`\n", "`" + json.dumps(testBtn2) + "`\n", "`" + json.dumps(testBtn3) + "`\n")
cmd = GetCommand()
if cmd:
Log(cmd)
Sleep(5000)
void main() {
json testBtn1 = R"({
"type": "button",
"name": "testBtn1",
"cmd": "cmdTestBtn1",
"input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
})"_json;
json testBtn2 = R"({
"type": "button",
"name": "testBtn2",
"cmd": "cmdTestBtn2",
"input": {
"name": "testBtn2MultiComboBox",
"type": "selected",
"description": "Implementing dropdown box multi-selection",
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
"defValue": ["A", "C"],
"multiple": true
}
})"_json;
json testBtn3 = R"({
"type": "button",
"name": "testBtn3",
"cmd": "cmdTestBtn3",
"group": [
{"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown box 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
{"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown box 2", "type": "selected", "defValue": "A|B"},
{"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown box 3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},
{
"name": "comboBox4",
"label": "labelComboBox4",
"description": "Dropdown box 4",
"type": "selected",
"defValue": ["A", "C"],
"multiple": true,
"options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option D", "value": "D"}]
}
]
})"_json;
while (true) {
LogStatus("`" + testBtn1.dump() + "`\n", "`" + testBtn2.dump() + "`\n", "`" + testBtn3.dump() + "`\n");
auto cmd = GetCommand();
if (cmd != "") {
Log(cmd);
}
Sleep(5000);
}
}
Lorsque le bouton de contrôle de groupe de la barre d'état (implémenté en réglant legroupLe champ de commande de la barre d'état (implémenté en réglant leinputL'exemple suivant démontre comment concevoir un contrôle de boîte déroulante avec plusieurs options de sélection:
var symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]
function createBtn(tmp, group) {
var btn = JSON.parse(JSON.stringify(tmp))
_.each(group, function(eleByGroup) {
btn["group"].unshift(eleByGroup)
})
return btn
}
function main() {
var arrManager = []
_.each(symbols, function(symbol) {
arrManager.push({
"symbol": symbol,
})
})
// Btn
var tmpBtnOpen = {
"type": "button",
"cmd": "open",
"name": "Open a position and place an order",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "Order type",
"description": "Market order, limit order",
"default": 0,
"group": "Trading setup",
"settings": {
"options": ["Market order", "Limit order"],
"required": true,
}
}, {
"type": "selected",
"name": "direction",
"label": "Trading direction",
"description": "Buy, sell",
"default": "buy",
"group": "Trading setup",
"settings": {
"render": "segment",
"required": true,
"options": [{"name": "buy", "value": "buy"}, {"name": "sell", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "price",
"description": "The price of the order",
"group": "Trading setup",
"filter": "tradeType==1",
"settings": {
"required": true,
}
}, {
"type": "number",
"name": "amount",
"label": "Order quantity",
"description": "Order quantity",
"group": "Trading setup",
"settings": {
"required": true,
}
}],
}
while (true) {
var tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
_.each(arrManager, function(m) {
var btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "Trading instruments", "default": m["symbol"], "settings": {"required": true}}])
tbl["rows"].push([m["symbol"], btnOpen])
})
var cmd = GetCommand()
if (cmd) {
Log("Receive interaction:", cmd)
// Parsing interaction messages: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
// According to the first colon: the previous instruction determines which button template triggers the message
var arrCmd = cmd.split(":", 2)
if (arrCmd[0] == "open") {
var msg = JSON.parse(cmd.slice(5))
Log("Trading instruments:", msg["symbol"], ", Trading direction:", msg["direction"], ", Order type:", msg["tradeType"] == 0 ? "Market order" : "Limit order", msg["tradeType"] == 0 ? ", Order price: current market price" : ", Order price:" + msg["price"], ", Order quantity:", msg["amount"])
}
}
LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(1000)
}
}
import json
symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]
def createBtn(tmp, group):
btn = json.loads(json.dumps(tmp))
for eleByGroup in group:
btn["group"].insert(0, eleByGroup)
return btn
def main():
arrManager = []
for symbol in symbols:
arrManager.append({"symbol": symbol})
# Btn
tmpBtnOpen = {
"type": "button",
"cmd": "open",
"name": "Open a position and place an order",
"group": [{
"type": "selected",
"name": "tradeType",
"label": "Order type",
"description": "Market order, limit order",
"default": 0,
"group": "Trading setup",
"settings": {
"options": ["Market order", "Limit order"],
"required": True,
}
}, {
"type": "selected",
"name": "direction",
"label": "Trading direction",
"description": "Buy, sell",
"default": "buy",
"group": "Trading Setup",
"settings": {
"render": "segment",
"required": True,
"options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
}
}, {
"type": "number",
"name": "price",
"label": "price",
"description": "The price of the order",
"group": "Trading Setup",
"filter": "tradeType==1",
"settings": {
"required": True,
}
}, {
"type": "number",
"name": "amount",
"label": "Order quantity",
"description": "Order quantity",
"group": "Trading Setup",
"settings": {
"required": True,
}
}],
}
while True:
tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
for m in arrManager:
btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "交易品种", "default": m["symbol"], "settings": {"required": True}}])
tbl["rows"].append([m["symbol"], btnOpen])
cmd = GetCommand()
if cmd != "" and cmd != None:
Log("Receive interaction:", cmd)
# Parsing interaction messages: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
# According to the first colon: the previous instruction determines which button template triggers the message
arrCmd = cmd.split(":")
if arrCmd[0] == "open":
msg = json.loads(cmd[5:])
Log("Trading instruments:", msg["symbol"], ", Trading direction:", msg["direction"], ", Order type:", "Market order" if msg["tradeType"] == 0 else "Limit order", ", Order price: current market price" if msg["tradeType"] == 0 else ", Order price:" + str(msg["price"]), ", Order quantity:", msg["amount"])
# Output status bar information
LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
Sleep(1000)
// Omit...
Utilisez la dernière structure de boutons pour construire les boutons dans la table de la barre d'état. Lorsque vous cliquez sur le bouton pour déclencher l'interaction, une fenêtre contextuelle multi-contrôle apparaîtra. Pour plus de détails, veuillez consulter:Guide utilisateur - Contrôles interactifs dans la barre d'état.
function main() {
var table = {
type: 'table',
title: 'position operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'close positions'}]
]
}
var ticker = exchange.GetTicker()
// Add a row of data, merge the first and second cells, and output the ticker variable in the merged cell
table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "position operation",
"cols" : ["column1", "column2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close positions"}]
]
}
ticker = exchange.GetTicker()
table["rows"].append([{"body": json.dumps(ticker), "colspan": 2}, "abc"])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "position operation",
"cols" : ["column1", "column2", "Action"],
"rows" : [
["abc", "def", {"type": "button", "cmd": "coverAll", "name": "close positions"}]
]
})"_json;
auto ticker = exchange.GetTicker();
json jsonTicker = R"({"Buy": 0, "Sell": 0, "High": 0, "Low": 0, "Volume": 0, "Last": 0, "Time": 0})"_json;
jsonTicker["Buy"] = ticker.Buy;
jsonTicker["Sell"] = ticker.Sell;
jsonTicker["Last"] = ticker.Last;
jsonTicker["Volume"] = ticker.Volume;
jsonTicker["Time"] = ticker.Time;
jsonTicker["High"] = ticker.High;
jsonTicker["Low"] = ticker.Low;
json arr = R"([{"body": {}, "colspan": 2}, "abc"])"_json;
arr[0]["body"] = jsonTicker;
table["rows"].push_back(arr);
LogStatus("`" + table.dump() + "`");
}
Fusion horizontale des cellules dans le tableau établi par leLogStatus()fonction:
function main() {
var table = {
type: 'table',
title: 'table demo',
cols: ['columnA', 'columnB', 'columnC'],
rows: [
['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
]
}
var ticker = exchange.GetTicker()
var name = exchange.GetName()
table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
// A3 is merged by the first cell in the previous row
table.rows.push(["B4", "C4"])
// A2 is merged by the first cell of the previous row
table.rows.push(["B5", "C5"])
table.rows.push(["A6", "B6", "C6"])
LogStatus('`' + JSON.stringify(table) + '`')
}
import json
def main():
table = {
"type" : "table",
"title" : "table demo",
"cols" : ["columnA", "columnB", "columnC"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
}
ticker = exchange.GetTicker()
name = exchange.GetName()
table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
table["rows"].append(["B4", "C4"])
table["rows"].append(["B5", "C5"])
table["rows"].append(["A6", "B6", "C6"])
LogStatus("`" + json.dumps(table) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "table demo",
"cols" : ["columnA", "columnB", "columnC"],
"rows" : [
["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
]
})"_json;
// For testing purposes, the code is short and easy to read, and the constructed data is used here
json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
auto name = exchange.GetName();
json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
arr2[0]["body"] = "A3 + A4 + A5:" + name;
table["rows"].push_back(arr1);
table["rows"].push_back(arr2);
table["rows"].push_back(R"(["B4", "C4"])"_json);
table["rows"].push_back(R"(["B5", "C5"])"_json);
table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
LogStatus("`" + table.dump() + "`");
}
La fusion verticale des cellules dans le tableau dessiné par leLogStatus()fonction:
function main() {
var table1 = {type: 'table', title: 'table1', cols: ['column1', 'column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
var table2 = {type: 'table', title: 'table2', cols: ['column1', 'column2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}
import json
def main():
table1 = {"type": "table", "title": "table1", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
table2 = {"type": "table", "title": "table2", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
LogStatus("`" + json.dumps([table1, table2]) + "`")
void main() {
json table1 = R"({"type": "table", "title": "table1", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json table2 = R"({"type": "table", "title": "table2", "cols": ["column1", "column2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
json arr = R"([])"_json;
arr.push_back(table1);
arr.push_back(table2);
LogStatus("`" + arr.dump() + "`");
}
Affichage de la pagination de la table de barre d'état:
function main(){
var tab1 = {
type : "table",
title : "table1",
cols : ["1", "2"],
rows : []
}
var tab2 = {
type : "table",
title : "table2",
cols : ["1", "2", "3"],
rows : []
}
var tab3 = {
type : "table",
title : "table3",
cols : ["A", "B", "C"],
rows : []
}
tab1.rows.push(["jack", "lucy"])
tab2.rows.push(["A", "B", "C"])
tab3.rows.push(["A", "B", "C"])
LogStatus('`' + JSON.stringify(tab1) + '`\n' +
'`' + JSON.stringify(tab2) + '`\n' +
'`' + JSON.stringify(tab3) + '`')
Log("exit")
}
import json
def main():
tab1 = {
"type": "table",
"title": "table1",
"cols": ["1", "2"],
"rows": []
}
tab2 = {
"type": "table",
"title": "table2",
"cols": ["1", "2", "3"],
"rows": []
}
tab3 = {
"type": "table",
"title": "table3",
"cols": ["A", "B", "C"],
"rows": []
}
tab1["rows"].append(["jack", "lucy"])
tab2["rows"].append(["A", "B", "C"])
tab3["rows"].append(["A", "B", "C"])
LogStatus("`" + json.dumps(tab1) + "`\n" +
"`" + json.dumps(tab2) + "`\n" +
"`" + json.dumps(tab3) + "`")
void main() {
json tab1 = R"({
"type": "table",
"title": "table1",
"cols": ["1", "2"],
"rows": []
})"_json;
json tab2 = R"({
"type": "table",
"title": "table2",
"cols": ["1", "2", "3"],
"rows": []
})"_json;
json tab3 = R"({
"type": "table",
"title": "table3",
"cols": ["A", "B", "C"],
"rows": []
})"_json;
tab1["rows"].push_back(R"(["jack", "lucy"])"_json);
tab2["rows"].push_back(R"(["A", "B", "C"])"_json);
tab3["rows"].push_back(R"(["A", "B", "C"])"_json);
LogStatus("`" + tab1.dump() + "`\n" +
"`" + tab2.dump() + "`\n" +
"`" + tab3.dump() + "`");
}
En plus d'afficher des tableaux dans les pages, plusieurs tableaux peuvent également être affichés dans un ordre descendant:
function main() {
var tbl = {
type : "table",
title : "test scroll",
scroll : "auto",
cols : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
rows : []
}
for (var i = 1 ; i < 100 ; i++) {
tbl.rows.push([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
}
LogStatus("`" + JSON.stringify(tbl) + "`")
}
import json
def main():
tbl = {
"type" : "table",
"title" : "test scroll",
"scroll" : "auto",
"cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
"rows" : []
}
for index in range(1, 100):
i = str(index)
tbl["rows"].append([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
LogStatus("`" + json.dumps(tbl) + "`")
void main() {
json table = R"({
"type" : "table",
"title" : "test scroll",
"scroll" : "auto",
"cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
"col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
"rows" : []
})"_json;
for (int index = 1; index < 100; ++index) {
std::string i = std::to_string(index);
table["rows"].push_back({i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
"11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i});
}
LogStatus("`" + table.dump() + "`");
}
Prise en charge du réglage du mode de défilement horizontal et vertical de la table des barres d'état.scrollattribué à"auto", lorsque le nombre de lignes verticales de la table des barres d'état dépasse 20 lignes, le contenu est roulé.scrolll'attribut peut être utilisé pour atténuer le problème du retard d'écriture d'une grande quantité de données dans la barre d'état lors de la négociation en direct.
La production d'informations à partir duLogStatus()La fonction lorsque la négociation en direct est en cours n'est pas enregistrée dans la base de données de négociation en direct, mais elle met à jour uniquement le contenu de la barre d'état de la négociation en direct en cours.
LeLogStatus()Fonction de support d'impressionbase64les images codées, à commencer par`et se termine par`Par exemple:LogStatus("`data:image/png;base64,AAAA`")- Je ne sais pas.
LeLogStatus()Fonction de support du passagematplotlib.pyplotles objets directement dansPython, tant que l'objet contient lesavefigméthode, il peut être passé comme paramètre auLogStatus()fonction, par exemple:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
Lorsque la stratégie est en cours d'exécution de négociation en direct, si vous passez par l'historique sur la page de négociation en direct, la barre d'état va dormir et cesser de mettre à jour.base64Il supporte également la sortie debase64les images codées dans le tableau affiché dans la barre d'état.
Je ne sais pas si je peux le faire.
Activer ou désactiver la journalisation des informations relatives aux commandes.
Activation du journal (activée)
Si leenablele paramètre est défini sur une valeur fausse, par exemplefalse, le journal des commandes (c'est-à-dire le journal généré par des fonctions telles queexchange.Buy()) n'est pas imprimé et n'est pas inscrit dans la base de données des transactions en direct.
permettre
vrai
Boole
function main() {
EnableLog(false)
}
def main():
EnableLog(False)
void main() {
EnableLog(false);
}
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}
Personnalisez la fonction de dessin de graphique.
Objet graphique. objet
Graphique (options)
LeoptionsLe paramètre est la configuration du graphique.Chart()paramètre de fonctionoptionsest unJSONsérialisableHighStocksparamètre pourHighcharts.StockChartUn autre__isStockl'attribut est ajouté sur le paramètre natif, et si__isStock:falseSi le graphique est spécifié, il s'affiche comme un graphique normal.__isStockl'attribut est défini sur une valeur fausse, par exemplefalse, c'est-à-dire que le graphique utilisé est unHighchartsSi le__isStockl'attribut est défini sur une valeur vraie, par exempletrue, c'est-à-dire que le graphique utilisé est unHighstocksgraphique (par défaut)__isStockest vrai par exempletrueVous pouvez consulter leBibliothèque de graphiques HighStocks- Je ne sais pas.
les options
vrai
objet, tableau d'objets
function main() {
var cfgA = {
extension: {
layout: 'single', // No grouping, display separately, default to group 'group'
height: 300, // Specify the height
},
title: {
text: 'handicap chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'buy one',
data: [],
}, {
name: 'sell one',
data: [],
}]
}
var cfgB = {
title: {
text: 'spread chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'spread',
type: 'column',
data: [],
}]
}
var cfgC = {
__isStock: false,
title: {
text: 'pie chart'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
] // Instead of updating the initial data with the add function, the sequence can be updated by changing the chart configuration directly.
}]
};
var cfgD = {
extension: {
layout: 'single',
col: 8, // Specify the cell value for the width, the total value is 12
height: '300px',
},
title: {
text: 'handicap chart'
},
xAxis: {
type: 'datetime'
},
series: [{
name: 'buy one',
data: [],
}, {
name: 'sell one',
data: [],
}]
}
var cfgE = {
__isStock: false,
extension: {
layout: 'single',
col: 4,
height: '300px',
},
title: {
text: 'pie chart2'
},
series: [{
type: 'pie',
name: 'one',
data: [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
};
var chart = Chart([cfgA, cfgB, cfgC, cfgD, cfgE]);
chart.reset()
// Add a number of points to the pie chart, add can only update the data points added by add, built-in data points cannot be updated later.
chart.add(3, {
name: "ZZ",
y: Math.random() * 100
});
while (true) {
Sleep(1000)
var ticker = exchange.GetTicker()
if (!ticker) {
continue;
}
var diff = ticker.Sell - ticker.Buy
cfgA.subtitle = {
text: 'buy one ' + ticker.Buy + ', sell one ' + ticker.Sell,
};
cfgB.subtitle = {
text: 'spread ' + diff,
};
chart.add([0, [new Date().getTime(), ticker.Buy]]);
chart.add([1, [new Date().getTime(), ticker.Sell]]);
// Equivalent to updating the first data series of the second chart
chart.add([2, [new Date().getTime(), diff]]);
chart.add(4, [new Date().getTime(), ticker.Buy]);
chart.add(5, [new Date().getTime(), ticker.Buy]);
cfgC.series[0].data[0][1] = Math.random() * 100;
cfgE.series[0].data[0][1] = Math.random() * 100;
// update is actually the same as resetting the chart's configuration
chart.update([cfgA, cfgB, cfgC, cfgD, cfgE]);
}
}
import random
import time
def main():
cfgA = {
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "handicap chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
}
cfgB = {
"title" : {
"text" : "spread chart"
},
"xAxis" : {
"type" : "datetime",
},
"series" : [{
"name" : "spread",
"type" : "column",
"data" : []
}]
}
cfgC = {
"__isStock" : False,
"title" : {
"text" : "pie chart"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25],
]
}]
}
cfgD = {
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "handicap chart"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
}
cfgE = {
"__isStock" : False,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "pie chart2"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
}
chart = Chart([cfgA, cfgB, cfgC, cfgD, cfgE])
chart.reset()
chart.add(3, {
"name" : "ZZ",
"y" : random.random() * 100
})
while True:
Sleep(1000)
ticker = exchange.GetTicker()
if not ticker :
continue
diff = ticker["Sell"] - ticker["Buy"]
cfgA["subtitle"] = {
"text" : "buy one" + str(ticker["Buy"]) + "sell one" + str(ticker["Sell"])
}
cfgB["subtitle"] = {
"text" : "spread " + str(diff)
}
chart.add(0, [time.time() * 1000, ticker["Buy"]])
chart.add(1, [time.time() * 1000, ticker["Sell"]])
chart.add(2, [time.time() * 1000, diff])
chart.add(4, [time.time() * 1000, ticker["Buy"]])
chart.add(5, [time.time() * 1000, ticker["Buy"]])
cfgC["series"][0]["data"][0][1] = random.random() * 100
cfgE["series"][0]["data"][0][1] = random.random() * 100
void main() {
json cfgA = R"({
"extension" : {
"layout" : "single",
"height" : 300,
"col" : 8
},
"title" : {
"text" : "handicap chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
})"_json;
json cfgB = R"({
"title" : {
"text" : "spread chart"
},
"xAxis" : {
"type" : "datetime"
},
"series" : [{
"name" : "spread",
"type" : "column",
"data" : []
}]
})"_json;
json cfgC = R"({
"__isStock" : false,
"title" : {
"text" : "pie chart"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
})"_json;
json cfgD = R"({
"extension" : {
"layout" : "single",
"col" : 8,
"height" : "300px"
},
"title" : {
"text" : "handicap chart"
},
"series" : [{
"name" : "buy one",
"data" : []
}, {
"name" : "sell one",
"data" : []
}]
})"_json;
json cfgE = R"({
"__isStock" : false,
"extension" : {
"layout" : "single",
"col" : 4,
"height" : "300px"
},
"title" : {
"text" : "pie chart2"
},
"series" : [{
"type" : "pie",
"name" : "one",
"data" : [
["A", 25],
["B", 25],
["C", 25],
["D", 25]
]
}]
})"_json;
auto chart = Chart({cfgA, cfgB, cfgC, cfgD, cfgE});
chart.reset();
json zz = R"({
"name" : "ZZ",
"y" : 0
})"_json;
zz["y"] = rand() % 100;
chart.add(3, zz);
while(true) {
Sleep(1000);
auto ticker = exchange.GetTicker();
if(!ticker.Valid) {
continue;
}
auto diff = ticker.Sell - ticker.Buy;
json cfgASubTitle = R"({"text" : ""})"_json;
cfgASubTitle["text"] = format("buy one %f , sell one %f", ticker.Buy, ticker.Sell);
cfgA["subtitle"] = cfgASubTitle;
json cfgBSubTitle = R"({"text" : ""})"_json;
cfgBSubTitle["text"] = format("spread %f", diff);
cfgB["subtitle"] = cfgBSubTitle;
chart.add(0, {Unix() * 1000, ticker.Buy});
chart.add(1, {Unix() * 1000, ticker.Sell});
chart.add(2, {Unix() * 1000, diff});
chart.add(4, {Unix() * 1000, ticker.Buy});
chart.add(5, {Unix() * 1000, ticker.Buy});
cfgC["series"][0]["data"][0][1] = rand() % 100;
cfgE["series"][0]["data"][0][1] = rand() % 100;
chart.update({cfgA, cfgB, cfgC, cfgD, cfgE});
}
}
Configuration de dessin à plusieurs graphiques:
extension.layoutattribut
Si l'attribut est défini avec la valeur extension.heightattribut
L'attribut est utilisé pour définir la hauteur du graphique, soit comme une valeur numérique, soit comme extension.colattribut
L'attribut est utilisé pour définir la largeur du graphique, la largeur de la page est divisée en 12 cellules, ensemble 8, c'est-à-dire que le graphique occupe 8 cellules de largeur.// This chart is an object in the JavaScript language, and before using the Chart function, we need to declare an object variable chart to configure the chart. var chart = {
// This field marks whether the chart is a general chart or not, if you are interested, you can change it to false and run it.
__isStock: true,
// Scaling tool
tooltip: {xDateFormat: '%Y-%m-%d %H:%M:%S, %A'},
// title
title : { text : 'spread analysis chart'},
// selection range
rangeSelector: {
buttons: [{type: 'hour',count: 1, text: '1h'}, {type: 'hour',count: 3, text: '3h'}, {type: 'hour', count: 8, text: '8h'}, {type: 'all',text: 'All'}],
selected: 0,
inputEnabled: false
},
// Coordinate axis horizontal axis that is: x-axis, the current setting type is: time
xAxis: { type: 'datetime'},
// Coordinate axis vertical axis that is: y-axis, default value adjusted with the size of the data
yAxis : {
// title
title: {text: 'spread'},
// Whether to enable the right vertical axis
opposite: false
},
// Data series, this sttribute holds the individual data series (lines, K-charts, labels, etc...)
series : [
// The index is 0, and the data array holds the data of the index series
{name : "line1", id : "line1,buy1Price", data : []},
// Index is 1, set dashStyle:'shortdash' i.e.: set the dashed line
{name : "line2", id : "line2,lastPrice", dashStyle : 'shortdash', data : []}
]
} function main(){
// Call the Chart function to initialize the chart
var ObjChart = Chart(chart)
// Clear out
ObjChart.reset()
while(true){
// Gets the timestamp of this poll, i.e. a millisecond timestamp. It's used to determine the position of the X-axis written to the chart.
var nowTime = new Date().getTime()
// Get the ticker data
var ticker = _C(exchange.GetTicker)
// Get buy one price from the return value of the ticker data
var buy1Price = ticker.Buy
// To obtain the final transaction price, we add 1 in order not to overlap the 2 lines
var lastPrice = ticker.Last + 1
// Data sequence with timestamp as X-value and buy one price as Y-value passed into index 0
ObjChart.add(0, [nowTime, buy1Price])
// ditto
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
}
}```
```python
import time
chart = {
"__isStock" : True,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "spread analysis chart"},
"rangeSelector" : {
"buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}],
"selected": 0,
"inputEnabled": False
},
"xAxis": {"type": "datetime"},
"yAxis": {
"title": {"text": "spread"},
"opposite": False
},
"series": [{
"name": "line1", "id": "line1,buy1Price", "data": []
}, {
"name": "line2", "id": "line2,lastPrice", "dashStyle": "shortdash", "data": []
}]
}
def main():
ObjChart = Chart(chart)
ObjChart.reset()
while True:
nowTime = time.time() * 1000
ticker = exchange.GetTicker()
buy1Price = ticker["Buy"]
lastPrice = ticker["Last"] + 1
ObjChart.add(0, [nowTime, buy1Price])
ObjChart.add(1, [nowTime, lastPrice])
Sleep(2000)
void main() {
// When writing strategies in C++, try not to declare global variables that are not of the base type, so the chart configuration object is declared inside the main function.
json chart = R"({
"__isStock" : true,
"tooltip" : {"xDateFormat" : "%Y-%m-%d %H:%M:%S, %A"},
"title" : {"text" : "spread analysis chart"},
"rangeSelector" : {
"buttons" : [{"type": "count", "count": 1, "text": "1h"}, {"type": "hour", "count": 3, "text": "3h"}, {"type": "hour", "count": 8, "text": "8h"}, {"type": "all", "text": "All"}],
"selected": 0,
"inputEnabled": false
},
"xAxis": {"type": "datetime"},
"yAxis": {
"title": {"text": "spread"},
"opposite": false
},
"series": [{
"name": "line1", "id": "line1,buy1Price", "data": []
}, {
"name": "line2", "id": "line2,lastPrice", "dashStyle": "shortdash", "data": []
}]
})"_json;
auto ObjChart = Chart(chart);
ObjChart.reset();
while(true) {
auto nowTime = Unix() * 1000;
auto ticker = exchange.GetTicker();
auto buy1Price = ticker.Buy;
auto lastPrice = ticker.Last + 1.0;
ObjChart.add(0, {nowTime, buy1Price});
ObjChart.add(1, {nowTime, lastPrice});
Sleep(2000);
}
}
Exemple de dessin simple:
// Objects used to initialize the chart
var chart = {
// Chart title
title: {text: "line value triggers the plotLines value"},
// Y-axis related settings
yAxis: {
// A horizontal line perpendicular to the Y-axis, used as a trigger line, is a structural array that can set multiple trigger lines
plotLines: [{
// The value of the trigger line, how much it set, this line will be displayed in the corresponding value position
value: 0,
// Set the color of the trigger line
color: 'red',
// Width
width: 2,
// Displaying labels
label: {
// Label text
text: 'Trigger value',
// Centered label position
align: 'center'
}
}]
},
// X-axis related settings, here the setting type is time axis
xAxis: {type: "datetime"},
series: [
{name: "sin", type: "spline", data: []},
// This is an important data series, you can set multiple data series, according to the array index control
{name: "cos", type: "spline", data: []}
]
}
function main(){
// Circumference
var pi = 3.1415926535897
// Variables for recording timestamps
var time = 0
// Angle
var angle = 0
// Coordinate y values for receiving sine and cosine values
var y = 0
// Call the API interface to initialize the chart with the chart object
var objChart = Chart(chart)
// Initially, clear the chart
objChart.reset()
// Set the value of the trigger line to 1
chart.yAxis.plotLines[0].value = 1
// Loop
while(true){
// Get the timestamp of the current moment
time = new Date().getTime()
// Angle increases by 5 degrees every 500ms and calculates the sine value
y = Math.sin(angle * 2 * pi / 360)
// Write the calculated y value to the data series of the corresponding index of the chart, the first parameter of the add function is the specified data series index
objChart.add(0, [time, y])
// Calculate the cosine value
y = Math.cos(angle * 2 * pi / 360)
objChart.add(1, [time, y])
// Increase by 5 degrees
angle += 5
// Pause for 5 seconds to avoid drawing too often and growing data too fast
Sleep(5000)
}
}
import math
import time
chart = {
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
}
def main():
pi = 3.1415926535897
ts = 0
angle = 0
y = 0
objChart = Chart(chart)
objChart.reset()
chart["yAxis"]["plotLines"][0]["value"] = 1
while True:
ts = time.time() * 1000
y = math.sin(angle * 2 * pi / 360)
objChart.add(0, [ts, y])
y = math.cos(angle * 2 * pi / 360)
objChart.add(1, [ts, y])
angle += 5
Sleep(5000)
void main() {
json chart = R"({
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
})"_json;
auto pi = 3.1415926535897;
auto ts = 0;
auto angle = 0.0;
auto y = 0.0;
auto objChart = Chart(chart);
objChart.reset();
chart["yAxis"]["plotLines"][0]["value"] = 1;
while(true) {
ts = Unix() * 1000;
y = sin(angle * 2 * pi / 360);
objChart.add(0, {ts, y});
y = cos(angle * 2 * pi / 360);
objChart.add(1, {ts, y});
angle += 5;
Sleep(5000);
}
}
Exemple de dessin de courbe trigonométrique:
/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
var chartCfg = {
subtitle: {
text: "subtitle",
},
yAxis: [{
height: "40%",
lineWidth: 2,
title: {
text: 'PnL',
},
tickPixelInterval: 20,
minorGridLineWidth: 1,
minorTickWidth: 0,
opposite: true,
labels: {
align: "right",
x: -3,
}
}, {
title: {
text: 'Profit',
},
top: "42%",
height: "18%",
offset: 0,
lineWidth: 2
}, {
title: {
text: 'Vol',
},
top: '62%',
height: '18%',
offset: 0,
lineWidth: 2
}, {
title: {
text: 'Asset',
},
top: '82%',
height: '18%',
offset: 0,
lineWidth: 2
}],
series: [{
name: 'PnL',
data: [],
id: 'primary',
tooltip: {
xDateFormat: '%Y-%m-%d %H:%M:%S'
},
yAxis: 0
}, {
type: 'column',
lineWidth: 2,
name: 'Profit',
data: [],
yAxis: 1,
}, {
type: 'column',
name: 'Trade',
data: [],
yAxis: 2
}, {
type: 'area',
step: true,
lineWidth: 0,
name: 'Long',
data: [],
yAxis: 2
}, {
type: 'area',
step: true,
lineWidth: 0,
name: 'Short',
data: [],
yAxis: 2
}, {
type: 'line',
step: true,
color: '#5b4b00',
name: 'Asset',
data: [],
yAxis: 3
}, {
type: 'pie',
innerSize: '70%',
name: 'Random',
data: [],
center: ['3%', '6%'],
size: '15%',
dataLabels: {
enabled: false
},
startAngle: -90,
endAngle: 90,
}],
};
function main() {
let c = Chart(chartCfg);
let preTicker = null;
while (true) {
let t = exchange.GetTicker();
c.add(0, [t.Time, t.Last]); // PnL
c.add(1, [t.Time, preTicker ? t.Last - preTicker.Last : 0]); // profit
let r = Math.random();
var pos = parseInt(t.Time/86400);
c.add(2, [t.Time, pos/2]); // Vol
c.add(3, [t.Time, r > 0.8 ? pos : null]); // Long
c.add(4, [t.Time, r < 0.8 ? -pos : null]); // Short
c.add(5, [t.Time, Math.random() * 100]); // Asset
// update pie
chartCfg.series[chartCfg.series.length-1].data = [
["A", Math.random()*100],
["B", Math.random()*100],
];
c.update(chartCfg)
preTicker = t;
}
}
'''backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
import random
chartCfg = {
"subtitle": {
"text": "subtitle"
},
"yAxis": [{
"height": "40%",
"lineWidth": 2,
"title": {
"text": 'PnL'
},
"tickPixelInterval": 20,
"minorGridLineWidth": 1,
"minorTickWidth": 0,
"opposite": True,
"labels": {
"align": "right",
"x": -3
}
}, {
"title": {
"text": 'Profit'
},
"top": "42%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": 'Vol'
},
"top": '62%',
"height": '18%',
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": 'Asset'
},
"top": '82%',
"height": '18%',
"offset": 0,
"lineWidth": 2
}],
"series": [{
"name": 'PnL',
"data": [],
"id": 'primary',
"tooltip": {
"xDateFormat": '%Y-%m-%d %H:%M:%S'
},
"yAxis": 0
}, {
"type": 'column',
"lineWidth": 2,
"name": 'Profit',
"data": [],
"yAxis": 1
}, {
"type": 'column',
"name": 'Trade',
"data": [],
"yAxis": 2
}, {
"type": 'area',
"step": True,
"lineWidth": 0,
"name": 'Long',
"data": [],
"yAxis": 2
}, {
"type": 'area',
"step": True,
"lineWidth": 0,
"name": 'Short',
"data": [],
"yAxis": 2
}, {
"type": 'line',
"step": True,
"color": '#5b4b00',
"name": 'Asset',
"data": [],
"yAxis": 3
}, {
"type": 'pie',
"innerSize": '70%',
"name": 'Random',
"data": [],
"center": ['3%', '6%'],
"size": '15%',
"dataLabels": {
"enabled": False
},
"startAngle": -90,
"endAngle": 90
}]
}
def main():
c = Chart(chartCfg)
preTicker = None
while True:
t = exchange.GetTicker()
c.add(0, [t["Time"], t["Last"]])
profit = t["Last"] - preTicker["Last"] if preTicker else 0
c.add(1, [t["Time"], profit])
r = random.random()
pos = t["Time"] / 86400
c.add(2, [t["Time"], pos / 2])
long = pos if r > 0.8 else None
c.add(3, [t["Time"], long])
short = -pos if r < 0.8 else None
c.add(4, [t["Time"], short])
c.add(5, [t["Time"], random.random() * 100])
# update pie
chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
["A", random.random() * 100],
["B", random.random() * 100]
]
c.update(chartCfg)
preTicker = t
/*backtest
start: 2020-03-11 00:00:00
end: 2020-04-09 23:59:00
period: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json chartCfg = R"({
"subtitle": {
"text": "subtitle"
},
"yAxis": [{
"height": "40%",
"lineWidth": 2,
"title": {
"text": "PnL"
},
"tickPixelInterval": 20,
"minorGridLineWidth": 1,
"minorTickWidth": 0,
"opposite": true,
"labels": {
"align": "right",
"x": -3
}
}, {
"title": {
"text": "Profit"
},
"top": "42%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": "Vol"
},
"top": "62%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}, {
"title": {
"text": "Asset"
},
"top": "82%",
"height": "18%",
"offset": 0,
"lineWidth": 2
}],
"series": [{
"name": "PnL",
"data": [],
"id": "primary",
"tooltip": {
"xDateFormat": "%Y-%m-%d %H:%M:%S"
},
"yAxis": 0
}, {
"type": "column",
"lineWidth": 2,
"name": "Profit",
"data": [],
"yAxis": 1
}, {
"type": "column",
"name": "Trade",
"data": [],
"yAxis": 2
}, {
"type": "area",
"step": true,
"lineWidth": 0,
"name": "Long",
"data": [],
"yAxis": 2
}, {
"type": "area",
"step": true,
"lineWidth": 0,
"name": "Short",
"data": [],
"yAxis": 2
}, {
"type": "line",
"step": true,
"color": "#5b4b00",
"name": "Asset",
"data": [],
"yAxis": 3
}, {
"type": "pie",
"innerSize": "70%",
"name": "Random",
"data": [],
"center": ["3%", "6%"],
"size": "15%",
"dataLabels": {
"enabled": false
},
"startAngle": -90,
"endAngle": 90
}]
})"_json;
Chart c = Chart(chartCfg);
Ticker preTicker;
while(true) {
auto t = exchange.GetTicker();
c.add(0, {t.Time, t.Last});
auto profit = preTicker.Valid ? t.Last - preTicker.Last : 0;
c.add(1, {t.Time, profit});
auto r = rand() % 100;
auto pos = t.Time / 86400.0;
c.add(2, {t.Time, pos / 2.0});
auto longPos = r > 0.8 ? pos : NULL;
c.add(3, {t.Time, longPos});
auto shortPos = r < 0.8 ? -pos : NULL;
c.add(4, {t.Time, shortPos});
c.add(5, {t.Time, rand() % 100});
// update pie
json pie = R"([["A", 0], ["B", 0]])"_json;
pie[0][1] = rand() % 100;
pie[1][1] = rand() % 100;
chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
c.update(chartCfg);
preTicker = t;
}
}
Exemples complexes d'utilisation de graphiques hybrides:
// update pie
chartCfg.series[chartCfg.series.length-1].data = [
["A", Math.random()*100],
["B", Math.random()*100],
];
c.update(chartCfg)
# update pie
chartCfg["series"][len(chartCfg["series"]) - 1]["data"] = [
["A", random.random() * 100],
["B", random.random() * 100]
]
c.update(chartCfg)
// update pie
json pie = R"([["A", 0], ["B", 0]])"_json;
pie[0][1] = rand() % 100;
pie[1][1] = rand() % 100;
chartCfg["series"][chartCfg["series"].size() - 1]["data"] = pie;
c.update(chartCfg);
Cartes de typepiesont des graphiques sans chronologie, et vous devez mettre à jour la configuration du graphique directement lors de la mise à jour des données.c.update(chartCfg)après mise à jour des données, comme suit:
LeChart()la fonction renvoie un objet graphique qui a 4 méthodes:add(), reset(), update(), del().
update()méthode:
Leupdate()Cette méthode peut mettre à jour les informations de configuration du graphique.del()méthode:
Ledel()Cette méthode peut supprimer la série de données de l'indice spécifié en fonction du paramètre de série passé.add()méthode:
Leadd()La méthode peut écrire des données sur le graphique, avec les paramètres suivants dans l'ordre:series: utilisé pour définir l'indice de la série de données, qui est un entier.data: utilisé pour définir les données spécifiques à écrire, il s'agit d'un tableau.index(facultatif): utilisé pour définir l'index des données, il s'agit d'un entier.-1fait référence aux dernières données de l'ensemble de données.
Par exemple, lors du dessin d'une ligne, modifiez les données du dernier point de la ligne:chart.add(0, [1574993606000, 13.5], -1), c'est-à-dire modifier les données sur l'avant-dernier premier point du graphiqueseries[0].data- Je ne sais pas.
Leindexle paramètre n'est pas défini, ce qui signifie que les données sont ajoutées au dernier point de la série de données en cours.reset()méthode:
Lereset()La méthode est utilisée pour vider lesreset()la méthode peut prendre un paramètreremainpour spécifier le nombre d'entrées à conserver.remainest passé pour effacer toutes les données.J'espère que tu as bien fait.
La fonction est utilisée pour le dessin personnalisé au moment de l'exécution de la stratégie en utilisant une méthode de dessin similaire à laPine language.
L'objet de la carte.KLineChart()fonction renvoie un objet graphique avec plusieurs méthodes, parmi lesquelles vous devez faire attention àbegin()etclose()L'opération de tirage doit commencer par unbegin()appel de fonction et fin avec unclose()appel de la fonction lors du traversement des données KLine pour effectuer l'opération de dessin.
objet
Le tableau KLine (options)
Leoptionsle paramètre est la configuration du graphique.
les options
vrai
objet, tableau d'objets
function main() {
// Call the KLineChart function to create a chart control object c
let c = KLineChart({
overlay: true
})
// Use the Spot Exchange object test to get K-line data. If you use the futures exchange object test, you need to set up the contract first.
let bars = exchange.GetRecords()
if (!bars) {
return
}
// Execute the drawing operation by traversing over the K-line data. The drawing operation must start with the ```c.begin(bar)``` function call and end with the ```c.close()``` function call.
bars.forEach(function(bar, index) {
c.begin(bar)
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)')
if (bar.Close > bar.Open) {
c.bgcolor('rgba(0, 255, 0, 0.5)')
}
let h = c.plot(bar.High, 'high')
let l = c.plot(bar.Low, 'low')
c.fill(h, l, {
color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'
})
c.hline(bar.High)
c.plotarrow(bar.Close - bar.Open)
c.plotshape(bar.Low, {
style: 'diamond'
})
c.plotchar(bar.Close, {
char: 'X'
})
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
if (bar.Close > bar.Open) {
// long/short/closelong/closeshort
c.signal("long", bar.High, 1.5)
} else if (bar.Close < bar.Open) {
c.signal("closelong", bar.Low, 1.5)
}
c.close()
})
}
def main():
# Call the KLineChart function to create a chart control object c
c = KLineChart({
"overlay": True
})
# Use the Spot Exchange object test to get K-line data. If you use the futures exchange object test, you need to set up the contract first.
bars = exchange.GetRecords()
if not bars:
return
for bar in bars:
c.begin(bar)
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
if bar.Close > bar.Open:
c.bgcolor('rgba(0, 255, 0, 0.5)')
h = c.plot(bar.High, 'high')
l = c.plot(bar.Low, 'low')
c.fill(h, l, 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)')
c.hline(bar.High)
c.plotarrow(bar.Close - bar.Open)
c.plotshape(bar.Low, style = 'diamond')
c.plotchar(bar.Close, char = 'X')
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
if bar.Close > bar.Open:
# long/short/closelong/closeshort
c.signal("long", bar.High, 1.5)
elif bar.Close < bar.Open:
c.signal("closelong", bar.Low, 1.5)
c.close()
// Not supported for now
Si un objet de commande de graphique est nécessaire pour dessiner dans la zone de dessin personnalisé de la stratégie, utilisez leKLineChart()Le paramètre de l'objet est le paramètre de la fonctionKLineChart()la fonction est une structure de configuration de graphique, celle utilisée dans le code de référence est simple:{overlay: true}. Cette structure de configuration de graphique définit uniquement le contenu de dessin à produire sur le graphique principal.overlayest réglée sur une valeur false, par exemplefalseSi vous avez besoin de spécifier une fonction de dessin pour dessiner sur le graphique principal, vous pouvez également spécifier le paramètreoverlaycomme valeur vraie dans l'appel de fonction spécifique, par exemple:true.
c.barcolor(bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(0, 0, 0, 0.2)') // Use the example illustrated in the reference code in this example, without further ado
c.barcolor('rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(0, 0, 0, 0.2)')
// Not supported for now
Les fonctions de l'interface de dessin duPineles langues prises en charge dans l'opération de dessin sont:barcolor, qui définit la couleur de la ligne K.
barcolor (couleur, décalage, modifiable, titre, affichage) les paramètres d'affichage sont facultatifs:
aucun , tous
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// Not supported for now
bgcolor, remplit le fond de la ligne K de la couleur spécifiée.
bgcolor ((couleur, décalage, modifiable, show_last, titre, affichage, superposition) les paramètres d'affichage sont facultatifs:
aucun , tous
c.plot(bar.High, 'high')
c.plot(bar.Open < bar.Close ? NaN : bar.Close, "Close", {style: "linebr"}) // Support for drawing discontinuous data lines
h = c.plot(bar.High, 'high')
h = c.plot(None if bar.Open < bar.Close else bar.Close, "Close", style = "linebr") # Support for drawing discontinuous data lines
// Not supported for now
plot, tracez une série de données sur un graphique.
graphique (série, titre, couleur, largeur de ligne, style, trackprice, base de données, décalage, joint, modifiable, show_last, affichage) Les paramètres de style sont facultatifs:
stepline_diamond , stepline , cross , areabr , area , circles , columns , histogram , linebr , line les paramètres d'affichage sont facultatifs: aucun , tous
let h = c.plot(bar.High, 'high')
let l = c.plot(bar.Low, 'low')
c.fill(h, l, {color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0.2)'})
h = c.plot(bar.High, 'high')
l = c.plot(bar.Low, 'low')
c.fill(h, l, color = 'rgba(255, 0, 0, 0.2)' if bar.Close > bar.Open else 'rgba(255, 0, 0, 0.2)'})
// Not supported for now
fill, remplir l'arrière-plan entre deux graphiques ouhlineavec les couleurs fournies.
remplir ((ligne1, ligne2, couleur, titre, modifiable, remplissage, affichage) les paramètres d'affichage sont facultatifs:
aucun , tous
Depuis leJavaScriptle langage ne peut pas spécifier les paramètres entrants basés sur les noms des paramètres de fonction formels, pour résoudre ce problème, vous pouvez utiliser un{key: value}structure pour spécifier les paramètres à passer à un nom de paramètre formel.
Par exemple, le code de référence{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)'}précise lecolorparamètre dufillfonction.
Si vous devez spécifier plusieurs paramètres avec des noms de paramètres de forme consécutifs, vous pouvez utiliser{key1: value1, key2: value2, key3: value3}- Je ne sais pas.
Par exemple, dans cet exemple, un supplémenttitlele paramètre est spécifié:{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)', title: 'fill'}- Je ne sais pas.
Pour la valeur de couleur, vous pouvez le définir avec'rgba(255, 0, 0, 0, 0.2)'ou avec'#FF0000'.
c.hline(bar.High)
c.hline(bar.High)
// Not supported for now
hline, la ligne horizontale est présentée à un prix fixe donné.
ligne ((prix, titre, couleur, style de ligne, largeur de ligne, modifiable, affichage) Les paramètres de style de ligne sont facultatifs:
pointillés , pointillés , solides les paramètres d'affichage sont facultatifs: aucun , tous
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// Not supported for now
plotarrow, tracez des flèches vers le haut et vers le bas sur la carte.
Plotarrow ((série, titre, colorup, coloradown, décalage, minheight, maxheight, modifiable, show_last, affichage) les paramètres d'affichage sont facultatifs:
aucun , tous
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// Not supported for now
plotshape, dessiner des formes visuelles sur le graphique.
Plotshape (série, titre, style, emplacement, couleur, décalage, texte, couleur de texte, modifiable, taille, show_last, affichage) Les paramètres de style sont facultatifs:
diamond size.autoC'est une petite taille. les paramètres d'affichage sont facultatifs:, square , label_down , label_up , arrow_down , arrow_up , circle , flag , triangle_down , triangle_up , cross , xcross Les paramètres de localisation sont facultatifs: barre supérieure , barre inférieure , top , bottom , absolu Les paramètres de taille sont facultatifs: 10px , 14px , 20px , 40px , 80px , en comparant taille.petite, taille.petite, taille.normale, taille.grande, taille.énorme en langue Pine. aucun , tous
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// Not supported for now
plotchar, dessinez des formes visuelles sur le graphique en utilisant n'importe quel caractère Unicode donné.
graphique (série, titre, graphique, emplacement, couleur, décalage, texte, couleur de texte, modifiable, taille, show_last, affichage) Les paramètres de localisation sont facultatifs:
barre supérieure size.autoC'est une petite taille. les paramètres d'affichage sont facultatifs:, barre inférieure , top , bottom , absolu Les paramètres de taille sont facultatifs: 10px , 14px , 20px , 40px , 80px , en comparant taille.petite, taille.petite, taille.normale, taille.grande, taille.énorme en langue Pine. aucun , tous
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
c.plotcandle(bar.Open*0.9, bar.High*0.9, bar.Low*0.9, bar.Close*0.9)
// Not supported for now
plotcandle, tracez un graphique de ligne K sur un graphique.
Plotcandle (ouvert, haut, bas, près, titre, couleur, couleur, éditable, show_last, bordure, affichage) les paramètres d'affichage sont facultatifs:
aucun , tous
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// Not supported for now
signal, une fonction qui n'est pas disponible dans le langage Pine, est utilisée pour tracer des signaux d'achat et de vente ici.
signal ((direction, prix, quantité, identifiant) Le paramètre
long est passé pour indiquer la direction de la transaction, vous pouvez choisir long , closelong , short , closeshort . bar.Highest la position de l'axe Y du signal de marquage. Le quatrième paramètre peut être passé pour remplacer le contenu de texte par défaut dessiné, et le texte par défaut du marqueur de signal dessiné est la direction de la transaction, par exemplecloselong .
c.reset()
c.reset()
// Not supported for now
reset, une fonction qui n'est pas disponible dans le langage Pine, est utilisée pour vider les données du graphique.
Réinitialiser (résister) Le
reset()la méthode peut prendre un paramètre,remain, pour spécifier le nombre de données à conserver.remainCela signifie effacer toutes les données.
La stratégie de dessin personnalisé ne peut utiliser qu'une des façons deKLineChart()fonction ouChart()Pour certains paramètres de couleur et de style utilisés dans leKLineChart()l'appel de fonction, veuillez vous référer à laUtilisez la fonction KLineChart pour faciliter la conception de dessins stratégiques.
{@fun/Log/Graphique graphique}
Dégagez le tronc.
LogReset (restez)
LeremainParamètre utilisé pour définir le nombre d'entrées de journal récentes à conserver.
rester
faux
Numéro
function main() {
// Keep the last 10 logs and clear the rest
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
Le journal de démarrage pour chaque démarrage de la stratégie de trading en direct en compte un, donc si aucun paramètre n'est passé et qu'il n'y a pas de sortie de journal au début de la stratégie, aucun journal ne sera affiché du tout, en attendant que le journal du docker soit renvoyé (pas une exception).
Je ne sais pas si je peux le faire.
Utilisé pour récupérer l'espace de stockage occupé parSQLiteLorsque vous supprimez des données après avoir appelé leLogReset()fonction pour effacer le journal.
LogVacuum (en anglais)
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
La raison en est queSQLitene récupère pas l'espace occupé lors de la suppression des données, et il doit exécuterVACUUML'opération de déplacement de fichier se produit lorsque cette fonction est appelée, et le délai est grand, il est donc recommandé d'appeler à un intervalle de temps approprié.
{@fun/Log/LogReset LogReset} Je ne peux pas le faire.
Il est utilisé pour la sortie des informations de débogage dans la colonne 123456, leconsole.logles sorties de fonction de débogage des informations sur la page de trading en direct, et en même temps, créer un fichier journal avec l'extension.loget écrire des informations de débogage dans le/logs/storage/123456/dans le répertoire du docker auquel appartient la transaction en direct, avec le préfixe nom de fichierstdout_.
Je ne sais pas comment faire.
Le paramètremsgest le contenu de la sortie et le paramètremsgpeut être passé plus d'une fois.
Message à envoyer
faux
chaîne, nombre, bool, objet, tableau, nul et autres types pris en charge par le système.
function main() {
console.log("test console.log")
}
# Not supported
// Not supported
JavaScriptLe langage supporte cette fonction.[object Object], alors essayez de produire autant d'informations lisibles que possible.{@fun/Log/console.error Console.error} Je suis désolé
Utilisé pour la sortie d'erreur dans le champ 123456, leconsole.errorfonction crée un fichier journal avec l'extension.logdans le/logs/storage/123456/répertoire du docker où le commerce en direct appartient, et écrit la sortie d'erreur avec le préfixestderr_.
Je suis désolé.
Le paramètremsgest le contenu de la sortie et le paramètremsgpeut être passé plus d'une fois.
Message à envoyer
faux
chaîne, nombre, bool, objet, tableau, nul et autres types pris en charge par le système.
function main() {
console.error("test console.error")
}
# Not supported
// Not supported
JavaScriptLe langage supporte cette fonction.[object Object], alors essayez de produire autant d'informations lisibles que possible.Je ne sais pas si je peux le faire.
Obtenez la structure {@struct/Ticker Ticker} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données du ticker.GetTicker ()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}, l'utilisationexchangeles fonctions (méthodes) des membres d'objet liées uniquement à:exchange, et il ne sera pas répété dans le document.
Leexchange.GetTicker()fonction renvoie la structure {@struct/Ticker Ticker} lorsque la demande de données est réussie, et renvoie la valeur nulle lorsque la demande de données échoue.
{@struct/Ticker Ticker}, valeur nulle
Je suis en train d' échanger. Je suis en train d'écrire une lettre.
Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données {@struct/Ticker Ticker} demandées.
Lorsque vous appelez leexchange.GetTicker(symbol)fonction,exchangeSi vous avez besoin de demander des données de marché avec la monnaie libellée comme USDT et la monnaie de négociation comme BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.
Lorsque vous appelez leexchange.GetTicker(symbol)fonction,exchangeSi vous avez besoin de demander les données du marché du contrat perpétuel U-standard de BTCsymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère exchange.GetTicker(symbol)fonction,exchangeSi vous avez besoin de demander les données du marché du contrat d'option U-standard de BTCsymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère
le symbole faux chaîne
function main(){
// If it is a futures exchange object, set the contract code first, e.g. set it as a perpetual contract
// exchange.SetContractType("swap")
var ticker = exchange.GetTicker()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, the ticker is null, and it will cause an error when accessing ticker.High, so when testing this code, make sure that the exchange interface can be accessed.
*/
Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume)
}
def main():
ticker = exchange.GetTicker()
Log("Symbol:", ticker["Symbol"], "High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Open:", ticker.Open, "Volume:", ticker["Volume"])
void main() {
auto ticker = exchange.GetTicker();
Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume);
}
Pour les objets d'échange de contrats à terme (c.-à-d.exchangeouexchanges[0]), vous devez définir le code du contrat à l'aide duexchange.SetContractType()fonction avant d'appeler la fonction ticker, qui ne sera pas répétée.
function main() {
var ticker = exchange.GetTicker("BTC_USDT")
Log(ticker)
}
def main():
ticker = exchange.GetTicker("BTC_USDT")
Log(ticker)
void main() {
auto ticker = exchange.GetTicker("BTC_USDT");
Log(ticker);
}
Utilisez lesymbolparamètre permettant de demander des données de marché pour un symbole spécifique (symbole au comptant).
LeTickerLes données renvoyées par leexchange.GetTicker()Le système de backtesting est basé sur desHighetLowLes valeurs d'achat et de vente sont des valeurs simulées, tirées de la vente et de l'achat sur le marché à ce moment-là.TickerLes données renvoyées par leexchange.GetTicker()La situation actuelle est celle de laHighetLowles valeurs sont basées sur les données renvoyées par l'échange encapsuléTickl'interface, qui comprend les prix les plus élevés et les plus bas au cours d'une certaine période (généralement une période de 24 heures).
Échanges qui ne soutiennent pas leexchange.GetTicker()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| GetTicker | – | Le montant de la garantie est calculé à partir du montant de la garantie |
{@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange
Obtenir la structure {@struct/Depth Depth} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données du carnet de commandes.
Leexchange.GetDepth()fonction renvoie la structure {@struct/Depth Depth} si la demande de données est réussie, et elle renvoie nul si la demande de données échoue.
{@struct/Depth Depth}, valeur nulle
Je suis désolé. échange.Symbole GetDepth
Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données {@struct/Depth Depth} demandées. Si ce paramètre n'est pas passé, les données du carnet d'ordres de la paire de négociation actuellement définie et le code de contrat seront demandés par défaut.exchange.GetDepth(symbol)fonction,exchangeSi vous avez besoin de demander d'obtenir les données du carnet de commandes avec la monnaie libellée en USDT et la monnaie de la transaction en BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.exchange.GetDepth(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat perpétuel standard U de BTCsymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère exchange.GetDepth(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat d'option U-standard de BTCsymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère
function main(){
var depth = exchange.GetDepth()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, the depth is null, which will cause an error when accessing depth.Asks[1].Price, so make sure you can access the exchange interface when testing the code.
*/
var price = depth.Asks[1].Price
Log("Sell 2 price is:", price)
}
def main():
depth = exchange.GetDepth()
price = depth["Asks"][1]["Price"]
Log("Sell 2 price is:", price)
void main() {
auto depth = exchange.GetDepth();
auto price = depth.Asks[1].Price;
Log("Sell 2 price is:", price);
}
Test de détectionexchange.GetDepth()fonction:
function main() {
// BTC U-based perpetual contract
var depth = exchange.GetDepth("BTC_USDT.swap")
Log(depth)
}
def main():
depth = exchange.GetDepth("BTC_USDT.swap")
Log(depth)
void main() {
auto depth = exchange.GetDepth("BTC_USDT.swap");
Log(depth);
}
Lorsque le configuréexchangel'objet est un objet d'échange de contrats à terme, utiliser lesymbolparamètre permettant de demander les données du carnet de commandes d'un symbole spécifique (symbole des contrats à terme).
Dans le système de backtesting, les données pour chaque grade renvoyées par leexchange.GetDepth()fonction lorsque l'on utilise leSimuler une tiqueDans le système de backtesting, les données renvoyées par leexchange.GetDepth()fonction lorsque l'on utilise leUne vraie tiqueLe backtesting est un instantané profond de deuxième niveau.
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetTicker exchange.GetTicker}, {@fun
Obtenez le tableau de structure {@struct/Trade Trade} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données de transaction sur le marché.
Leexchange.GetTrades()la fonction renvoie un tableau de structures {@struct/Trade Trade} si la demande de données est réussie, et elle renvoie des valeurs nulles si la demande de données échoue.
{@struct/Trade Trade} séries, valeurs nulles
Je suis en train d' échanger. Le symbole "GetTrades" est le symbole de l'échange.
Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données de tableau {@struct/Trade Trade} demandées. Si ce paramètre n'est pas passé, les dernières données d'enregistrement de transaction de la paire de négociation actuellement définie et le code de contrat seront demandés par défaut.exchange.GetTrades(symbol)fonction,exchangeSi vous avez besoin de demander à obtenir les données du carnet de commandes avec la monnaie libellée en USDT et la monnaie de négociation en BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.exchange.GetTrades(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat perpétuel standard U de BTCsymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère exchange.GetTrades(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat d'option standard U de BTCsymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère
function main(){
var trades = exchange.GetTrades()
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, trade is null. When accessing trade[0].Id, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
*/
Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}
def main():
trades = exchange.GetTrades()
Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])
void main() {
auto trades = exchange.GetTrades();
Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}
Testez leexchange.GetTrades()fonction:
function main() {
// BTC's U-based perpetual contract
var trades = exchange.GetTrades("BTC_USDT.swap")
Log(trades)
}
def main():
trades = exchange.GetTrades("BTC_USDT.swap")
Log(trades)
void main() {
auto trades = exchange.GetTrades("BTC_USDT.swap");
Log(trades);
}
Lorsque le configuréexchangel'objet est un objet d'échange de contrats à terme, utiliser lesymbolparamètre permettant de demander des données d'enregistrement des transactions de marché pour un symbole spécifique (symbole des contrats à terme).
exchange.GetTrades()Les données retournées sont un tableau, où chaque élément de l'ordre chronologique etexchange.GetRecords ()la fonction renvoie le même ordre de données, c'est-à-dire que le dernier élément du tableau est les données les plus proches de l'heure actuelle.
Leexchange.GetTrades()fonction renvoie un tableau vide en utilisantSimuler une tiqueLes données renvoyées par l'appareil deexchange.GetTrades()fonction lors de l'utilisationUne vraie tiquele backtesting dans le système de backtesting est les données instantanées du flux des ordres, c'est-à-dire le tableau de structure {@struct/Trade Trade}.
Échanges qui ne soutiennent pas leexchange.GetTrades()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| GetTrades | – | Le montant de l'obligation est calculé à partir de la valeur de l'obligation. |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetRecords}, {@fun/Market/exchange.GetTicker exchange.GetRecords}, {@fun/Market/Market/Exchange.
Obtenir le tableau de structure {@struct/Record Record} du spot ou du contrat correspondant à la paire de négociation actuellement définie, le code du contrat, c'est-à-dire les données de ligne K.
Leexchange.GetRecords()fonction renvoie un tableau de {@struct/Record Record} structures lorsque la demande de données réussit, et il renvoie des valeurs nulles lorsque la demande de données échoue.
{@struct/Record Record} séries, valeurs nulles
Je suis en train d' échange.GetRecords Je suis en train de faire un test de détection. Je suis en train d'écrire une lettre. Le code de l'échange.GetRecords (symbole, période, limite) Je ne peux pas faire ça. Je ne sais pas si je peux vous aider.
Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code de contrat correspondant aux données de tableau {@struct/Record Record} demandées. Si ce paramètre n'est pas passé, les données de ligne K de la paire de négociation actuellement définie et le code de contrat seront demandés par défaut.exchange.GetRecords(symbol)fonction,exchangeSi vous avez besoin de demander à obtenir les données avec la monnaie libellée en USDT et la monnaie de la transaction en BTC, le paramètresymbolest:"BTC_USDT", et le format est le format de paire de négociation défini par la plateforme FMZ.exchange.GetRecords(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat perpétuel standard U de BTCsymbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère exchange.GetRecords(symbol)fonction,exchangeSi vous avez besoin de demander les données du carnet de commandes du contrat d'option standard U de BTCsymbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), le format est la combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère periodspécifie la période des données de ligne K demandées, par exemple: {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15}, etc. La valeur du paramètreperiodSi ce paramètre n'est pas passé, la période des données de ligne K demandées par défaut est la période de ligne K par défaut de la configuration de stratégie en temps réel / backtest en cours.
période
faux
Numéro
Le paramètrelimitest utilisé pour spécifier la longueur des données de ligne K demandées. Si ce paramètre n'est pas passé, la longueur de demande par défaut est le nombre maximum de barres de ligne K demandées à un moment de l'interface de ligne K d'échange. Ce paramètre peut provoquer une page à interroger les données de ligne K d'échange, et la consommation de temps de l'appel de fonction augmentera pendant la requête de page.
limite
faux
Numéro
function main() {
// Print K-line data with a K-line period of 120 seconds (2 minutes)
Log(exchange.GetRecords(60 * 2))
// Print K-line data with a K-line period of 5 minutes
Log(exchange.GetRecords(PERIOD_M5))
}
def main():
Log(exchange.GetRecords(60 * 2))
Log(exchange.GetRecords(PERIOD_M5))
void main() {
Log(exchange.GetRecords(60 * 2)[0]);
Log(exchange.GetRecords(PERIOD_M5)[0]);
}
Obtenez les données de la ligne K pour une période personnalisée.
function main() {
var records = exchange.GetRecords(PERIOD_H1)
/*
The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
At this point, records is null. When accessing records[0].Time, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
*/
Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
Log("The second k-line data is Time:", records[1].Time ,"Close:", records[1].Close)
Log("Current K-line (latest)", records[records.length-1], "Previous K-line", records[records.length-2])
}
def main():
records = exchange.GetRecords(PERIOD_H1)
Log("The first k-line data is Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
Log("The second k-line data Time:", records[1]["Time"], "Close:", records[1]["Close"])
Log("Current K-line (latest)", records[-1], "Previous K-line", records[-2])
void main() {
auto records = exchange.GetRecords(PERIOD_H1);
Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
Log("The second k-line data Time:", records[1].Time, "Close:", records[1].Close);
Log("Current K-line (latest)", records[records.size() - 1], "Previous K-line", records[records.size() - 2]);
}
Données de sortie de la barre K:
function main() {
var records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
Log(records)
}
def main():
records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
Log(records)
void main() {
auto records = exchange.GetRecords("BTC_USDT.swap", 60, 100);
Log(records);
}
Lorsque le configuréexchangel'objet est un objet d'échange de contrats à terme, utiliser lesymbol, period, etlimitles paramètres permettant de demander les données de ligne K d'un produit spécifique (produit futur).
Si vous spécifiez un paramètre lors de l'appel de la ligne K, vous pouvez définir la période par défaut dans les pages de backtest et de trading réel.exchange.GetRecords()Si aucun paramètre n'est spécifié lors de l'appel de la fonction, les données de ligne correspondantes seront renvoyées selon la période de ligne définie dans le backtest et les paramètres réels du marché.
La valeur retournée est un tableau deRecordLes données de ligne K renvoyées seront accumulées au fil du temps, la limite supérieure des barres de ligne K accumulées est affectée par leexchange.SetMaxBarLen()La limite par défaut est de 5000 bar quand elle n'est pas définie. Lorsque les données de ligne K atteignent la limite d'accumulation de la barre de ligne K, elles seront mises à jour en ajoutant une barre de ligne K et en supprimant la barre de ligne K la plus ancienne (par exemple, file d'attente d'entrée/sortie).TradeLes données sont extraites en temps réel pour générer des lignes K.
Si l'interface K-line de l'échange prend en charge les requêtes de pagination, plusieurs requêtes API seront effectuées lors de l'appel de l'interfaceexchange.SetMaxBarLen()fonction pour définir une plus grande longueur de ligne K.
Lorsque leexchange.GetRecords()- Le système de backtesting obtiendra un certain nombre de barres de K-line avant le début de l'intervalle de temps de backtesting à l'avance (le paramètre par défaut est 5000, les paramètres du système de backtesting et la quantité de données affecteront le nombre final renvoyé), comme les données de K-line initiales. - Le nombre de barres de K-line obtenues pendant le trading réel est basé sur la quantité maximale de données pouvant être obtenues à partir de l'interface K-line de l'échange.
LeperiodLe paramètre est réglé sur 5, qui est une demande d'obtention de données de ligne K avec une période de 5 secondes.periodLe système sous-jacent utilise l'interface correspondante deexchange.GetTrades()Les données de l'enregistrement de transaction doivent être collectées et synthétisées.periodsi le paramètre est divisible par 60, les données de ligne K requises sont synthétisées à l'aide d'un minimum de données de ligne K d'une minute (si possible, les données de ligne K requises sont synthétisées à l'aide d'une période plus longue).
Le backtesting de niveau simulé dans le système de backtesting nécessite le réglage de la période de ligne K sous-jacente (lorsque le système de backtesting simule le backtesting de niveau, les données de ligne K correspondantes sont utilisées pour générer des données Tick en fonction de la période de ligne K sous-jacente).
LeC++le langage a l'exemple de code suivant si vous avez besoin de construire vos propres données de ligne K:
#include <sstream>
void main() {
Records r;
r.Valid = true;
for (auto i = 0; i < 10; i++) {
Record ele;
ele.Time = i * 100000;
ele.High = i * 10000;
ele.Low = i * 1000;
ele.Close = i * 100;
ele.Open = i * 10;
ele.Volume = i * 1;
r.push_back(ele);
}
// Output display: Records[10]
Log(r);
auto ma = TA.MA(r,10);
// Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
Log(ma);
}
Les échanges qui ne soutiennent pas leexchange.GetRecords()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| Obtenez des enregistrements | Il est à la recherche d'un emploi. | Le montant de la garantie est calculé à partir du montant de la garantie |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetDepth exchange.GetDepth exchange
Obtenez la période de la ligne K définie sur la page du site Web de la plateforme de trading FMZ Quant lors du backtesting et de l'exécution de la stratégie dans le trading en direct, c'est-à-dire la période de la ligne K par défaut utilisée lors de l'appel de laexchange.GetRecords()fonctionner sans passer de paramètres.
Période de ligne K en secondes, valeur entière en secondes. Numéro
Je suis en train d'écrire une lettre.
function main() {
// For example, the K-line period set on the website page of the FMZ Quant Trading platform during backtesting and live trading is 1 hour.
var period = exchange.GetPeriod()
Log("K-line period:", period / (60 * 60), "hours")
}
def main():
period = exchange.GetPeriod()
Log("K-line period:", period / (60 * 60), "hours")
void main() {
auto period = exchange.GetPeriod();
Log("K-line period:", period / (60 * 60.0), "hours");
}
{@fun/Marché/échange.GetRecords échange.GetRecords}
Réglez la longueur maximale de la ligne K.
Je vous en prie, échangez.
Le paramètrenest utilisé pour spécifier la longueur maximale de la ligne K.
n
vrai
Numéro
function main() {
exchange.SetMaxBarLen(50)
var records = exchange.GetRecords()
Log(records.length, records)
}
def main():
exchange.SetMaxBarLen(50)
r = exchange.GetRecords()
Log(len(r), r)
void main() {
exchange.SetMaxBarLen(50);
auto r = exchange.GetRecords();
Log(r.size(), r[0]);
}
Leexchange.SetMaxBarLen()La fonction affecte deux aspects pour le temps d'exécution de la stratégie de crypto-monnaie:
{@fun/Marché/échange.GetRecords échange.GetRecords}
Obtenez le contenu original retourné par la dernièrerestdemande pour l'objet d'échange en cours ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).
Les données de réponse pour lerestune demande.
chaîne
Je suis en train d'écrire un article.
function main(){
exchange.GetAccount();
var obj = JSON.parse(exchange.GetRawJSON());
Log(obj);
}
import json
def main():
exchange.GetAccount()
obj = json.loads(exchange.GetRawJSON())
Log(obj)
void main() {
auto obj = exchange.GetAccount();
// C++ does not support the GetRawJSON function
Log(obj);
}
Leexchange.GetRawJSON()La fonction n'est prise en charge que pour le trading réel.C++ language.
{@var/EXCHANGE échange}
Obtenez le taux de change actuellement défini pour l'objet d'échange.
La valeur courante du taux de change de l'objet de change. Numéro
Je suis en train de changer.
function main(){
Log(exchange.GetTicker())
// Set up exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("Current exchange rate:", exchange.GetRate())
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
Log("Current exchange rate:", exchange.GetRate())
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
Log("Current exchange rate:", exchange.GetRate());
}
Siexchange.SetRate()n'a pas été appelée à fixer le taux de conversion, leexchange.GetRate()La fonction renvoie une valeur de taux par défaut de 1, c'est-à-dire que les données relatives à la devise actuellement affichée (quoteCurrency) n'ont pas été converties.
Si une valeur de taux de change a été définie en utilisantexchange.SetRate(), par exemple,exchange.SetRate(7). Ensuite, toutes les informations sur les prix, telles que les cotations, les profondeurs et les prix des commandes obtenus par leexchangel'objet d'échange sera converti en multipliant par le taux de change fixé7- Je ne sais pas.
Siexchangecorrespond à un échange avec USD comme monnaie de dénomination, après avoir appeléexchange.SetRate(7), tous les prix sur le marché en direct seront convertis en un prix proche du yuan en multipliant7À ce stade, la valeur du taux de change obtenue enexchange.GetRate()est7.
{@fun/Trade/exchange.SetRate échange.SetRate} Je suis désolé.
Leexchange.SetData()fonction est utilisée pour définir les données chargées lorsque la stratégie est exécutée.
La longueur de la chaîne après le paramètrevalueLe code JSON.
Numéro
Le code de l'appareil est le même que le code de l'appareil.
Le nom de la collecte de données.
clé
vrai
chaîne
Les données à charger par leexchange.SetData()La structure de données est la même que le format de données demandé par leexchange.GetData()fonction lors de la demande de données externes, c'est-à-dire:"schema": ["time", "data"]- Je ne sais pas.
valeur
vrai
séquence
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
var data = [
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
exchange.SetData("test", data)
while(true) {
Log(exchange.GetData("test"))
Sleep(1000)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
data = [
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
exchange.SetData("test", data)
while True:
Log(exchange.GetData("test"))
Sleep(1000)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json data = R"([
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
])"_json;
exchange.SetData("test", data);
while(true) {
Log(exchange.GetData("test"));
Sleep(1000);
}
}
Elle exige que les données du paramètrevalueêtre dans le même format que ledataVous pouvez voir que l'horodatage1579622400000correspond à l'heure2020-01-22 00:00:00, et que lorsque le programme de stratégie est exécuté après ce temps, appeler leexchange.GetData()fonction pour obtenir les données avant le prochain horodatage1579708800000, c'est-à-dire le temps2020-01-23 00:00:00Ce que vous obtenez[1579622400000, 123]le contenu de ces données, au fur et à mesure que le programme continue à s'exécuter, l'heure change, et ainsi de suite pour obtenir l'élément de données par élément. Dans l'exemple suivant, à l'exécution (backtesting ou trading en direct), le moment actuel atteint ou dépasse l'horodatage1579795200000, leexchange.GetData()la fonction est appelée et la valeur de retour est:{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000correspond à1579795200000dans les données[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]correspond aux données["abc", 123, {"price": 123}]]dans[1579795200000, ["abc", 123, {"price": 123}]].
Les données chargées peuvent être des indicateurs économiques, des données sectorielles, des indicateurs pertinents, etc., utilisés pour une évaluation quantitative stratégique de toutes les informations quantifiables.
{@fun/Marché/échange.GetData échange.GetData}
Leexchange.GetData()fonction est utilisée pour obtenir les données chargées par leexchange.SetData()fonction ou fournie par un lien externe.
Enregistrements dans la collecte de données. objet
Je suis en train d' échanger. Je ne sais pas si je peux le faire.
Le nom de la collecte de données. clé vrai chaîne Utilisé pour définir le temps d'arrêt du cache en millisecondes. Par défaut à une minute de temps d'arrêt du cache pour les transactions en direct. Le temps mort faux Numéro
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
while(true) {
Log(exchange.GetData("test"))
Sleep(1000 * 60 * 60 * 24)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
while True:
Log(exchange.GetData("test"))
Sleep(1000 * 60 * 60 * 24)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
arr[0][1] = _D(1579536000000);
arr[1][1] = _D(1579622400000);
arr[2][1] = _D(1579708800000);
exchange.SetData("test", arr);
while(true) {
Log(exchange.GetData("test"));
Sleep(1000 * 60 * 60 * 24);
}
}
L'appel pour obtenir les données écrites directement.
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
while(true) {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Sleep(1000)
}
}
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''
def main():
while True:
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Sleep(1000)
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
void main() {
while(true) {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
Sleep(1000);
}
}
Il prend en charge la demande de données via des liens externes, le format des données demandées pour:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Où?schemaest le format de données pour chaque enregistrement dans le corps des données chargées, qui est fixé à["time", "data"]correspondant au format des données entrées par entrées dans ledataattribut.
Ce qui est stocké dans ledatal'attribut est le corps des données, chaque entrée étant constituée d'un horodatage de niveau milliseconde et du contenu des données (qui peut être n'importe quelle donnée codable JSON).
Le programme de service pour les tests, écrit en Go:
package main
import (
"fmt"
"net/http"
"encoding/json"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
ret := map[string]interface{}{
"schema": []string{"time","data"},
"data": []interface{}{
[]interface{}{1579536000000, "abc"},
[]interface{}{1579622400000, 123},
[]interface{}{1579708800000, map[string]interface{}{"price":123}},
[]interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
},
}
b, _ := json.Marshal(ret)
w.Write(b)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
Les données de réponse du programme à la réception de la demande:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Code de stratégie de test:
function main() {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
}
def main():
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
void main() {
Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
}
La méthode d'appel pour obtenir les données d'un lien externe.
function main() {
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data")) // The xxx part of the link is the code of the query data, here xxx is an example.
}
def main():
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))
void main() {
Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"));
}
Demande de données pour une requête créée sur la plateformedonnées données, demandant que le format de données de la réponse soit (doit comporter le temps, les champs de données décrits dans le schéma):
{
"data": [],
"schema": ["time", "data"]
}
Le champ exchange.GetData()une fonction est appelée, un objet JSON est renvoyé, par exemple:{"Time":1579795200000, "Data":"..."}.
Obtenez les données à la fois pour le backtesting et cache une minute de données pour le trading en direct.from(horodatage en secondes),to(horodatage en secondes) à la demande, paramètres tels queperiod(période de ligne K sous-jacente, timestampée en millisecondes) sont utilisées pour déterminer la période pendant laquelle les données doivent être acquises.
{@fun/Market/exchange.SetData exchange.SetData} Vous avez une idée?
Leexchange.GetMarkets()fonction est utilisée pour obtenir des informations sur le marché des changes.
Le dictionnaire contient la structure {@struct/Market Market}. objet
Je suis en train d'écrire.
function main() {
var markets = exchange.GetMarkets()
var currency = exchange.GetCurrency()
// Get the current contract code can also use exchange.GetContractType() function
var ct = "swap"
var key = currency + "." + ct
Log(key, ":", markets[key])
}
def main():
markets = exchange.GetMarkets()
currency = exchange.GetCurrency()
ct = "swap"
key = currency + "." + ct
Log(key, ":", markets[key])
void main() {
auto markets = exchange.GetMarkets();
auto currency = exchange.GetCurrency();
auto ct = "swap";
auto key = currency + "." + ct;
Log(key, ":", markets[key]);
}
Exemple d'appel à un objet d'échange à terme:
/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
var tbl1 = {
type: "table",
title: "markets1",
cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
rows: []
}
var markets1 = exchange.GetMarkets()
for (var key in markets1) {
var market = markets1[key]
tbl1.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
}
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
var tbl2 = {
type: "table",
title: "markets2",
cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
rows: []
}
var markets2 = exchange.GetMarkets()
for (var key in markets2) {
var market = markets2[key]
tbl2.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
}
LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}
'''backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
tbl1 = {
"type": "table",
"title": "markets1",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
}
markets1 = exchange.GetMarkets()
for key in markets1:
market = markets1[key]
tbl1["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
for symbol in arrSymbol:
exchange.GetTicker(symbol)
tbl2 = {
"type": "table",
"title": "markets2",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
}
markets2 = exchange.GetMarkets()
for key in markets2:
market = markets2[key]
tbl2["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
/*backtest
start: 2023-05-10 00:00:00
end: 2023-05-20 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
json tbl1 = R"({
"type": "table",
"title": "markets1",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
})"_json;
auto markets1 = exchange.GetMarkets();
for (auto& [key, market] : markets1.items()) {
json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
tbl1["rows"].push_back(arrJson);
}
for (const auto& symbol : arrSymbol) {
exchange.GetTicker(symbol);
}
json tbl2 = R"({
"type": "table",
"title": "markets2",
"cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
"rows": []
})"_json;
auto markets2 = exchange.GetMarkets();
for (auto& [key, market] : markets2.items()) {
json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
tbl2["rows"].push_back(arrJson);
}
json tbls = R"([])"_json;
tbls.push_back(tbl1);
tbls.push_back(tbl2);
LogStatus("`" + tbls.dump() + "`");
}
Utilisez l'objet d'échange de contrats à terme pour appeler leexchange.GetMarkets()Avant d'appeler une fonction de marché, GetMarkets ne renvoie que les données de marché de la paire de négociation par défaut actuelle. Après avoir appelé la fonction de marché, il renvoie les données de marché de toutes les variétés demandées. Vous pouvez vous référer à l'exemple de test suivant:
Leexchange.GetMarkets()fonction renvoie un dictionnaire avec une clé nommée le nom de la variété de négociation, et pour les fixes au comptant formatés comme une paire de négociation, par exemple:
{
"BTC_USDT" : {...}, // The key value is the Market structure
"LTC_USDT" : {...},
...
}
Pour les échanges de contrats à terme, car il peut y avoir plusieurs contrats pour une même variété, par exempleBTC_USDTIl existe des contrats perpétuels, des contrats trimestriels, etc.exchange.GetMarkets()fonction renvoie un dictionnaire avec le nom de clé de la paire combiné avec le code du contrat, par exemple:
{
"BTC_USDT.swap" : {...}, // The key value is the Market structure
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()La fonction prend en charge les transactions en direct, le système de backtesting.exchange.GetMarkets()La fonction renvoie des informations de marché uniquement pour les variétés qui sont négociées en ligne sur la bourse.exchange.GetMarkets()fonction ne prend pas en charge les contrats d'options.Les échanges qui ne soutiennent pas leexchange.GetMarkets()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| GetMarkets | Coincheck / Bithumb / BitFlyer | – |
{@struct/Marché du marché}
Leexchange.GetTickers()La fonction est utilisée pour obtenir des données de ticker agrégées d'échange (le tableau de la structure {@struct/Ticker Ticker}).exchangerenvoie les données de ticker pour toutes les paires de négociation lorsqu'il s'agit d'un objet d'échange au comptant;exchangerenvoie des données de ticker pour tous les contrats lorsqu'il s'agit d'un objet d'échange de contrats à terme.
Leexchange.GetTickers()fonction renvoie un tableau de {@struct/Ticker Ticker} structures quand il réussit à demander des données, et nul quand il échoue.
{@struct/Ticker Ticker} les tableaux, les valeurs nulles
Je suis en train de changer.
function main() {
var tickers = exchange.GetTickers()
if (tickers && tickers.length > 0) {
Log("Number of tradable items on the exchange:", tickers.length)
}
}
def main():
tickers = exchange.GetTickers()
if tickers and len(tickers) > 0:
Log("Number of tradable items on the exchange:", len(tickers))
void main() {
auto tickers = exchange.GetTickers();
if (tickers.Valid && tickers.size() > 0) {
Log("Number of tradable items on the exchange:", tickers.size());
}
}
Appelez leexchange.GetTickers()fonction pour obtenir des données de marché agrégées.
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
// Before requesting other trading pair market data, call Get Tickers
var tickers1 = exchange.GetTickers()
var tbl1 = {type: "table", title: "tickers1", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
for (var ticker of tickers1) {
tbl1.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
}
// Request market data for other trading pairs
for (var symbol of arrSymbol) {
exchange.GetTicker(symbol)
}
// Call GetTickers again
var tickers2 = exchange.GetTickers()
var tbl2 = {type: "table", title: "tickers2", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
for (var ticker of tickers2) {
tbl2.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
}
LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
tickers1 = exchange.GetTickers()
tbl1 = {"type": "table", "title": "tickers1", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
for ticker in tickers1:
tbl1["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
for symbol in arrSymbol:
exchange.GetTicker(symbol)
tickers2 = exchange.GetTickers()
tbl2 = {"type": "table", "title": "tickers2", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
for ticker in tickers2:
tbl2["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
json tickerToJson(const Ticker& ticker) {
json arrJson;
arrJson.push_back(ticker.Symbol);
arrJson.push_back(ticker.High);
arrJson.push_back(ticker.Open);
arrJson.push_back(ticker.Low);
arrJson.push_back(ticker.Last);
arrJson.push_back(ticker.Buy);
arrJson.push_back(ticker.Sell);
arrJson.push_back(ticker.Time);
arrJson.push_back(ticker.Volume);
return arrJson;
}
void main() {
std::string arrSymbol[] = {"ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"};
auto tickers1 = exchange.GetTickers();
json tbl1 = R"({
"type": "table",
"cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
"rows": []
})"_json;
tbl1["title"] = "tickers1";
for (const auto& ticker : tickers1) {
json arrJson = tickerToJson(ticker);
tbl1["rows"].push_back(arrJson);
}
for (const std::string& symbol : arrSymbol) {
exchange.GetTicker(symbol);
}
auto tickers2 = exchange.GetTickers();
json tbl2 = R"({
"type": "table",
"cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
"rows": []
})"_json;
tbl2["title"] = "tickers2";
for (const auto& ticker : tickers2) {
json arrJson = tickerToJson(ticker);
tbl2["rows"].push_back(arrJson);
}
json tbls = R"([])"_json;
tbls.push_back(tbl1);
tbls.push_back(tbl2);
LogStatus("`" + tbls.dump() + "`");
}
Utilisez l'objet d'échange au comptant et appelezexchange.GetTickers()Avant d'appeler une fonction de marché, GetTickers renvoie uniquement les données de ticker de la paire de trading par défaut actuelle. Après avoir appelé la fonction de marché, il renvoie les données de ticker de toutes les variétés demandées. Vous pouvez vous référer à l'exemple de test suivant:
Les échanges qui ne soutiennent pas leexchange.GetTickers()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| - Je ne sais pas. | Il est aussi connu sous le nom de "Gemini". | Les titres de titres de créance détenus par les établissements de crédit sont considérés comme des titres de titres détenus par les établissements de crédit. |
{@struct/TickerTicker}, {@fun/Marché/échange.GetTicker échange.GetTicker} Je suis désolée.
Leexchange.Buy()La fonction est utilisée pour passer des ordres d'achat.Buy()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}.Buy()fonction fonctionne sur le compte de change lié à l'objet de changeexchangeLe but des fonctions (méthodes) des membres duexchangel'objet est uniquement lié àexchange, et il ne sera pas répété après la documentation.
Une commande réussie renvoie l'identifiant de commande, une commande ratée renvoie une valeur nulle.
L'attributIdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de la paire de négociation au comptantETH_USDTl'ordre de l'échange OKX est le suivant:ETH-USDT,1547130415509278720- Je ne sais pas.
Lorsque vous appelez leexchange.Buy()fonction pour passer une commande, la commande de retour de valeurIdest conforme à laIdattribute de la structure de l'ordre {@struct/Order Order}.
chaîne, valeur nulle
échange.Acheter ((prix, montant) échange.acheter ((prix, montant,... arguments)
LepriceLe paramètre est utilisé pour définir le prix de la commande.
prix
vrai
Numéro
LeamountLe paramètre est utilisé pour définir le montant de la commande.
Le montant
vrai
Numéro
Paramètres étendus pouvant fournir des informations d'accompagnement à ce journal des commandes,argLes paramètres peuvent être passés à plus d'un.
arg
faux
chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système
function main() {
var id = exchange.Buy(100, 1);
Log("id:", id);
}
def main():
id = exchange.Buy(100, 1)
Log("id:", id)
void main() {
auto id = exchange.Buy(100, 1);
Log("id:", id);
}
Le numéro d'ordre renvoyé parexchange.Buy()peut être utilisé pour interroger les informations de commande et annuler la commande.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error call
def main():
exchange.SetContractType("quarter")
exchange.SetDirection("sell")
id = exchange.Buy(50, 1)
exchange.SetDirection("buy")
id2 = exchange.Sell(60, 1)
exchange.SetDirection("closebuy")
id3 = exchange.Buy(-1, 1)
exchange.SetDirection("closesell")
id4 = exchange.Sell(-1, 1)
// The following is an error call
void main() {
exchange.SetContractType("quarter");
exchange.SetDirection("sell");
auto id = exchange.Buy(50, 1);
exchange.SetDirection("buy");
auto id2 = exchange.Sell(60, 1);
exchange.SetDirection("closebuy");
auto id3 = exchange.Buy(-1, 1);
exchange.SetDirection("closesell");
auto id4 = exchange.Sell(-1, 1);
}
Lors de la passation d'un ordre pour un contrat à terme de crypto-monnaie, il faut veiller à ce que la direction du commerce soit correctement définie, car un décalage entre la direction du commerce et la fonction de commerce entraînera une erreur:
direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell
// For example, the trading pair: ETH_BTC, place a buy order at the market price
function main() {
// Place a buy order at the market price and buy ETH coins with a value of 0.1 BTC (denominated currency)
exchange.Buy(-1, 0.1)
}
def main():
exchange.Buy(-1, 0.1)
void main() {
exchange.Buy(-1, 0.1);
}
Commande au comptant.
Lorsque vous passez un ordre pour un contrat à terme, vous devez faire attention à savoir si la direction du commerce est correctement définie, car une erreur sera signalée si la direction du commerce et la fonction du commerce ne correspondent pas.
Le paramètrepriceest réglée sur-1pour placer des ordres de marché, ce qui nécessite que l'interface de placement des ordres de l'échange supporte les ordres de marché.amountest le montant de l'argent dans la devise de l'ordre.amountest le nombre de contrats. Il y a quelques échanges de crypto-monnaie qui ne prennent pas en charge l'interface d'ordre de marché pendant la négociation en direct. La quantité d'ordre pour les ordres d'achat de marché sur certains échanges au comptant est le nombre de pièces de monnaie de négociation. Veuillez vous référer auInstructions spéciales pour les échangesPour plus de détails, voir le Idde l'annéeexchange.Buy()fonction peut être différente de la valeur de retour de l'ordreIddécrits dans le présent document.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Leexchange.Sell()fonction est utilisée pour placer des ordres de vente.
Une commande réussie renvoie l'identifiant de commande, une commande ratée renvoie une valeur nulle.IdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de la paire de négociation au comptantETH_USDTl'ordre de l'échange OKX est le suivant:ETH-USDT,1547130415509278720Lorsque vous appelez leexchange.Sell()fonction pour passer une commande, la commande de retour de valeurIdest conforme à laIdattribute de la structure de l'ordre {@struct/Order Order}.
chaîne, valeur nulle
échange.Vente (prix, montant) échange.Vente ((prix, montant,... arguments)
LepriceLe paramètre est utilisé pour définir le prix de la commande.
prix
vrai
Numéro
LeamountLe paramètre est utilisé pour définir le montant de la commande.
Le montant
vrai
Numéro
Paramètres étendus pouvant fournir des informations d'accompagnement à ce journal des commandes,argLes paramètres peuvent être passés à plus d'un.
arg
faux
chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système
function main(){
var id = exchange.Sell(100, 1)
Log("id:", id)
}
def main():
id = exchange.Sell(100, 1)
Log("id:", id)
void main() {
auto id = exchange.Sell(100, 1);
Log("id:", id);
}
Le numéro d'ordre renvoyé parexchange.Sell()peut être utilisé pour interroger les informations relatives aux commandes et annuler les commandes.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error call
def main():
exchange.SetContractType("quarter")
exchange.SetDirection("sell")
id = exchange.Buy(50, 1)
exchange.SetDirection("buy")
id2 = exchange.Sell(60, 1)
exchange.SetDirection("closebuy")
id3 = exchange.Buy(-1, 1)
exchange.SetDirection("closesell")
id4 = exchange.Sell(-1, 1)
// The following is an error call
void main() {
exchange.SetContractType("quarter");
exchange.SetDirection("sell");
auto id = exchange.Buy(50, 1);
exchange.SetDirection("buy");
auto id2 = exchange.Sell(60, 1);
exchange.SetDirection("closebuy");
auto id3 = exchange.Buy(-1, 1);
exchange.SetDirection("closesell");
auto id4 = exchange.Sell(-1, 1);
}
Lors de la passation d'un ordre pour un contrat à terme de crypto-monnaie, il faut veiller à ce que la direction du commerce soit correctement définie, car un décalage entre la direction du commerce et la fonction de commerce entraînera une erreur:
direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell
// For example, the trading pair: ETH_BTC, place a sell order at the market price
function main() {
// Note: place a market order to sell, sell 0.2 ETH
exchange.Sell(-1, 0.2)
}
def main():
exchange.Sell(-1, 0.2)
void main() {
exchange.Sell(-1, 0.2);
}
Commande au comptant.
Lorsque vous passez un ordre pour un contrat à terme, vous devez faire attention à savoir si la direction du commerce est correctement définie, car une erreur sera signalée si la direction du commerce et la fonction de trading ne correspondent pas.
Le paramètrepriceest réglée sur-1pour la passation d'ordres de marché, ce qui nécessite que l'interface de passation d'ordres de l'échange soutienne les ordres de marché.amountest le montant en monnaie de négociation.amountIl y a quelques échanges de crypto-monnaie qui ne prennent pas en charge l'interface d'ordre de marché lors de la négociation en direct.
Si vous utilisez une ancienne version du docker, la valeur de retour de l'ordreIdde l'annéeexchange.Sell()fonction peut être différente de la valeur de retour de l'ordreIddécrits dans le présent document.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Leexchange.CreateOrder()La fonction est utilisée pour passer une commande.
Si l'ordre est placé avec succès, l'identifiant de commande est renvoyé; si l'ordre échoue, une valeur nulle est renvoyée.IdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de l'ordre de la paire de négociation au comptantETH_USDTde la bourse OKX est:ETH-USDT,1547130415509278720Lorsque vous appelez leexchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande, la valeur retournée de l'ordreIdest conforme à laIdpropriété de la structure de l'ordre {@struct/Order Order}.
chaîne, valeur nulle
Créer un ordre (symbole, côté, prix, montant) L'échange.CréerOrder (symbole, côté, prix, montant,... arguments)
Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code du contrat de l'ordre.exchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande,exchangeest l'objet d'échange au comptant. Si la monnaie libellée de l'ordre est l'USDT et la monnaie de négociation est le BTC, le paramètresymbolest:"BTC_USDT", dans le format de la paire de négociation définie par la plateforme FMZ.exchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande,exchangeest l'objet de l'échange de contrats à terme.symbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère exchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande,exchangeest l'objet de l'échange de contrats à terme.symbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), et le format est une combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère sideParamètre utilisé pour spécifier la direction de négociation de l'ordre.
Pour les objets d'échange au comptant, les valeurs facultatives desideLes paramètres sont:buy, sell. buysignifie acheter, etsellÇa veut dire vendre.
Pour les objets d'échange de contrats à terme, les valeurs facultatives desideLes paramètres sont:buy, closebuy, sell, closesell. buydésigne l'ouverture d'une position longue,closebuysignifie la clôture d'une position longue,selldésigne l'ouverture d'une position courte, etclosesellsignifie la clôture d'une position courte.
côté
vrai
chaîne
Le paramètrepriceUn prix de -1 indique que l'ordre est un ordre de marché.
prix
vrai
Numéro
Le paramètreamountest utilisé pour définir la quantité d'ordre. Veuillez noter que lorsque l'ordre est un ordre d'achat sur le marché, la quantité d'ordre est le montant d'achat; la quantité d'ordre de l'ordre d'achat sur le marché de certaines bourses à vue est le nombre de pièces de monnaie de négociation.Instructions spéciales pour les échangesdans le argles paramètres peuvent être passés.
arg
faux
Tout type pris en charge par le système, tel que chaîne, nombre, bool, objet, tableau, valeur nulle, etc.
function main() {
var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
}
def main():
id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) # Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
# id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) # Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
void main() {
auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01); // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01); // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id);
}
Les objets d'échange au comptant et les objets d'échange à terme s'appellentexchange.CreateOrder()fonction pour passer une commande.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Buy.Buy.Buy}, {@fun/Trade/Exchange.Buy.Buy}
Leexchange.CancelOrder()La fonction est utilisée pour annuler la commande.
L'attributIdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de l'ordre de la paire de négociation au comptantETH_USDTde la bourse OKX est:ETH-USDT,1547130415509278720- Je ne sais pas.
Le paramètreorderIdIl est passé à l'appelexchange.CancelOrder()La fonction d'annulation d'une commande est conforme à laIdpropriété de la structure de l'ordre {@struct/Order Order}.
Leexchange.CancelOrder()la fonction renvoie une valeur vraie, par exempletruesignifie que la demande d'ordre d'annulation a été envoyée avec succès.false, signifie que la demande d'ordre d'annulation n'a pas été envoyée. La valeur renvoyée représente uniquement le succès ou l'échec de la demande envoyée pour déterminer si l'échange annule l'ordre.exchange.GetOrders()pour déterminer si l'ordre est annulé.
Boole
Échange.Annuler la commande ((Identifier la commande) Échange.Annuler la commande ((Identifier la commande,... arguments)
LeorderIdLe paramètre est utilisé pour spécifier l'ordre à annuler.
commandé
vrai
Numéro, chaîne
Paramètres étendus, vous pouvez exécuter les informations jointes à ce journal de retrait,argLes paramètres peuvent être passés à plus d'un.
arg
faux
chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système
function main(){
var id = exchange.Sell(99999, 1)
exchange.CancelOrder(id)
}
def main():
id = exchange.Sell(99999, 1)
exchange.CancelOrder(id)
void main() {
auto id = exchange.Sell(99999, 1);
exchange.CancelOrder(id);
}
Annuler la commande.
function main() {
if (exchange.GetName().includes("Futures_")) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
}
var ticker = exchange.GetTicker()
exchange.Buy(ticker.Last * 0.5, 0.1)
var orders = exchange.GetOrders()
for (var i = 0 ; i < orders.length ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i])
Sleep(500)
}
}
def main():
if exchange.GetName().find("Futures_") != -1:
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
ticker = exchange.GetTicker()
exchange.Buy(ticker["Last"] * 0.5, 0.1)
orders = exchange.GetOrders()
for i in range(len(orders)):
exchange.CancelOrder(orders[i]["Id"], "Cancelled orders:", orders[i])
Sleep(500)
void main() {
if (exchange.GetName().find("Futures_") != std::string::npos) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.");
exchange.SetContractType("swap");
exchange.SetDirection("buy");
}
auto ticker = exchange.GetTicker();
exchange.Buy(ticker.Last * 0.5, 0.1);
auto orders = exchange.GetOrders();
for (int i = 0 ; i < orders.size() ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i]);
Sleep(500);
}
}
Fonctions d'API FMZ pouvant produire des fonctions de sortie de log tels que:Log(), exchange.Buy(), exchange.CancelOrder()peuvent être suivies de quelques paramètres de sortie d'accompagnement après les paramètres nécessaires.exchange.CancelOrder(orders[i].Id, orders[i]), de sorte que lors de l' annulation de la commande dont l' ID estorders[i].Id, l'information de l'ordre est produite avec elle.orders[i].
Si vous utilisez une ancienne version du docker, le paramètre orderId de la fonction exchange.CancelOrder() peut être différent de l'orderId décrit dans le document actuel.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Sell exchange.GetOrders}
Leexchange.GetOrder()La fonction est utilisée pour obtenir les informations de commande.
Rechercher les détails de l'ordre selon le numéro d'ordre, et retourner la structure {@struct/Order Order} si la requête réussit, ou retourner null si la requête échoue. {@struct/Order Order}, valeur nulle
Je ne sais pas si c'est le cas.
LeorderIdLe paramètre est utilisé pour spécifier l'ordre à interroger.
L'attributIdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de l'ordre de la paire de négociation au comptantETH_USDTde la bourse OKX est:ETH-USDT,1547130415509278720- Je ne sais pas.
Le paramètreorderIdIl est passé à l'appelexchange.GetOrder()La fonction de requête d'une commande est compatible avec laIdpropriété de la structure de l'ordre {@struct/Order Order}.
commandé vrai chaîne
function main(){
var id = exchange.Sell(1000, 1)
// Parameter id is the order number, you need to fill in the number of the order you want to query
var order = exchange.GetOrder(id)
Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}
def main():
id = exchange.Sell(1000, 1)
order = exchange.GetOrder(id)
Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:",
order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])
void main() {
auto id = exchange.Sell(1000, 1);
auto order = exchange.GetOrder(id);
Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}
Leexchange.GetOrder()La fonction n'est pas prise en charge par certains échanges.AvgPriceL'attribut dans la structure {@struct/Order Order} de la valeur de retour est le prix moyen de la transaction. Certains échanges ne prennent pas en charge ce champ, et s'ils ne le font pas, il est défini sur 0.
Si vous utilisez une ancienne version du docker, leorderIdparamètre duexchange.GetOrder()fonction peut différer de laorderIddécrits dans la documentation actuelle.
Les échanges qui ne soutiennent pas leexchange.GetOrder()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| Obtenir un ordre | Il y a un autre problème. | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/HistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders},
Leexchange.GetOrders()La fonction est utilisée pour obtenir des commandes en suspens.
Leexchange.GetOrders()la fonction renvoie un tableau de structures {@struct/Order Order} si la demande de données est réussie, et elle renvoie des valeurs nulles si la demande de données échoue.
{@struct/Order Order} tableau, valeur nulle
Je suis en train d' échanger des ordres. Les commandes (symbole)
Le paramètresymbolest utilisé pour régler lesymbole de transactionougamme de symboles de transactionPour être interrogé.
Pour les objets d'échange au comptant, sisymbolsi le paramètre n'est pas passé, les données de commande incomplètes de tous les produits au comptant seront demandées.
Pour les objets d'échange de contrats à terme,symbolsi le paramètre n'est pas passé, la valeur par défaut est de demander les données d'ordre incomplètes de toutes les variétés dans la gamme de dimensions de la paire de négociation et du code de contrat en cours.
le symbole faux chaîne
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
}
var spotOrders = exchange.GetOrders()
var tbls = []
for (var orders of [spotOrders]) {
var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)
spotOrders = exchange.GetOrders()
tbls = []
for orders in [spotOrders]:
tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
}
auto spotOrders = exchange.GetOrders();
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {spotOrders};
for (const auto& orders : arr) {
json tbl = R"({
"type": "table",
"title": "test GetOrders",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back("Symbol");
arrJson.push_back("Id");
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
Utilisez l'objet de change au comptant pour passer des ordres d'achat pour plusieurs paires de transactions différentes à la moitié du prix actuel, puis interrogez les informations sur les ordres en cours.
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
}
var defaultOrders = exchange.GetOrders()
var swapOrders = exchange.GetOrders("USDT.swap")
var futuresOrders = exchange.GetOrders("USDT.futures")
var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
var tbls = []
var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for (var index in arr) {
var orders = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)
defaultOrders = exchange.GetOrders()
swapOrders = exchange.GetOrders("USDT.swap")
futuresOrders = exchange.GetOrders("USDT.futures")
btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
tbls = []
arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for index in range(len(arr)):
orders = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
}
auto defaultOrders = exchange.GetOrders();
auto swapOrders = exchange.GetOrders("USDT.swap");
auto futuresOrders = exchange.GetOrders("USDT.futures");
auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
for (int index = 0; index < arr.size(); index++) {
auto orders = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back(order.Symbol);
arrJson.push_back(to_string(order.Id)); // The Id attribute type in the Order structure is TId, which is encoded using a C++ function to_string built into the FMZ platform.
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
Utilisez des objets d'échange de contrats à terme pour passer des ordres pour plusieurs paires de transactions et codes de contrats différents.
function main() {
var orders = exchange.GetOrders("BTC_USDT") // Examples of spot products
// var orders = exchange.GetOrders("BTC_USDT.swap") // Examples of futures products
Log("orders:", orders)
}
def main():
orders = exchange.GetOrders("BTC_USDT") # Examples of spot products
# orders = exchange.GetOrders("BTC_USDT.swap") # Examples of futures products
Log("orders:", orders)
void main() {
auto orders = exchange.GetOrders("BTC_USDT"); // Examples of spot products
// auto orders = exchange.GetOrders("BTC_USDT.swap"); // Examples of futures products
Log("orders:", orders);
}
Lorsque vous appelez leexchange.GetOrders()fonction, passer dans leSymbolparamètre permettant de demander des données d'ordre pour une paire de négociation spécifique et le code du contrat.
Dans leGetOrdersfonction, les scénarios d'utilisation du paramètre symbole sont résumés comme suit:
| Classification des objets Exchange | Symbole Paramètres | Portée de la requête | Nom de l'entreprise |
|---|---|---|---|
| Le point | Ne pas passer le paramètre de symbole | Rechercher toutes les paires de négociation au comptant | Pour tous les scénarios d'appel, si l'interface d'échange ne le prend pas en charge, une erreur sera signalée et une valeur nulle sera renvoyée. |
| Le point | Indiquer le type de négociation, le paramètre du symbole est: |
Rechercher la paire de négociation BTC_USDT spécifiée | Pour les objets de change au comptant, le format du paramètre du symbole est: |
| Les contrats à terme | Ne pas passer le paramètre de symbole | Rechercher tous les produits de négociation dans la gamme de dimensions de la paire de négociation et du code du contrat en cours | Si la paire de trading actuelle est BTC_USDT et que le code du contrat est swap, tous les contrats perpétuels à marge USDT seront interrogés.GetOrders("USDT.swap") |
| Les contrats à terme | Indiquer le type de négociation, le paramètre du symbole est: |
Rechercher le contrat perpétuel basé sur USDT pour un BTC spécifié | Pour les objets d'échange de contrats à terme, le format du symbole du paramètre est:paire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par les caractères".. |
| Les contrats à terme | Spécifier la gamme de produits de négociation, le paramètre du symbole est: |
Rechercher tous les contrats perpétuels basés sur USDT | - |
| Échanges de contrats à terme qui prennent en charge les options | Ne pas passer le paramètre de symbole | Rechercher tous les contrats d'options dans la plage de dimension de la paire de négociation en cours | Si la paire de négociation actuelle est BTC_USDT, le contrat est défini sur un contrat d'option, par exemple, le contrat d'option Binance: BTC-240108-40000-C |
| Échanges de contrats à terme qui prennent en charge les options | Spécifier les produits commerciaux spécifiques | Rechercher le contrat d' option spécifié | Par exemple, pour Binance Futures Exchange, le paramètre du symbole est le suivant: BTC_USDT.BTC-240108-40000-C |
| Échanges de contrats à terme qui prennent en charge les options | Spécifiez la gamme de produits de négociation, le paramètre du symbole est: |
Rechercher tous les contrats d'options basés sur USDT | - |
Dans leGetOrdersfonction, la requête de l'objet d'échange à terme
la plage de dimensions est résumée comme suit:
| Symbole Paramètres | Définition de la plage de demande | Nom de l'entreprise |
|---|---|---|
| USDT.swap | la valeur de l'échange est la valeur de l'échange à terme. | Pour |
les dimensions qui ne sont pas prises en charge par l'interface API d'échange, une erreur sera signalée et une valeur nulle sera renvoyée lorsque Je vous appelle. Une gamme de contrats de livraison basés sur USDT. Une gamme de change perpétuel basé sur la devise Des contrats. Une gamme de livraison basée sur la devise Des contrats. Une gamme d'options basée sur USDT. L'option USD est basée sur la variété des contrats d'options. Une gamme de combinaisons de CFD. Les échanges de dérivés futures. Une gamme de contrats de livraison de marge mixte. Je suis en train d'écrire un livre. Une gamme de contrats perpétuels à marge mixte. Je suis en train d'essayer de vous aider.
Lorsque le compte représenté par l'objet d'échangeexchangen'a pas d'ordres en attente dans leplage de requêteouinstruments de négociation spécifiques(ordres actifs dans un état non rempli), l'appel de cette fonction renvoie un tableau vide, c'est à dire:[]Je suis désolée.
Les échanges suivants exigent que l'instrument passe dans le paramètre de l'instrument lors de la requête des ordres actuellement inachevés. Lors de l'appel de la fonction GetOrders avec ces échanges, si le paramètre de l'instrument n'est pas passé, seuls les ordres inachevés de l'instrument actuel sont demandés, pas les ordres inachevés de tous les instruments (car l'interface d'échange ne le prend pas en charge).
Il a été vendu à des entreprises comme Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE.
Les échanges qui ne soutiennent pas leexchange.GetOrders()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| Obtenir des ordres | – | Les échanges à terme |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder.GetOrder}, {@
Leexchange.GetHistoryOrders()Cette fonction permet d'obtenir la paire de négociation en cours, les ordres historiques pour les contrats; elle permet de spécifier des variétés de négociation spécifiques.
Leexchange.GetHistoryOrders()fonction renvoie un tableau de structures {@struct/Order Order} si la demande de données est réussie, et nul si la demande échoue.
{@struct/Order Order} tableaux, valeurs nulles
Les commandes de l' échange.GetHistory Les commandes d'échange.GetHistory (symbole) Je ne sais pas comment faire. Les commandes d'exchange.GetHistory (symbole, depuis, limite) Je ne peux pas faire ça. Les commandes de l'historique (depuis)
LesymbolLe paramètre est utilisé pour spécifier le symbole commercial.BTC_USDTPar exemple, lorsque leexchangeest un objet d'échange au comptant, le format de paramètre poursymbolestBTC_USDT; si il s'agit d'un objet d'échange de contrats à terme, en prenant par exemple le contrat perpétuel, le format de paramètre poursymbolest:BTC_USDT.swapJe suis désolée.
Si vous interrogez les données d'ordre des contrats d'option, définissez le paramètresymbolà"BTC_USDT.BTC-240108-40000-C"Le format est une combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère
le symbole
faux
chaîne
LesinceLe paramètre est utilisé pour spécifier l'horodatage de début de la requête en millisecondes.
depuis
faux
Numéro
LelimitLe paramètre est utilisé pour spécifier le nombre d'ordres à interroger.
limite
faux
Numéro
function main() {
var historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
}
def main():
historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
void main() {
auto historyOrders = exchange.GetHistoryOrders();
Log(historyOrders);
}
symbol, since, limitLes paramètres ne sont pas spécifiés, la requête par défaut est la paire de négociation actuelle, les ordres historiques de contrat.symbolSi le paramètre est spécifié, interroger l'historique des ordres pour le type de transaction défini.sinceParamètre est spécifié, requête dans le sens de l'heure actuelle en utilisant lesincel'horodatage comme heure de début.limitparamètre est spécifié, la requête est renvoyée après un nombre suffisant d'entrées.Les échanges qui ne soutiennent pas leexchange.GetHistoryOrders()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| Les commandes GetHistory | Il est également disponible en téléchargement gratuit. | Les états financiers des États membres sont définis par le règlement (UE) no 575/2013. |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder}
exchange.SetPrecision()fonction est utilisée pour régler la précision duexchangeobjet d'échangeprixetmontant de la commande, le système ignore automatiquement les données excédentaires.
Je ne sais pas si je peux le faire.
LepricePrecisionLe paramètre est utilisé pour contrôler la précision des données sur les prix.
prixPrécision
vrai
Numéro
LeamountPrecisionParamètre utilisé pour contrôler la précision de la quantité de données à commander.
Montant précise
vrai
Numéro
function main(){
// Set the decimal precision of price to 2 bits, and the decimal precision of variety order amount to 3 bits
exchange.SetPrecision(2, 3)
}
def main():
exchange.SetPrecision(2, 3)
void main() {
exchange.SetPrecision(2, 3);
}
Le système de backtesting ne prend pas en charge cette fonction, et la précision numérique du système de backtesting est gérée automatiquement.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Buy.Buy.Buy}, {@fun/Trade/Exchange.Buy.Buy}
Définir le taux de change actuel de l'objet d'échange.
Le taux d'échange.SetRate
LerateLe paramètre est utilisé pour spécifier le taux de conversion.
taux
vrai
Numéro
function main(){
Log(exchange.GetTicker())
// Set exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
// Set to 1, no conversion
exchange.SetRate(1)
}
def main():
Log(exchange.GetTicker())
exchange.SetRate(7)
Log(exchange.GetTicker())
exchange.SetRate(1)
void main() {
Log(exchange.GetTicker());
exchange.SetRate(7);
Log(exchange.GetTicker());
exchange.SetRate(1);
}
Si une valeur de taux de change a été fixée en utilisant leexchange.SetRate()Ensuite, toutes les informations de prix telles que les tickers, les profondeurs, les prix des commandes, etc. pour l'échange représenté par le courantexchangeL'objet de change sera converti en le multipliant par le taux de change fixé de 7.exchangeest un échange avec le dollar américain comme monnaie.exchange.SetRate(7), tous les prix sur le marché en direct seront convertis en prix proches deRésultats de l'enquêteNominalité multipliée par 7.
{@fun/Marché/échange.GetRate échange.GetRate}
Leexchange.IO()la fonction est utilisée pour d'autres appels d'interface liés à l'objet d'échange.
Leexchange.IO()La fonction appelle d'autres interfaces liées à l'objet d'échange, renvoyant les données de réponse demandées lors d'un appel réussi et elle renvoie null lors d'un appel raté.
chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système
exchange.IO(k,... args)
Lekparamètre est utilisé pour définir le type d'appel, avec des valeurs facultatives"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedet ainsi de suite.
K
vrai
chaîne
Paramètres étendus, passés selon le scénario d'appel spécifique,argEn raison du mécanisme polymorphe de laexchange.IO()Le nombre et le type de paramètres correspondent aux fonctions de l'appareil.exchange.IO()Les fonctions sont indéterminées.
arg
vrai
chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système
function main() {
var arrOrders = [
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
]
// Call exchange.IO to access the exchange's bulk order interface directly
var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
Log(ret)
}
import json
def main():
arrOrders = [
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
]
ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
Log(ret)
void main() {
json arrOrders = R"([
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
{"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
])"_json;
auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
Log(ret);
}
En utilisant leexchange.IO("api", httpMethod, resource, params, raw)Le formulaire d'appelexchange.IO()Il est nécessaire de comprendre l'interface API de l'échange et de vérifier d'abord la documentation pertinente.POSTla demande ne vous oblige pas à vous soucier du chiffrement, de la signature ou de la vérification des paramètres, qui sont déjà gérés par FMZ en bas, tant que vous remplissez les paramètres correspondants.Échange OKXles contrats à terme, et utiliser le paramètrerawpour passer les paramètres d'ordre:
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// Note that both amount.toString() and price.toString() have a ' character on the left and right side
var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
var id = exchange.IO("api", "POST", "/v1/order/new", message)
}
amount = 1
price = 10
basecurrency = "ltc"
def main():
message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
id = exchange.IO("api", "POST", "/v1/order/new", message)
void main() {
auto amount = 1.0;
auto price = 10.0;
auto basecurrency = "ltc";
string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}
Si la valeur clé dans leparamsparamètre (par exemple, paramètre de demande HTTP) est une chaîne, il doit être écrit en guillemets simples (par exemple, le symbole ') autour de la valeur du paramètre pour envelopper la valeur du paramètre.
function main() {
var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
Log(ret);
}
Il prend en charge le passage de paramètres d'url complets, ce qui peut omettre l'opération de commutation de l'adresse de base (appelant leexchange.SetBase()fonction).
function main(){
var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
Log(ret);
}
Exemple d'appel sans paramètreraw:
function main() {
// For example, if you set the current trading pair of the exchange object to BTC_USDT at the beginning of the live trading, print the current trading pair tickers
Log(exchange.GetTicker())
// Switch the trading pair to LTC_BTC
exchange.IO("currency", "LTC_BTC")
Log(exchange.GetTicker())
}
def main():
Log(exchange.GetTicker())
exchange.IO("currency", "LTC_BTC")
Log(exchange.GetTicker())
void main() {
Log(exchange.GetTicker());
exchange.IO("currency", "LTC_BTC");
Log(exchange.GetTicker());
}
Modifier la paire de négociation de l'échange actuel, de sorte qu'il changera la paire de négociation configurée par codelors de la création de transactions en directouau backtest.
function main () {
// exchanges[0] is the first exchange object added when the live trading is created
exchanges[0].IO("base", "https://api.huobi.pro")
}
def main():
exchanges[0].IO("base", "https://api.huobi.pro")
void main() {
exchanges[0].IO("base", "https://api.huobi.pro");
}```
For example, the default base address when the exchange object is wrapped is ```https://api.huobipro.com```, and when you need to switch to ```https://api.huobi.pro```, use the following code to switch:
```javascript
function main() {
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
}
def main():
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
void main() {
exchange.SetBase("https://api.bitfinex.com");
exchange.IO("mbase", "https://api-pub.bitfinex.com");
}
Pour les bourses avec différentes adresses de base pour l'interface ticker et l'interface de trading, par exemple, Bitfinex Futures dispose de deux adresses, l'une pour l'interface ticker et l'autre pour l'interface de trading.exchange.SetBase("xxx")Les contrats à terme de Bitfinex changent d'adresse de base d'interface publique en utilisantexchange.IO("mbase", "xxx").
I. Pour les échanges centrés sur les crypto-monnaies, autres appels d'interface API qui ne sont pas uniformément encapsulés, avec paramètrekréglé sur"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, etc.URL.Leexchange.IO("api", httpMethod, resource, params, raw)l'appel de fonction accède à l'interface d'échange et renvoie null si l'appel échoue et qu'une erreur se produit.
Seul le commerce réel soutient l'appelexchange.IO("api", httpMethod, resource, params, raw) function.
II. Pour le changement de paires de négociation, le paramètrekest réglée sur"currency":
exchange.IO("currency", currency)
monnaie : Le paramètre est un type de chaîne avec un format majuscule uniforme, avec un trait de soulignement pour séparerbaseCurrencydequoteCurrency, tels queBTC_USDT.
ETH_BTCJe peux seulement passer àLTC_BTC, pas àLTC_USDT.exchange.IO("currency", currency)pour changer de paire de négociation.III. Utilisé pour basculer sur le mode de compte à effet de levier de l'objet de l'échange au comptant de crypto-monnaie:
kest réglée sur"trade_margin"Pour placer des ordres et obtenir des actifs de compte, vous aurez accès à l'interface à effet de levier au comptant de l'échange.
Si la bourse fait la distinction entre marge totale et marge isolée dans l'effet de levier au comptant, utiliser:exchange.IO("trade_super_margin")passer à la marge totale pour le compte à effet de levier, etexchange.IO("trade_margin")de passer à une marge isolée pour le compte à effet de levier.kest réglée sur"trade_normal"pour revenir au mode de compte au comptant normal.Échanges au comptant qui prennent en charge le passage entre les modèles de comptes à effet de levier:
| Les échanges | Remarques spéciales |
|---|---|
| - Ça va. | Les paires de trading en mode compte à effet de levier sont différentes des paires normales, certaines paires de trading peuvent ne pas les avoir.exchange.IO("trade_super_margin")passer à la position complète pour les comptes à effet de levier et utiliserexchange.IO("trade_margin")pour passer à la position par position.trade_normalutiliser le dispositif pour passer en mode spot normal.exchange.IO("tdMode", "cross")pour spécifier directement le mode d'effet de levier. |
| Huobi est un joueur. | Les paires de trading en mode compte à effet de levier sont différentes des paires normales, certaines paires de trading peuvent ne pas les avoir.trade_marginpour passer à un compte d'effet de levier position par position, utilisertrade_super_marginpour passer à la position complète du compte à effet de levier.trade_normalpour passer au mode monnaie-monnaie normal. |
| Binance | Le mode de compte à effet de levier est divisé en position par position et position totale, utilisationtrade_marginpour passer à position par position, utilisertrade_super_marginpour passer à la position complète, utilisertrade_normalpour passer au mode monnaie-monnaie normal. |
| La porte | Le mode de compte à effet de levier est divisé en position par position et position totale, utilisationtrade_marginpour passer à position par position, utilisertrade_super_marginpour passer à la position complète, utilisertrade_normalpour passer au mode monnaie-monnaie normal. |
| AscendEx | Utilisationexchange.IO("trade_margin")de passer au mode de compte à effet de levier etexchange.IO("trade_normal")pour revenir au mode de compte normal. |
| Je vous en prie! | Utilisationexchange.IO("trade_margin")de passer au mode de compte à effet de levier etexchange.IO("trade_normal")pour revenir au mode de compte normal. |
| CoinEx | Utilisationexchange.IO("trade_margin")de passer au mode de compte à effet de levier etexchange.IO("trade_normal")pour revenir au mode de compte normal. |
IV. Autres fonctions de commutationRegardez leexchange.IO()fonction pourAutres fonctions de commutationdans le guide de l'utilisateur.
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}
Leexchange.Log()fonction est utilisée pour produire le journal des commandes passées et retirées dans la zone de la colonne de journal.
échange.Log ((ordreTyp, prix, montant) Compte rendu de la commande type, prix, montant,... arguments
LeorderTypeLe paramètre est utilisé pour définir le type de journal de sortie, les valeurs optionnelles sont {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}.
ordreTypes
vrai
Numéro
LepriceLe paramètre est utilisé pour définir le prix affiché dans le journal de sortie.
prix
vrai
Numéro
LeamountParamètre utilisé pour définir le nombre de commandes passées affiché dans le journal de sortie.
Le montant
vrai
Numéro
Paramètres étendus pouvant fournir des informations d'accompagnement à ce journal,argLes paramètres peuvent être passés à plus d'un.
arg
faux
chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système
var id = 123
function main() {
// Order type buy, price 999, amount 0.1
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
// Cancel the order
exchange.Log(LOG_TYPE_CANCEL, id)
}
id = 123
def main():
exchange.Log(LOG_TYPE_BUY, 999, 0.1)
exchange.Log(LOG_TYPE_CANCEL, id)
void main() {
auto id = 123;
exchange.Log(LOG_TYPE_BUY, 999, 0.1);
exchange.Log(LOG_TYPE_CANCEL, id);
}
Utilisationexchange.Log(orderType, price, amount)L'un des scénarios les plus courants consiste à utiliser le {@fun/Trade/exchange.IOexchange.IOLa fonction d'accès à l'interface de l'échange pour la création d'ordres conditionnels, mais en utilisant leexchange.IO()La fonction n'affiche pas les informations du journal des transactions dans l'enregistrement du journal des transactions en direct.exchange.Log()Cette fonction peut être utilisée pour compléter le journal de sortie afin d'enregistrer les informations relatives au placement des commandes, de même que pour les opérations de retrait des commandes.
Lorsque leorderTypele paramètre estLOG_TYPE_CANCEL, lepriceParamètre est l'ordre Id de l'ordre retiré qui est utilisé pour imprimer le journal de retrait lorsque l'ordre est retiré directement en utilisant leexchange.IO()La fonctionexchange.Log()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}, par opposition à la fonction globale {@fun/Log Log}.
Le nombre de points de vente est calculé en fonction du nombre de points de vente.
Leexchange.Encode()fonction est utilisée pour les calculs de chiffrement de signature.
Leexchange.Encode()la fonction renvoie le codage de la valeur de hachage calculée.
chaîne
L'échange.Encode ((algo, entréeFormat, sortieFormat, données) Le code de l'appareil est le code de l'appareil.
Le paramètrealgoest l'algorithme utilisé pour le calcul du codage. Les paramètres pris en charge sont: algoIl prend également en charge: algosupporte également: algopeut être écrit comme ed25519.seedle calcul.
quelque chose
vrai
chaîne
Utilisé pour spécifier le format de données dudataParamètre.inputFormatle paramètre peut être défini sur l'un des paramètres suivants: hexcodé, base64encodé, et outputFormatparamètre prend en charge les paramètres suivants: hexcodé, base64encodé, et dataest les données à traiter.
données
vrai
chaîne
Utilisé pour spécifier le format de données dukeyParamètre.keyle paramètre peut être défini sur l'un des paramètres suivants: hexcodé, base64encodé, et keyparamètre est utilisé pour spécifier la clé utilisée dans le calcul de la signature, et il peut être utilisé comme une chaîne de texte brut."{{accesskey}}", "{{secretkey}}"pour faire référence à laaccessKeyetsecretKeyconfiguré dans l'objet d'échange {@var/EXCHANGE exchange}.
clé
faux
chaîne
function main() {
var APIKEY = "your Access Key(Bitmex API ID)"
var expires = parseInt(Date.now() / 1000) + 10
var signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
var client = Dial("wss://www.bitmex.com/realtime", 60)
var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
var pos = 0
client.write(auth)
client.write('{"op": "subscribe", "args": "position"}')
while (true) {
bitmexData = client.read()
if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
pos = parseInt(bitmexData.data[0].currentQty)
}
}
}
import time
def main():
APIKEY = "your Access Key(Bitmex API ID)"
expires = int(time.time() + 10)
signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
client = Dial("wss://www.bitmex.com/realtime", 60)
auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
pos = 0
client.write(auth)
client.write('{"op": "subscribe", "args": "position"}')
while True:
bitmexData = json.loads(client.read())
if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:
Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
pos = bitmexData["data"][0]["currentQty"]
void main() {
auto APIKEY = "your Access Key(Bitmex API ID)";
auto expires = Unix() + 10;
auto signature = exchange.Encode("sha256", "string", "hex", format("GET/realtime%d", expires), "hex", "{{secretkey}}");
auto client = Dial("wss://www.bitmex.com/realtime", 60);
json auth = R"({"args": [], "op": "authKeyExpires"})"_json;
auth["args"].push_back(APIKEY);
auth["args"].push_back(expires);
auth["args"].push_back(signature);
auto pos = 0;
client.write(auth.dump());
client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
while(true) {
auto bitmexData = json::parse(client.read());
if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
Log("test");
Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
pos = bitmexData["data"][0]["currentQty"];
}
}
}
Exemple de modification de position de BitMEX (protocole wss):
Seul le commerce réel soutient l'appelexchange.Encode()La fonction"{{accesskey}}", "{{secretkey}}"Les références ne sont valables que lorsque leexchange.Encode()fonction est utilisée.
{@var/EXCHANGE échange}, {@fun/Global/Encode Encode}
Les fonctions de support asynchrone à plusieurs fils peuvent transformer les opérations de toutes les fonctions prises en charge en exécution asynchrone simultanée.
Leexchange.Go()fonction renvoie un objet concurrent immédiatement, et vous pouvez utiliser lewait()méthode de cet objet concurrent pour obtenir le résultat de la requête concurrente.
objet
Métode d'échange (Go) L'échange.Méthode Go,... args)
Lemethodparamètre est utilisé pour spécifier le nom de la fonction concurrente. Notez que le paramètre est une chaîne de noms de fonction, pas une référence de fonction.
méthode
vrai
chaîne
Paramètres àexécutant simultanément des fonctions, il peut y avoir plusieurs paramètresarg. Le type et le nombre de paramètresargdépend des paramètres dufonction d'exécution simultanéeJe suis désolée.
arg
faux
chaîne, nombre, bool, objet, tableau, fonction, nul et tous les autres types pris en charge par le système
function main(){
// The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
var a = exchange.Go("GetTicker")
var b = exchange.Go("GetDepth")
var c = exchange.Go("Buy", 1000, 0.1)
var d = exchange.Go("GetRecords", PERIOD_H1)
// Call the wait method to wait for the return of the ticker results asynchronously
var ticker = a.wait()
// Returns the depth, or null if it fails
var depth = b.wait()
// return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait timeout
var orderId = c.wait(1000)
if(typeof(orderId) == "undefined") {
// Timeout, reacquire
orderId = c.wait()
}
var records = d.wait()
}
def main():
a = exchange.Go("GetTicker")
b = exchange.Go("GetDepth")
c = exchange.Go("Buy", 1000, 0.1)
d = exchange.Go("GetRecords", PERIOD_H1)
ticker, ok = a.wait()
depth, ok = b.wait()
orderId, ok = c.wait(1000)
if ok == False:
orderId, ok = c.wait()
records, ok = d.wait()
void main() {
auto a = exchange.Go("GetTicker");
auto b = exchange.Go("GetDepth");
auto c = exchange.Go("Buy", 1000, 0.1);
auto d = exchange.Go("GetRecords", PERIOD_H1);
Ticker ticker;
Depth depth;
Records records;
TId orderId;
a.wait(ticker);
b.wait(depth);
if(!c.wait(orderId, 300)) {
c.wait(orderId);
}
d.wait(records);
}
Exchange.Go()exemple d'utilisation de la fonction, pour déterminerundefinedà utilisertypeof(xx) === "undefined", parce quenull == undefinedest valide en JavaScript.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
var ret = d.wait()
}
def main():
d = exchange.Go("GetRecords", PERIOD_H1)
records, ok = d.wait()
ret, ok = d.wait()
void main() {
auto d = exchange.Go("GetRecords", PERIOD_H1);
Records records;
d.wait(records);
Records ret;
d.wait(ret);
}
On appelle lewait()la méthode sur un objet simultané qui a été libéré signalera une erreur:
function main() {
while(true) {
var beginTS = new Date().getTime()
var arrRoutine = []
var arrTicker = []
var arrName = []
for(var i = 0; i < exchanges.length; i++) {
arrRoutine.push(exchanges[i].Go("GetTicker"))
arrName.push(exchanges[i].GetName())
}
for(var i = 0; i < arrRoutine.length; i++) {
arrTicker.push(arrRoutine[i].wait())
}
var endTS = new Date().getTime()
var tbl = {
type: "table",
title: "ticker",
cols: ["index", "name", "latest-deal-price"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(500)
}
}
import time
import json
def main():
while True:
beginTS = time.time()
arrRoutine = []
arrTicker = []
arrName = []
for i in range(len(exchanges)):
arrRoutine.append(exchanges[i].Go("GetTicker"))
arrName.append(exchanges[i].GetName())
for i in range(len(exchanges)):
ticker, ok = arrRoutine[i].wait()
arrTicker.append(ticker)
endTS = time.time()
tbl = {
"type": "table",
"title": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
Sleep(500)
void main() {
while(true) {
int length = exchanges.size();
auto beginTS = UnixNano() / 1000000;
Ticker arrTicker[length] = {};
string arrName[length] = {};
// Note that to add several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
auto r0 = exchanges[0].Go("GetTicker");
auto r1 = exchanges[1].Go("GetTicker");
auto r2 = exchanges[2].Go("GetTicker");
auto r3 = exchanges[3].Go("GetTicker");
GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
for(int i = 0; i < length; i++) {
arrName[i] = exchanges[i].GetName();
}
for(int i = 0; i < length; i++) {
Ticker ticker;
arrRoutine[i]->wait(ticker);
arrTicker[i] = ticker;
}
auto endTS = UnixNano() / 1000000;
json tbl = R"({
"type": "table",
"title": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
})"_json;
for(int i = 0; i < length; i++) {
json arr = R"(["", "", ""])"_json;
arr[0] = format("%d", i);
arr[1] = arrName[i];
arr[2] = format("%f", arrTicker[i].Last);
tbl["rows"].push_back(arr);
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
Accès simultané à plusieurs tickers de change:
function main() {
/*
Testing with OKX futures order interface
POST /api/v5/trade/order
*/
var beginTS = new Date().getTime()
var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var id1 = ret1.wait()
var id2 = ret2.wait()
var id3 = ret3.wait()
var endTS = new Date().getTime()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond")
}
import time
import json
def main():
beginTS = time.time()
param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
id1, ok1 = ret1.wait()
id2, ok2 = ret2.wait()
id3, ok3 = ret3.wait()
endTS = time.time()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("Concurrent order placement time consumption:", endTS - beginTS, "second")
void main() {
auto beginTS = UnixNano() / 1000000;
json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
json id1 = R"({})"_json;
json id2 = R"({})"_json;
json id3 = R"({})"_json;
ret1.wait(id1);
ret2.wait(id2);
ret3.wait(id3);
auto endTS = UnixNano() / 1000000;
Log("id1:", id1);
Log("id2:", id2);
Log("id3:", id3);
Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}
Les appels concomitantsexchange.IO("api", ...)fonction:
Cette fonction crée uniquement des tâches d'exécution multi-threaded lors de l'exécution dans le commerce réel, le backtesting ne prend pas en charge l'exécution simultanée de tâches multi-threaded (le backtesting est disponible, mais toujours exécuté séquentiellement).
Après leexchange.Go()fonction renvoie un objet, sonwait()fonction est appelée à travers cet objet pour obtenir les données renvoyées par le fil.wait()La fonction doit être appelée pour obtenir les données avant que le fil ne soit libéré automatiquement.wait()Le résultat du thread doit être obtenu avant qu'il ne soit libéré automatiquement (indépendamment du succès ou de l'échec de l'appel d'interface pour l'accès simultané).wait()fonction indépendamment du succès ou de l'échec de l'exécution, et la ressource du fil demandée par leexchange.Go()La fonction doit être libérée automatiquement par le docker.
Lewait()la méthode prend en charge un paramètre de temps d'arrêt:
Sans paramètre de temps d'arrêt, c'est à dire,wait(), ou avec un paramètre de temps d'arrêt de 0, c'est-à-direwait(0)Lewait()blocs de fonction et attend que le thread concurrent ait terminé d'exécuter, renvoyant le résultat de l'exécution du thread concurrent.
Mettre le paramètre de temps d'arrêt -1, c'est à direwait(-1)Lewait()la fonction renvoie immédiatement, avec des valeurs de retour différentes pour différents langages de programmation, voir cette sous-section pour un exemple d'appel.
Définir le paramètre de temps d'arrêt spécifique,wait(300), et lewait()La fonction attend au maximum 300 millisecondes avant de revenir.
Si le résultat de retour de la finalewait()si la fonction n'est pas obtenue, les ressources de thread ne seront pas libérées automatiquement, ce qui entraînera l'accumulation des threads demandés, et plus de 2000 signalera une erreur:"too many routine wait, max is 2000"- Je ne sais pas.
Fonctions prises en charge:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Toutes ces fonctions sont exécutées sur la base de l'objet d'échange {@var/EXCHANGE exchange} en cours lorsqu'il est appelé simultanément.
La différence entre le langage Python et le langage JavaScript est que lewait()fonction d'objets concurrents dans le langage Python renvoie deux paramètres. Le premier paramètre est le résultat renvoyé par un appel API asynchrone, et le deuxième paramètre indique si l'appel asynchrone est terminé.
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok will return True definitely, unless the strategy is stopped
ret, ok = d.wait()
# If the wait times out, or if it waits for an instance that has already ended, ok returns False
ret, ok = d.wait(100)
Je ne sais pas si je peux vous aider, mais je vais vous aider.
Leexchange.GetAccount()La fonction est utilisée pour demander des informations sur les comptes de change.GetAccount()La fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}.exchangel'objet est uniquement lié àexchange, et il ne sera pas répété après la documentation.
Rechercher les informations sur l'actif du compte et renvoyer la structure {@struct/Account Account} si la requête réussit ou nul si elle échoue. {@struct/Account Account}, valeur nulle
Je suis en train de changer de compte.
function main(){
// Switching trading pairs
exchange.IO("currency", "BTC_USDT")
// Take OKX futures as an example, set the contract as the current week's contract, the current trading pair is BTC_USDT, so the current contract is BTC's U-nominal current week contract
exchange.SetContractType("this_week")
// Get current account asset data
var account = exchange.GetAccount()
// Available balance of USDT as margin
Log(account.Balance)
// USDT freeze amount as margin
Log(account.FrozenBalance)
// Current asset equity
Log(account.Equity)
// The unrealized profit and loss of all positions held with the current asset as margin
Log(account.UPnL)
}
def main():
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("this_week")
account = exchange.GetAccount()
Log(account["Balance"])
Log(account["FrozenBalance"])
Log(account["Equity"])
Log(account["UPnL"])
void main() {
exchange.IO("currency", "BTC_USDT");
exchange.SetContractType("this_week");
auto account = exchange.GetAccount();
Log(account.Balance);
Log(account.FrozenBalance);
Log(account["Equity"])
Log(account["UPnL"])
}
Configurez des paires de trading, des codes de contrat, et obtenez les informations du compte courant.
Si l'objet d'échange est défini sur un échange de contrats à terme de crypto-monnaie et basculé sur un contrat avecUSDTcomme marge (voir {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} pour les fonctions de commutation).USDTLa marge est enregistrée dans leBalance, FrozenBalanceles attributs de la structure {@struct/Account Account}.
Si l'objet de l'échange est défini sur un échange de contrats à terme de crypto-monnaie, et basé sur un contrat monétaire, l'actif est en monnaie sous forme de marge et est enregistré dans leStocks, FrozenStocksles attributs de la structure {@struct/Account Account}.
Lorsque vous utilisez le compte unifié Binance Futures, lorsque vous appelez leexchange.GetAccount()Les données encapsulées sont le montant de l'ensemble des actifs convertis enDépensesElle est affichée dans leBalanceSi vous avez besoin de calculer le montant de conversion des autres actifs, vous pouvez utiliser le montant de conversion en USD divisé par le prix de l'indice (de l'actif à convertir) puis divisé par le taux de mise en gage (de l'actif à convertir) pour le calcul.
{@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
Leexchange.GetAssetsfonction est utilisée pour demander des informations sur les actifs du compte de change.
Leexchange.GetAssets()fonction renvoie un tableau de structures {@struct/Asset Asset} si la demande de données est réussie, ou nul si la demande échoue.
{@struct/Asset Asset} tableau, valeur nulle
Je suis en train d' échanger.
function main() {
// exchange.SetCurrency("BTC_USDT") // You can set up trading pairs
// exchange.SetContractType("swap") // You can set up contracts
var assets = exchange.GetAssets()
Log(assets)
}
def main():
# exchange.SetCurrency("BTC_USDT") # You can set up trading pairs
# exchange.SetContractType("swap") # You can set up contracts
assets = exchange.GetAssets()
Log(assets)
void main() {
// exchange.SetCurrency("BTC_USDT"); // You can set up trading pairs
// exchange.SetContractType("swap"); // You can set up contracts
auto assets = exchange.GetAssets();
Log(assets);
}
Obtenez des informations sur les actifs d'un compte de change,exchange.GetAssets()renvoie un tableau contenant des éléments de la structure d'actifs.
LeGetAssets()La fonction de l'objet Futures Exchange renvoie les actifs de marge sous la paire de négociation en cours (basés sur la devise, sur l'USDT, sur l'USDC, etc.).
{@struct/Asset Asset} Les actifs sont des actifs
Leexchange.GetName()fonction est utilisée pour obtenir le nom de l'échange auquel l'objet d'échange actuel est lié.
Leexchange.GetName()Cette fonction renvoie le nom de la bourse définie par la plateforme de trading FMZ Quant.
chaîne
Je suis en train d' écrire un article.
function main() {
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance")
}
def main():
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance")
void main() {
Log("The exchange object exchange is judged to be Binance spot, and the result is judged to be:", exchange.GetName() == "Binance");
}
Leexchange.GetName()fonction est généralement utilisée pour identifier les objets d'échange, tels queexchangeouexchanges[1], exchanges[2]dans le code de stratégie. Les noms des bourses de contrats à terme de crypto-monnaie ont le préfixe fixeFutures_.
{@fun/Account/exchange.GetLabel échange.GetLabel} Je ne peux pas le faire.
Leexchange.GetLabel()fonction est utilisée pour obtenir l'étiquette personnalisée qui a été définie lorsque l'objet d'échange a été configuré.
Leexchange.GetLabel()fonction renvoie l'étiquette personnalisée qui a été définie lors de la configuration de l'objet d'échange.
chaîne
Je suis en train de changer.GetLabel
function main() {
Log("exchange label:", exchange.GetLabel())
}
def main():
Log("exchange label:", exchange.GetLabel())
void main() {
Log("exchange label:", exchange.GetLabel());
}
Objets d'échange tels queexchangeouexchanges[1], exchanges[2]dans le code de stratégie sont identifiés par l'étiquette set.
{@var/EXCHANGE échange}
Leexchange.GetCurrency()La fonction est utilisée pour obtenir la paire de négociation actuellement définie.
Leexchange.GetCurrency()La fonction renvoie la paire de négociation définie par l'objet d'échange {@var/EXCHANGE exchange} en cours.
chaîne
Je suis en train de changer de monnaie.
function main() {
Log("the current trading pair of exchange is:", exchange.GetCurrency())
}
def main():
Log("the current trading pair of exchange is:", exchange.GetCurrency())
void main() {
Log("the current trading pair of exchange is:", exchange.GetCurrency());
}
Le format de la paire de négociation est en majuscules uniformément, en utilisant des soulignements pour séparerbaseCurrencyetquoteCurrency, tels queBTC_USDT.
{@fun/Account/exchange.SetÉchange de devise.SetÉchange de devise}
Leexchange.SetCurrency()fonction est utilisée pour basculer la paire de négociation courante de l'objet d'échange {@var/EXCHANGE exchange}.
échange.SetMonnaie (monnaie)
LecurrencyLe format de la paire de trading est en majuscules uniformément, en utilisant un soulignement pour séparerbaseCurrencydequoteCurrency, tels queBTC_USDT- Je ne sais pas.
monnaie
vrai
chaîne
function main() {
var ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
// Switching trading pairs, pay attention to the changes of ticker data and account information after switching
exchange.SetCurrency("LTC_USDT")
Log("Switch to LTC_USDT")
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
}
def main():
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
exchange.SetCurrency("LTC_USDT")
Log("Switch to LTC_USDT")
ticker = exchange.GetTicker()
Log(ticker)
Log(exchange.GetAccount())
void main() {
auto ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
exchange.SetCurrency("LTC_USDT");
Log("Switch to LTC_USDT");
ticker = exchange.GetTicker();
Log(ticker);
Log(exchange.GetAccount());
}
exchange.IO("currency", "BTC_USDT")méthode de commutation, veuillez consulter {@funexcahnge.IO}.BTC_USDTpeut être basculé versLTC_USDT, pas àLTC_BTC.BTC_USDT, le nombre deBTCest 3, le nombre deUSDTà ce moment, passez àLTC_USDTimmédiatement, le nombre de devises négociées est égal à 0 après le passage, c'est-à-dire le nombre deLTC_USDTdans le compte est de 0, c'est-à-dire le nombre deLTCsur le compte est égal à 0, et la paire de négociation échangée partage le nombre deUSDT, ce qui est 10 000.{@fun/Account/exchange.GetCurrency échange.GetCurrency} Je suis désolé.
Leexchange.GetQuoteCurrency()la fonction est utilisée pour obtenir le nom de la monnaie libellée de la paire de négociation en cours, c'est-à-direquoteCurrency.
Leexchange.GetQuoteCurrency()La fonction renvoie le nom de la devise libellée de la paire de négociation en cours.
chaîne
La monnaie de l'échange.GetQuoteCurrency
function main() {
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency())
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
}
def main():
exchange.SetCurrency("BTC_USDT")
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency())
# exchange.SetCurrency("ETH_BTC")
# Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
void main() {
exchange.SetCurrency("BTC_USDT");
Log("BTC_USDT denominated currency name:", exchange.GetQuoteCurrency());
// exchange.SetCurrency("ETH_BTC")
// Log("ETH_BTC denominated currency name:", exchange.GetQuoteCurrency())
}
Par exemple: {@var/EXCHANGE exchange} est la paire de transactions courante de l'objet d'échangeBTC_USDT, leexchange.GetQuoteCurrency()Retour de la fonctionUSDT. Si la paire de négociation actuelle estETH_BTC, leexchange.GetQuoteCurrency()Retour de la fonctionBTC.
{@fun/Account/exchange.GetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Account/exchange.SetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency}, {@fun/Account/exchange.SetCurrency.GetCurrency.GetCurrency.GetCurrency}, {@fun/Account/exchange.SetCurrency.SetCurrency}
Leexchange.GetPositions()La fonction est utilisée pour obtenir les informations de position;GetPositions()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}.GetPositions()fonction obtient les informations de position du compte de change lié à l'objet de changeexchangeLe but des fonctions (méthodes) des membres duexchangel'objet est uniquement lié àexchangeet ne se reproduira pas ici.
Leexchange.GetPositions()la fonction renvoie un tableau de structures {@struct/Position Position} si la demande de données est réussie, et elle renvoie une valeur nulle si la demande de données échoue.
{@struct/Position Position} les tableaux, les valeurs nulles
Je suis en train de changer de position. Je suis en train d'écrire une lettre.
Le paramètresymbolest utilisé pour régler lesymbole de négociationougamme de symboles de négociationPour être interrogé.
Si lesymbolsi le paramètre n'est pas passé, la valeur par défaut est de demander les données de position de tous les symboles dans la gamme de dimensions de la paire de négociation en cours et du code du contrat.
le symbole faux chaîne
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
exchange.CreateOrder(symbol, "buy", -1, 1)
exchange.CreateOrder(symbol, "sell", -1, 1)
}
var defaultPositions = exchange.GetPositions()
var swapPositions = exchange.GetPositions("USDT.swap")
var futuresPositions = exchange.GetPositions("USDT.futures")
var btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")
var tbls = []
var arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
var tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
for (var index in arr) {
var positions = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], rows: [] }
for (var pos of positions) {
tbl.rows.push([pos.Symbol, pos.MarginLevel, pos.Amount, pos.FrozenAmount, pos.Price, pos.Profit, pos.Type, pos.ContractType, pos.Margin])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
exchange.CreateOrder(symbol, "buy", -1, 1)
exchange.CreateOrder(symbol, "sell", -1, 1)
defaultPositions = exchange.GetPositions()
swapPositions = exchange.GetPositions("USDT.swap")
futuresPositions = exchange.GetPositions("USDT.futures")
btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")
tbls = []
arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
for index in range(len(arr)):
positions = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], "rows": []}
for pos in positions:
tbl["rows"].append([pos["Symbol"], pos["MarginLevel"], pos["Amount"], pos["FrozenAmount"], pos["Price"], pos["Profit"], pos["Type"], pos["ContractType"], pos["Margin"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
exchange.CreateOrder(symbol, "buy", -1, 1);
exchange.CreateOrder(symbol, "sell", -1, 1);
}
auto defaultPositions = exchange.GetPositions();
auto swapPositions = exchange.GetPositions("USDT.swap");
auto futuresPositions = exchange.GetPositions("USDT.futures");
auto btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Position>> arr = {defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions};
std::string tblDesc[] = {"defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"};
for (int index = 0; index < arr.size(); index++) {
auto positions = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& pos : positions) {
json arrJson = R"([])"_json;
arrJson.push_back(pos.Symbol);
arrJson.push_back(pos.MarginLevel);
arrJson.push_back(pos.Amount);
arrJson.push_back(pos.FrozenAmount);
arrJson.push_back(pos.Price);
arrJson.push_back(pos.Profit);
arrJson.push_back(pos.Type);
arrJson.push_back(pos.ContractType);
arrJson.push_back(pos.Margin);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
Utilisez des objets d'échange de contrats à terme pour passer des ordres de marché pour plusieurs paires de transactions et codes de contrats différents.
Les contrats à terme de crypto-monnaie diffèrent des contrats à terme de crypto-monnaie, qui n'ont que le concept logique d'une position.paires de négociation, code du contratVeuillez vous référer aux fonctions {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}.
Dans leGetPositionsfonction, les scénarios d'utilisation du paramètre symbole sont résumés comme suit:
| Classification des objets Exchange | Symbole Paramètres | Portée de la requête | Nom de l'entreprise |
|---|---|---|---|
| Les contrats à terme | Ne pas passer le paramètre de symbole | Rechercher tous les produits de négociation dans la gamme de dimensions de la paire de négociation et du code du contrat en cours | Si la paire de trading actuelle est BTC_USDT et que le code du contrat est swap, tous les contrats perpétuels basés sur USDT seront interrogés.GetPositions("USDT.swap") |
| Les contrats à terme | Indiquez le produit de négociation, le paramètre du symbole est: |
Rechercher le contrat perpétuel basé sur USDT d'un BTC spécifié | Pour les objets d'échange de contrats à terme, le format du symbole de paramètre est:paire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par les caractères".. |
| Les contrats à terme | Spécifier la gamme de produits de négociation, le paramètre du symbole est: |
Rechercher tous les contrats perpétuels basés sur USDT | - |
| Échanges de contrats à terme qui prennent en charge les options | Ne pas passer le paramètre de symbole | Rechercher tous les contrats d'options dans la plage de dimension de la paire de négociation en cours | Si la paire de négociation actuelle est BTC_USDT, le contrat est défini sur un contrat d'option, par exemple, le contrat d'option Binance: BTC-240108-40000-C |
| Échanges de contrats à terme qui prennent en charge les options | Spécifier le produit commercial spécifique | Rechercher le contrat d' option spécifié | Par exemple, pour Binance Futures Exchange, le paramètre du symbole est le suivant: BTC_USDT.BTC-240108-40000-C |
| Échanges de contrats à terme qui prennent en charge les options | Spécifiez la gamme de produits de négociation, le paramètre du symbole est: |
Rechercher tous les contrats d'options basés sur USDT | - |
Dans leGetPositionsfonction, l'objet de l'échange à terme
la gamme de dimensions de requête est résumée comme suit:
| Symbole Paramètres | Définition de la portée de la demande | Nom de l'entreprise |
|---|---|---|
| USDT.swap | la valeur de l'échange est la valeur de l'échange à terme. | Pour |
les dimensions qui ne sont pas prises en charge par l'interface API d'échange, une erreur sera signalée et une valeur nulle sera renvoyée lorsque Je vous appelle.
Une gamme de contrats de livraison basés sur USDT.
L'ampleur de l'échange perpétuel basé sur la monnaie Des contrats.
L'ampleur de la livraison basée sur la monnaie Des contrats.
Une gamme d'options basée sur USDT.
L'option USD est basée sur la monnaie.
Une gamme de combinaisons de CFD. Les échanges de dérivés futures.
L'ampleur des contrats de livraison de marge mixte. Je suis en train d'écrire un livre.
Une marge mixte pour un contrat perpétuel. Je suis en train d'écrire un livre.
Compatible avecexchange.GetPosition()appel,GetPositionest exactement le même queGetPositions.
Lorsque le compte représenté par l'objet d'échangeexchangen'a aucune position dans leplage de requêteouinstruments de négociation spécifiques, leexchange.GetPositions()la fonction renvoie un tableau vide, par exemple:[].
{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
Leexchange.SetMarginLevel()Cette fonction est utilisée pour définir la valeur du levier de la paire de négociation ou du contrat spécifié par lesymbolParamètre. Compatible avec seulement passer dans le paramètremarginLevelpour définir la valeur du levier de la paire de négociation ou du contrat en cours de l'objet de l'échange {@var/EXCHANGE exchange}.
Le niveau de marge est défini par l'échange. Le taux d'intérêt de l'échange est le taux d'intérêt de la bourse.
LesymbolLe paramètre est utilisé pour spécifier la paire de négociation ou le contrat pour lequel la valeur de l'effet de levier doit être ajustée.symbolparamètre duSetMarginLevel()La fonction est compatible avec le format de lasymbolparamètre duGetTicker()fonction.
le symbole
faux
chaîne
LemarginLevelLe paramètre est utilisé pour définir la valeur de l'effet de levier, qui est généralement un entier pour les bourses et il prend également en charge les paramètres de valeur d'effet de levier à virgule flottante pour certaines bourses.
MargeLe niveau
vrai
Numéro
function main() {
exchange.SetMarginLevel(10)
// Set the leverage of BTC’s USDT-margined perpetual contract to 15
exchange.SetMarginLevel("BTC_USDT.swap", 15)
}
def main():
exchange.SetMarginLevel(10)
exchange.SetMarginLevel("BTC_USDT.swap", 15)
void main() {
exchange.SetMarginLevel(10);
exchange.SetMarginLevel("BTC_USDT.swap", 15);
}
Leexchange.SetMarginLevel()Le système de backtesting prend en charge l'appel de l'objet de l'échange de contrat à terme de crypto-monnaie.exchange.SetMarginLevel()fonction permettant de définir la valeur du levier.
Pour les contrats à terme de crypto-monnaie, le mécanisme d'effet de levier n'est pas uniforme en raison des échanges de contrats à terme de crypto-monnaie.exchange.SetMarginLevel()la fonction ne génère pas une demande réseau, mais définit uniquement la variable de levier dans le système FMZ sous-jacent (utilisé pour passer des paramètres dans l'interface de placement des ordres).exchange.SetMarginLevel()Il peut y avoir de nombreuses raisons à cela, par exemple: il y a une position en cours ou un ordre en attente, ce qui rend impossible de définir une nouvelle valeur d'effet de levier pour cette paire ou ce contrat.
Échanges qui ne soutiennent pas leexchange.SetMarginLevel()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| Définir le niveau de marge | – | Le montant de l'obligation est calculé à partir de la valeur de l'obligation. |
{@var/EXCHANGE échange}
Leexchange.SetDirection()Cette fonction est utilisée pour définir la direction des ordres de la fonction {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell} lors de la passation d'ordres pour les contrats à terme.
Je suis en train de changer de direction.
LedirectionLe paramètre est utilisé pour définir la direction du contrat à terme lorsque l'ordre est passé."buy", "closesell", "sell", "closebuy"- Je ne sais pas.
direction
vrai
chaîne
function main(){
// For example, set to OKX futures contract of this week
exchange.SetContractType("this_week")
// Set leverage to 5 times
exchange.SetMarginLevel(5)
// Set the order type to long
exchange.SetDirection("buy")
// Place an order for 2 contracts at 10,000
exchange.Buy(10000, 2)
exchange.SetMarginLevel(5)
exchange.SetDirection("closebuy")
exchange.Sell(1000, 2)
}
def main():
exchange.SetContractType("this_week")
exchange.SetMarginLevel(5)
exchange.SetDirection("buy")
exchange.Buy(10000, 2)
exchange.SetMarginLevel(5)
exchange.SetDirection("closebuy")
exchange.Sell(1000, 2)
void main() {
exchange.SetContractType("this_week");
exchange.SetMarginLevel(5);
exchange.SetDirection("buy");
exchange.Buy(10000, 2);
exchange.SetMarginLevel(5);
exchange.SetDirection("closebuy");
exchange.Sell(1000, 2);
}
Leexchange.SetDirection()la fonction définit la correspondance entre la direction de l'opération du contrat à terme et la fonction de placement des ordres:
| Fonctions de placement des commandes | La direction définie par les paramètres de la fonction SetDirection | Les commentaires |
|---|---|---|
| exchange.Buy | Achat et ouverture de positions longues | |
| exchange.Buy | Achat et fermeture de positions courtes | |
| exchange.Sell | Vendre et ouvrir des positions courtes | |
| exchange.Sell | Vendre et fermer des positions longues |
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Buy.Buy.Buy}, {@fun/Trade/Exchange.Buy.Buy}
Leexchange.SetContractType()fonction est utilisée pour définir le code de contrat courant de l'objet d'échange {@var/EXCHANGE exchange}.
Leexchange.SetContractType()La fonction renvoie une structure qui contient le code du contrat d'échange correspondant au code du contrat actuel.quarter, et la structure de la valeur de retour de cette fonction est:{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}- Je ne sais pas.
objet
le type de contrat (symbole)
Lesymbolle paramètre est utilisé pour définir le code du contrat, les valeurs facultatives sont:"this_week", "next_week", "quarter", "next_quarter", "swap", etc.
Contrats à terme sur crypto-monnaiecontrat de livraisonles codes, s'ils ne sont pas spécifiés, comportent généralement:
this_week: le contrat de la semaine en cours.next_weekLe contrat de la semaine prochaine.quarter: contrat trimestriel.next_quarter: le contrat trimestriel suivant.Contrats à durée déterminéeles codes des contrats à terme sur crypto-monnaie, s'ils ne sont pas spécifiés, comportent généralement:swapLe contrat est perpétuel.le symbole vrai chaîne
function main() {
// Set to this week contract
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
Définissez le contrat en cours comme le contrat de la semaine en cours:
function main() {
// The default trading pair is BTC_USD, set the contract for this week, and the contract is a currency standard contract
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
// Switching trading pairs, then setting up contracts, switching to USDT as margin contracts, as opposed to currency standard contracts
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("swap")
Log("ticker:", exchange.GetTicker())
}
def main():
exchange.SetContractType("this_week")
Log("ticker:", exchange.GetTicker())
exchange.IO("currency", "BTC_USDT")
exchange.SetContractType("swap")
Log("ticker:", exchange.GetTicker())
void main() {
exchange.SetContractType("this_week");
Log("ticker:", exchange.GetTicker());
exchange.IO("currency", "BTC_USDT");
exchange.SetContractType("swap");
Log("ticker:", exchange.GetTicker());
}
Lors de la conclusion d'un contrat avecUSDTcomme marge, vous devez basculer la paire de négociation dans le code (vous pouvez également définir la paire de négociation directement lors de l'ajout de l'objet d'échange):
function main(){
// Set the contract for this week
var ret = exchange.SetContractType("this_week")
// Return information about the current week's contracts
Log(ret)
}
def main():
ret = exchange.SetContractType("this_week")
Log(ret)
void main() {
auto ret = exchange.SetContractType("this_week");
Log(ret);
}
Imprimez la valeur de retour duexchange.SetContractType()fonction:
Dans la stratégie des contrats à terme de crypto-monnaie, prenons l'exemple du passage à laBTC_USDTPartie de négociation: Lorsque des paires de négociation sont changées en utilisant leexchange.SetCurrency("BTC_USDT")ouexchange.IO("currency", "BTC_USDT")fonctionnalités, après le changement, vous devez utiliser leexchange.SetContractType()La fonction de réinitialisation du contrat pour déterminer le contrat en cours à opérer dans le cadre de la nouvelle paire de négociation.contrat type de deviseou unContrat type USDTPar exemple, si une paire de négociation est réglée surBTC_USDT, utilisezexchange.SetContractType("swap")fonction de régler le code du contrat àswapÀ ce stade, il est réglé surBTCPour leNorme USDTSi la paire de négociation estBTC_USD, utilisezexchange.SetContractType("swap")fonction de régler le code du contrat àswapÀ ce stade, il est réglé surBTCC' est...norme monétaireLe contrat est perpétuel.
Détails des bourses de contrats à terme de crypto-monnaie prises en charge, avec les noms des contrats pour chaque bourse comme suit:
Le montant de l'obligation est calculé à partir du montant de la garantie.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap")Le contrat de cette semaine:exchange.SetContractType("this_week")Le contrat de la semaine prochaine:exchange.SetContractType("next_week")Réglé à un contrat mensuel:exchange.SetContractType("month")Contrat pour le mois prochain:exchange.SetContractType("next_month")Résultats des contrats trimestriels:exchange.SetContractType("quarter")Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")
OKX a des contrats de négociation pré-marché: la date de livraison du contrat est une heure fixe.HMSTR-USDT-250207. Réglez la paire de négociation àHMSTR_USDTsur la plateforme FMZ, puis utiliserexchange.SetContractType("HMSTR-USDT-250207")pour établir le contrat.
Pour les fonctions qui prennent en charge lesymbolparamètre, tel que:exchange.GetTicker(), exchange.CreateOrder(), etc. Vous pouvez spécifier lesymbolparamètre comme suit:HMSTR_USDT.HMSTR-USDT-250207d'obtenir les données de marché du présent contrat ou de passer une commande.
Le montant de l'obligation est calculé à partir de la valeur de la garantie.
Le contrat de cette semaine:exchange.SetContractType("this_week")- Je ne sais pas.
Le contrat de la semaine prochaine:exchange.SetContractType("next_week")- Je ne sais pas.
Résultats des contrats trimestriels:exchange.SetContractType("quarter")Je suis désolée.
Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")- Je ne sais pas.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap")- Je ne sais pas.
Il soutient les contrats avecUSDTcomme marge, prenezBTCle contrat par exemple: utilisationexchange.IO("currency", "BTC_USDT")pour passer à un contrat qui utiliseUSDTcomme marge.
Ou régler la paire de négociation actuelle àBTC_USDTIl est nécessaire de modifier les paramètres de trading en direct et d'ajouter des objets d'échange.exchange.SetContractType()La fonction de régler le contrat.
Les titres de titres de titres de titres de titres de titres
Réglé sur des contrats perpétuels:exchange.SetContractType("swap")Je suis désolée.
Les contrats de livraison sur le marché des contrats à terme BitMEX sont des contrats mensuels avec les codes de contrat suivants (de janvier à décembre):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Rédaction de contrats de livraison:exchange.SetContractType("December")Par exemple, lorsque la paire de négociation est réglée surXBT_USDT, leexchange.SetContractType("December")La fonction est appelée à définir le contrat pour la livraison de décembre en USDT basé sur BTC (correspondant au code de contrat réel deXBTUSDTZ23).
Résumé des informations relatives aux contrats à terme BitMEX
| Code du contrat défini par Futures_BitMEX | La paire de négociation correspondante dans FMZ | Le code du contrat correspondant dans FMZ | Nom de l'entreprise |
|---|---|---|---|
| Le DOGEUSD | Le montant de l'allocation | échange | Nommé en USD, XBT réglé. |
| Le code de conduite | Le code de l'appareil | échange | Nominé en USDT, réglé en USDT. |
| XBTETH | XBT_ETH | échange | ETH dénommé, XBT réglé. |
| XBTEUR | XBT_EUR | échange | Nominé en euros, réglé en XBT. |
| USDTUSDC | USDT_USDC | échange | Nommé en USDC, XBT réglé. |
| Évaluation de la valeur de l'échange | Équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent de l'équivalent | échange | Nommé en USD, réglé en ETH. |
| XBTH24 | XBT_USD | Le mois de mars | Date d'expiration: le 24 mars, le code du mois est: H; libellé en USD, XBT réglé. |
| Le montant de la dette est calculé en fonction de la valeur de la dette. | Équivalent de l'équivalent de l'échange | Décembre | Date d'expiration: le 23 décembre, le code du mois est le suivant: Z; libellé en USD, réglé en XBT. |
| Je ne sais pas. | XBT_USDT | Décembre | Date d'expiration: le 23 décembre. Le code du mois est le suivant: Z ; libellé en USDT, réglé en USDT. |
| ADAZ23 | ADA_XBT | Décembre | Date d'expiration: 23 décembre, le code du mois est: Z ; facturation en XBT, règlement en XBT. |
| P_XBTETFX23 | USDT_XXX | P_XBTETFX23 | Expiration: 23/11/23; exprimé en pourcentage et réglé en USDT. |
Les contrats à terme
Le contrat de cette semaine:exchange.SetContractType("this_week")- Je ne sais pas.
Le contrat de la semaine prochaine:exchange.SetContractType("next_week")- Je ne sais pas.
Résultats des contrats trimestriels:exchange.SetContractType("quarter")Je suis désolée.
Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")- Je ne sais pas.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap")- Je ne sais pas.
Il soutient les contrats avecUSDTcomme marge, prenezBTCle contrat par exemple: utilisationexchange.IO("currency", "BTC_USDT")pour passer à un contrat qui utiliseUSDTcomme marge.
Ou régler la paire de négociation actuelle àBTC_USDTIl est nécessaire de modifier les paramètres de trading en direct et d'ajouter des objets d'échange.exchange.SetContractType()La fonction de régler le contrat.
Les titres à terme
Réglé sur des contrats perpétuels:exchange.SetContractType("swap")- Je ne sais pas.
Il prend en charge DeribitUSDCLe contrat.
Les contrats de livraison sont les suivants:"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"- Je ne sais pas.
Le montant de l'obligation de dépôt est calculé à partir du montant de la garantie."this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", il y a beaucoup de combinaisons.
Pour les contrats d'options, vous devez entrer le code spécifique du contrat d'option défini par la bourse, voir le site Web de Deribit pour plus de détails.
Les contrats à terme avec KuCoin
Par exemple, si la paire de négociation est réglée surBTC_USDet le code du contrat est défini, il s'agit d'un contrat basé sur la devise:
Réglé à des contrats perpétuels:exchange.SetContractType("swap")- Je ne sais pas.
Résultats des contrats trimestriels:exchange.SetContractType("quarter")Je suis désolée.
Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter").
USDT comme contrat de marge:
Par exemple, si la paire de négociation est réglée surBTC_USDT, puis définissez le code du contrat, il s'agit d'un contrat avec USDT comme marge.
Réglé à des contrats perpétuels:exchange.SetContractType("swap").
Les contrats à terme avec Binance
Binance Futures Exchange défaut sur le contrat perpétuel de la paire de négociation en cours, code du contrat:swap- Je ne sais pas.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap"), les contrats perpétuels de Binance ont des contrats qui utilisentUSDTcomme marge.USDTcontrat perpétuel standard deBTCLe taux de change de la paire de négociation peut être utilisé comme contrat de marge et la paire de négociation est réglée surBTC_USDTBinance prend également en charge les contrats perpétuels qui utilisent des pièces comme marge, par exemple,BTCLe contrat perpétuel standard de Binance, avec la paire de négociationBTC_USD- Je ne sais pas.
Résultats des contrats trimestriels:exchange.SetContractType("quarter"), le contrat de livraison comporte un contrat standard en devises (c'est-à-dire en utilisant des devises comme marge), par exemple,BTCDans le contrat trimestriel, la paire de négociation est réglée sur:BTC_USDet ensuite fixer le contratexchange.SetContractType("quarter"), il est réglé surBTCun contrat trimestriel avec un contrat type en devises.
Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter"), par exemple,BTCdu contrat trimestriel type de devises, la paire de négociation est fixée à:BTC_USD, et ensuite fixer le contratexchange.SetContractType("next_quarter")- Je ne sais pas.
Binance prend en charge partiellementUSDTcomme contrat de livraison de marge, prendreBTCpar exemple, définir la paire de négociation àBTC_USDT, puis définissez le code du contrat.
Prise en charge des contrats Binance Options:
Le format du code du contrat d'option est basé sur le code du contrat d'option défini par la bourse:BTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-PPrenez le code du contrat d' option BinanceBTC-241227-15000-PPar exemple: BTC est le code de la devise de l'option, 241227 est la date d'exercice, 15000 est le prix d'exercice, P représente une option de vente et C représente une option d'achat.
Pour plus de détails sur le type d'option, qu'il s'agisse d'option européenne ou d'option américaine, veuillez consulter les informations pertinentes du contrat d'option de l'échange.
L'échange peut restreindre les vendeurs d'options et les obliger à demander des qualifications séparément.
Les échanges à terme
Code du contrat pour les contrats perpétuels Bibox:swap- Je ne sais pas.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap").
Les échanges à terme
Le code du contrat est le contrat perpétuel pour la paire de négociation en cours:swap- Je ne sais pas.
Le code du contrat de cette semaine:this_week- Je ne sais pas.
Code du contrat de la semaine prochaine:next_week- Je ne sais pas.
Code du contrat de la troisième semaine:third_week- Je ne sais pas.
Code du contrat mensuel:month- Je ne sais pas.
Code du contrat du mois prochain:next_monthJe suis désolée.
Code du contrat trimestriel:quarterJe suis désolée.
Code du contrat pour le trimestre suivant:next_quarter- Je ne sais pas.
Code du contrat pour le troisième trimestre:third_quarter.
Les contrats à terme
Le contrat par défaut est le contrat perpétuel de la paire de négociation en cours, code du contrat:swap.
swapLe contrat est perpétuel.month: contrat du mois en cours.quarter: contrat trimestriel.next_quarterLe contrat pour le prochain trimestre.swap_pf: Contrats perpétuels à marge mixte.quarter_ff: Contrat trimestriel à marge mixte.month_ff: contrat de marge mixte pour le mois en cours.next_quarter_ffContrat de marge mixte pour le prochain trimestre.
Les titres à terme
Le code du contrat est le code de la paire de négociation en cours.swap.
Les contrats à terme_Bitget
Le code du contrat est le code de la paire de négociation en cours.swap- Je ne sais pas.
La paire de négociation est réglée surBTC_USDpour les contrats standard de devises, et la paire de négociation est réglée surBTC_USDTpour les contrats réglés parUSDTLes contrats de démonstration peuvent être établis avec des paires de négociation telles queSBTC_USD, BTC_SUSDT.
Les échanges à terme
Code du contrat pour les contrats perpétuels dYdX:swap- Je ne sais pas.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap"), dYdX ne propose que des contrats standard en USDT.
Les échanges à terme
Code du contrat pour les contrats perpétuels MEXC:swap- Je ne sais pas.
Réglé sur des contrats perpétuels:exchange.SetContractType("swap"). Régler la paire de négociation àBTC_USD, qui est un contrat standard de devise, et définit une paire de négociation àBTC_USDT, qui estUSDT- Un contrat conclu.
Les contrats à terme
Les jetons dans un compte sur lecrypto.comLes opérations de change peuvent être converties en crédits libellés en USD à utiliser comme marge pour le trading de contrats.
Je suis en contrat à perpétuité:exchange.SetContractType("swap"). Exemple d'appel duexchange.SetContractType("swap")fonction de définition d'un contrat perpétuel pour BTC lorsque la paire de négociation est réglée surBTC_USD- Je ne sais pas.
Lecrypto.comLes contrats de livraison de change sont des contrats mensuels avec les codes de contrat suivants (de janvier à décembre):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Définir le contrat de livraison:exchange.SetContractType("October")Par exemple, lorsque la paire de négociation est réglée surBTC_USD, appeler la fonctionexchange.SetContractType("October")pour fixer le contrat de livraison d'octobre pour BTC.
Le code du contrat correspondant à l'heure actuelle est le suivant:BTCUSD-231027.
Les contrats à terme
Comptes à terme_WOOUSDTLes contrats basés sur un code de contrat perpétuel deswapPar exemple, lorsque la paire de négociation est réglée surBTC_USDT, la fonctionexchange.SetContractType("swap")est appelé à définir le contrat actuel comme un contrat perpétuel pour BTC basé sur USDT.
{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}
Leexchange.GetContractType()fonction est utilisée pour obtenir le code du contrat pour le paramètre actuel de l'objet d'échange {@var/EXCHANGE exchange}.
Leexchange.GetContractType()la fonction renvoie le code de contrat défini par la plateforme FMZ, par exemple:this_week, swap, etc.
chaîne
Il est possible de modifier le type de contrat.
function main () {
Log(exchange.SetContractType("this_week"))
Log(exchange.GetContractType())
}
def main():
Log(exchange.SetContractType("this_week"))
Log(exchange.GetContractType())
void main() {
Log(exchange.SetContractType("this_week"));
Log(exchange.GetContractType());
}
{@fun/Futures/exchange.SetContractType exchange.SetContractType} Il s'agit d'un produit qui a été vendu par un fournisseur d'électricité.
Leexchange.GetFundings()Cette fonction est utilisée pour obtenir les données sur le taux de financement pour la période en cours.
Leexchange.GetFundings()la fonction renvoie un tableau de structures {@struct/Funding Funding} lorsque la demande de données est réussie, et renvoie une valeur nulle lorsque la demande de données échoue.
{@struct/Funding Funding} tableau, valeur nulle
Les fonds sont versés à l'échange. Les échanges de fonds (symbole)
Le paramètresymbolest utilisé pour régler lesymbole de transactionougamme de symboles de transactionLe rapport de la commission de l'emploi et des affaires socialessymbolsi le paramètre n'est pas passé, les données relatives au taux de financement actuel de tous les instruments seront demandées par défaut dans la gamme de dimensions de la paire de négociation et du code du contrat en cours.
le symbole faux chaîne
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
function main() {
// LPT_USDT.swap 4-hour period
var symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
for (var symbol of symbols) {
exchange.GetTicker(symbol)
}
var arr = []
var arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
for (p of arrParams) {
if (p == "no param") {
arr.push(exchange.GetFundings())
} else {
arr.push(exchange.GetFundings(p))
}
}
var tbls = []
var index = 0
for (var fundings of arr) {
var tbl = {
"type": "table",
"title": arrParams[index],
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": [],
}
for (var f of fundings) {
tbl["rows"].push([f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate * 100 + " %"])
}
tbls.push(tbl)
index++
}
LogStatus(_D(), "\n Requested market types:", symbols, "\n`" + JSON.stringify(tbls) + "`")
}
'''backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
'''
import json
def main():
# LPT_USDT.swap 4-hour period
symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
for symbol in symbols:
exchange.GetTicker(symbol)
arr = []
arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
for p in arrParams:
if p == "no param":
arr.append(exchange.GetFundings())
else:
arr.append(exchange.GetFundings(p))
tbls = []
index = 0
for fundings in arr:
tbl = {
"type": "table",
"title": arrParams[index],
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": [],
}
for f in fundings:
tbl["rows"].append([f["Symbol"], f["Interval"] / 3600000, _D(f["Time"]), str(f["Rate"] * 100) + " %"])
tbls.append(tbl)
index += 1
LogStatus(_D(), "\n Requested market types:", symbols, "\n`" + json.dumps(tbls) + "`")
/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
void main() {
// LPT_USDT.swap 4-hour period
json arrSymbol = R"([])"_json;
std::string symbols[] = {"SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"};
for (const std::string& symbol : symbols) {
exchange.GetTicker(symbol);
arrSymbol.push_back(symbol);
}
std::vector<std::vector<Funding>> arr = {};
std::string arrParams[] = {"no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"};
for (const std::string& p : arrParams) {
if (p == "no param") {
arr.push_back(exchange.GetFundings());
} else {
arr.push_back(exchange.GetFundings(p));
}
}
json tbls = R"([])"_json;
int index = 0;
for (int i = 0; i < arr.size(); i++) {
auto fundings = arr[i];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Interval", "Time", "Rate"],
"rows": []
})"_json;
tbl["title"] = arrParams[index];
for (int j = 0; j < fundings.size(); j++) {
auto f = fundings[j];
// json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), string(f.Rate * 100) + " %"};
json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate};
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
index++;
}
LogStatus(_D(), "\n Requested market types:", arrSymbol.dump(), "\n`" + tbls.dump() + "`");
}
Utilisez l'objet d'échange de contrats à terme pour appeler leexchange.GetFundings()Avant d'appeler une fonction de marché, GetFundings renvoie uniquement les données de financement de la paire de trading par défaut actuelle. Après avoir appelé la fonction de marché, il renvoie les données de financement de toutes les variétés demandées. Vous pouvez vous référer à l'exemple de test suivant:
Pour les bourses à terme qui ne prennent pas en charge la requête par lots de données sur les taux de financement, si lesymbolle paramètre est spécifié comme la plage de requête, par exemple:USDT.swapou lesymbolSi le paramètre n'est pas passé, l'interface signalera une erreur.GetFundings()fonction utilisant ce type d'objet d'échange de contrats à terme, vous devez spécifier lesymbolparamètre comme type de contrat perpétuel spécifique afin d'interroger les données actuelles sur le taux de financement du type.
Leexchange.GetFundings()La fonctionnalité prend en charge les systèmes réels de trading et de backtesting.
Les échanges qui ne prennent pas en charge l'acquisition par lots de données sur les taux de financement: Futures_Bitget, Futures_OKX, Futures_MEXC, Futures_Deribit, Futures_Crypto.symbolparamètre avec le code de symbole spécifique, par exemple:ETH_USDT.swap.
Les échanges qui ne soutiennent pas leexchange.GetFundings()fonction:
| Nom de la fonction | Échanges au comptant non pris en charge | Échanges de contrats à terme non soutenus |
|---|---|---|
| GetFundings | – | Les contrats à terme |
{@struct/Funding Financing} Je suis désolée.
Leexchange.SetBase()fonction est utilisée pour définir l'adresse de base de l'interface API d'échange configurée dans l'objet d'échange {@var/EXCHANGE exchange}.
Les données de la base de données
Lesparamètre est utilisé pour spécifier l'adresse de base de l'interface API d'échange.
s
vrai
chaîne
function main() {
// Use default base address
Log(exchange.GetTicker())
// Switch to https://aws.okx.com
exchange.SetBase("https://aws.okx.com")
Log(exchange.GetTicker())
}
def main():
Log(exchange.GetTicker())
exchange.SetBase("https://aws.okx.com")
Log(exchange.GetTicker())
void main() {
Log(exchange.GetTicker());
exchange.SetBase("https://aws.okx.com");
Log(exchange.GetTicker());
}
La commutation de l'adresse de base de l'API d'échange n'est pas prise en charge dans le système de backtesting, car le système de backtesting est un environnement de simulation de sandbox et n'accède pas réellement à l'interface de l'API d'échange.
{@fun/Trade/exchange.IO exchange.IO}
Leexchange.GetBase()la fonction est utilisée pour obtenir l'adresse de base de l'interface API d'échange en cours.
L'adresse de base actuelle de l'interface API d'échange. chaîne
Je suis en train d' écrire un message.
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
Je ne sais pas si je peux vous aider.
Leexchange.SetProxy()fonction est utilisée pour définir la configuration du proxy de l'objet d'échange {@var/EXCHANGE exchange}.
Je suis en train de changer de nom.
LeproxyLe paramètre est utilisé pour spécifier la configuration du proxy.
représentant
vrai
chaîne
function main() {
exchange.SetProxy("socks5://192.168.1.10:8080")
// If you can't access the exchange ticker interface, set up an available ss5 proxy and you can access the ticker interface
Log(exchange.GetTicker())
}
def main():
exchange.SetProxy("socks5://192.168.1.10:8080")
Log(exchange.GetTicker())
void main() {
exchange.SetProxy("socks5://192.168.1.10:8080");
Log(exchange.GetTicker());
}
Configurer l'objet d'échange {@var/EXCHANGE exchange}socks5le représentant:
function main(){
exchange.SetProxy("ip://10.0.3.15")
// The requested IP address is 10.0.3.15
exchange.GetTicker()
}
def main():
exchange.SetProxy("ip://10.0.3.15")
exchange.GetTicker()
void main() {
exchange.SetProxy("ip://10.0.3.15");
exchange.GetTicker();
}
En plus despécifications globalesde l'adresse IP de la demande de l'objet d'échange {@var/EXCHANGE exchange}, il est également possible de spécifier une adresse IP basée sur {@var/EXCHANGE exchange}:
Si le réglage du proxy échoue, leexchange.SetProxy()la fonction renverra null lorsqu'elle est appelée.exchange.SetProxy()fonction définit le proxy pour lerestUn proxy peut être défini pour chaque objet d'échange {@var/EXCHANGE exchange}, et l'accès à l'interface d'échange liée à l'objet d'échange {@var/EXCHANGE exchange} après la configuration du proxy sera accessible par le proxy.
Appui au réglagesocks5Proxy, en prenant le premier objet d'échange ajouté {@var/EXCHANGE exchange} c'est à dire:exchanges[0]à titre d'exemple:
exchange.SetProxy("socks5://127.0.0.1:8889").exchange.SetProxy("socks5://username:password@127.0.0.1:8889"). usernameest le nom d'utilisateur etpasswordest le mot de passe.exchange.SetProxy("").Prend en charge la définition de l'adresse IP de la demande à partir de l'objet d'échange {@var/EXCHANGE exchange},spécifié globalement.
{@var/EXCHANGE échange}
Leexchange.SetTimeout()fonction est utilisée pour régler le temps d'arrêt de larestdemande pour l'objet d'échange {@var/EXCHANGE exchange}.
Je suis en train d' écrire une lettre.
LetimeoutLe paramètre est utilisé pour spécifier le nombre de millisecondes pour le réglage du temps d'arrêt.
Le temps mort
vrai
Numéro
function main() {
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
}
def main():
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
void main() {
exchange.SetTimeout(3000);
Log(exchange.GetTicker());
}
Le paramètretimeoutest une valeur de milliseconde, 1000 millisecondes est égale à 1 seconde.restLe protocole est utilisé pour régler le temps d'arrêtrestIl n'y a qu'une seule fois où il prend effet.exchange.SetTimeout(3000), définit lerestdemande de délai pour leexchangeL'appel des fonctions avec les demandes de réseau telles queexchange.GetTicker()qui ne reçoivent pas de réponse pendant plus de 3 secondes seront temps d'arrêt, et les appels de fonction qui font temps d'arrêt renverront des valeurs nulles.SetTimeout()n'est pas une fonction globale, c'est une méthode de l'objet d'échange {@var/EXCHANGE exchange}.
{@var/EXCHANGE échange}
La plate-forme de négociation quantitative FMZ prend réellement en charge la fonction multi-threaded duJavaScriptLa stratégie linguistique est mise en place de bas en haut du système et vise à atteindre les objectifs suivants:
| Objets | Directions de conduite | Les commentaires |
|---|---|---|
| filtrage | Objet global à plusieurs fils | Les fonctions des membres:Thread, getThread, mainThread, etc. |
| Le fil | Objet de fil | Les fonctions des membres:peekMessage, postMessage, join, etc. |
| Fermeture de fil | Objet de verrouillage de fil | Les fonctions des membres:acquire, release. Ils peuvent être passés dans l'environnement du thread en tant que paramètres de la fonction d'exécution du thread. |
| ThreadÉvénement | Objet événement | Les fonctions des membres:set, clear, wait, isSet. Ils peuvent être passés dans l'environnement du thread comme paramètre de la fonction d'exécution du thread. |
| ThreadCondition | Objet de condition | Les fonctions des membres:notify, notifyAll, wait, acquire, release. Ils peuvent être passés dans l'environnement du thread comme paramètre de la fonction d'exécution du thread. |
| ThreadDict | Objet du dictionnaire | Les fonctions des membres:get, set. Ils peuvent être passés dans l'environnement du thread en tant que paramètres de la fonction d'exécution du thread. |
LethreadingObjet est un outil de gestion multi-threading global qui fournit des fonctions telles que la création de threads concurrents, de verrouillage de thread et d'objets condition.threadingCet objet n'est pris en charge que par leJavaScriptstratégie linguistique.
LeThread()la fonction est utilisée pour créer des threads simultanés.
LeThread()La fonction renvoie aThreadobjet, qui est utilisé pour gérer les threads simultanés créés, la communication des threads, etc.
Threadobjet
Je ne sais pas si c'est vrai. Thème (s)
Le paramètrefuncest une fonction d'exécution simultanée (passée par référence) et prend en charge le passage de fonctions anonymes.funcpeut accepter plusieurs paramètres, qui seront transmis à travers...argsPar conséquent, la liste de paramètres defuncdoit être conforme à...args.
fonction
vrai
fonction
Le paramètreargest le paramètre réel passé àfunc(c'est-à-dire la fonction d'exécution simultanée du thread) lorsque le rappel est exécuté; il peut y avoir plusieurs paramètresarg, et la liste des paramètres defuncdoit être conforme à...args.
arg
faux
chaîne, nombre, bool, objet, tableau, fonction, valeur nulle et autres types pris en charge par le système
Le paramètreitemest un tableau contenant les références de fonction et leurs paramètres à exécuter simultanément.itemLes paramètres peuvent être passés lors de l'appel duThread function.
point vrai séquence
function test1(a, b, c) {
Log("test1:", a, b, c)
}
function main() {
var t1 = threading.Thread(test1, 1, 2, 3)
var t2 = threading.Thread(function (msg) {
Log("msg:", msg)
}, "Hello thread2")
t1.join()
t2.join()
}
Créez des threads simultanés pour une fonction personnalisée et une fonction anonyme.
function test1(msg) {
Log("msg:", msg)
test2("Hello test2")
}
function main() {
var t1 = threading.Thread(
[function(a, b, c) {Log(a, b, c)}, 1, 2, 3],
[test1, "Hello test1"],
[`function test2(msg) {Log("msg:", msg)}`])
t1.join()
}
Utilisez leThread(...items)forme pour créer des threads simultanés et exécuter plusieurs fonctions séquentiellement.
function ml(input) {
const net = new brain.NeuralNetwork()
net.train([
{ input: [0, 0], output: [0] },
{ input: [0, 1], output: [1] },
{ input: [1, 0], output: [1] },
{ input: [1, 1], output: [0] },
])
return net.run(input)
}
function main() {
var ret = threading.Thread([ml, [1, 0]], [HttpQuery("https://unpkg.com/brain.js")]).join()
// ret: {"id":1,"terminated":false,"elapsed":337636000,"ret":{"0":0.9339330196380615}}
Log(ret)
}
Il prend en charge le passage de chaînes de fonctions et peut importer des bibliothèques externes de manière dynamique pour le calcul simultané.
La fonction de filfuncpassé dans leThread()Une fonction pour l'exécution simultanée s'exécute dans un environnement isolé, de sorte que les variables en dehors du thread ne peuvent pas être directement référencées, et la compilation échouera lorsqu'elle est référencée.
Il prend en charge le système de backtesting et l'environnement de trading en direct. Toutes les fonctions liées aux threads concurrents ne sont prises en charge que comme compatibilité de code dans le système de backtesting et ne seront pas réellement exécutées par des threads concurrents, elles ne seront donc pas répétées dans ce chapitre.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}
LegetThread()fonction est utilisée pour obtenir l'objet de thread basé sur l'ID de thread spécifié.
LegetThread()Retourne leThreadobjet avec le threadId spécifié par le paramètre
Threadobjet
Je ne sais pas si c'est vrai.
Le paramètrethreadIdest l'ID de l'objet de thread. Obtenez l'objet de thread correspondant en spécifiant le paramètre.
Le fil vrai Numéro
function main() {
var t1 = threading.Thread(function () {
Log("Hello thread1")
})
// The Thread object has a method: id(), which is used to get the thread ID. You can view the section of the document corresponding to the Thread object.
var threadId = t1.id()
var threadName = t1.name()
Log("threadId:", threadId, ", threadName:", threadName)
var t2 = threading.getThread(threadId)
Log(`threadId == t2.id():`, threadId == t2.id(), `, threadName == t2.name():`, threadName == t2.name())
}
Obtenir l'objet de thread spécifiéthreadId.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
Si le fil que vous voulez obtenir a été exécuté et libéré, vous ne pouvez pas utiliserthreading.getThread(threadId)pour obtenir l'objet du fil du fil.
{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop Loop}
LemainThread()fonction est utilisée pour obtenir l'objet de fil du fil principal, c'est-à-dire le fil où lemain()La fonction dans la stratégie est localisée.
LemainThread()la fonction renvoie l'objet de thread du thread principal.
Threadobjet
le fil principal (((
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
Prends leThreadl'objet du fil principal et la sortiethreadIddu fil conducteur.
function test() {
Log("Output the main thread ID in the test function:", threading.mainThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
L'objet de fil du fil principal peut également être obtenu dans des fils concurrents.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
{@fun/Threads/getThread getThread}, {@fun/Threads/threads/threading/Thread Thread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threads/threading/Lock Lock}, {@fun/Threads/threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop Loop}
LecurrentThread()la fonction est utilisée pour obtenir l'objet thread du thread actuel.
LecurrentThread()la fonction renvoie l'objet de thread du thread en cours.
Threadobjet
Le fil de discussion actuel
function test() {
Log("Id of the current thread:", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Prends leThreadl'objet du fil de courant et la sortiethreadIddu fil actuel.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threads/threading/event Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop eventLoop}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}, {@fun/threads/threads/threading/eventLoop}, {@fun/threads/threads/threads/ev
LeLock()la fonction est utilisée pour créer un objet de verrouillage de thread.
LeLock()la fonction renvoie un objet de verrouillage de thread.
ThreadLockobjet
Fermeture
function consumer(productionQuantity, dict, lock) {
for (var i = 0; i < productionQuantity; i++) {
lock.acquire()
var count = dict.get("count")
Log("consumer:", count)
Sleep(1000)
lock.release()
}
}
function producer(productionQuantity, dict, lock) {
for (var i = 0; i < productionQuantity; i++) {
lock.acquire()
dict.set("count", i)
Log("producer:", i)
Sleep(1000)
lock.release()
}
}
function main() {
var dict = threading.Dict()
dict.set("count", -1)
var lock = threading.Lock()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, lock)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, lock)
consumerThread.join()
producerThread.join()
}
Deux fils concurrents accèdent à une ressource commune.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threads/threading/threadThread}, {@fun/Threads/threads/threading/condition Condition}, {@fun/Threads/threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop}
LeCondition()fonction est utilisée pour créer un objet variable de condition, qui est utilisé pour réaliser la synchronisation et la communication entre les threads dans un environnement concurrent multi-threaded.Condition(), un thread peut attendre lorsque certaines conditions ne sont pas remplies jusqu'à ce qu'un autre thread l'informe que la condition a été remplie.
LeCondition()La fonction renvoie aThreadCondition object.
ThreadConditionobjet
Condition (s)
function consumer(productionQuantity, dict, condition) {
for (var i = 0; i < productionQuantity; i++) {
condition.acquire()
while (dict.get("array").length == 0) {
condition.wait()
}
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
condition.release()
Sleep(1000)
}
}
function producer(productionQuantity, dict, condition) {
for (var i = 0; i < productionQuantity; i++) {
condition.acquire()
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
condition.notify()
condition.release()
Sleep(1000)
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var condition = threading.Condition()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, condition)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, condition)
consumerThread.join()
producerThread.join()
}
Deux fils concurrents accèdent à une ressource commune.
Le système de backtesting ne met pas en œuvre cette fonctionnalité, il la définit seulement.
{@fun/Threads/getThread getThread}, {@fun/Threads/threads/mainThread mainThread}, {@fun/Threads/threads/currentThread currentThread}, {@fun/Threads/threads/threading/Lock Lock}, {@fun/Threads/threads/threading/Thread Thread}, {@fun/Threads/threads/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}
LeEvent()fonction est utilisée pour créer unévénement de filobjet, qui est utilisé pour la synchronisation entre les threads, permettant à un thread d'attendre une notification ou un signal d'un autre thread.
LeEvent()La fonction renvoie aThreadEvent object.
ThreadEventobjet
Événement
function consumer(productionQuantity, dict, pEvent, cEvent) {
for (var i = 0; i < productionQuantity; i++) {
while (dict.get("array").length == 0) {
pEvent.wait()
}
if (pEvent.isSet()) {
pEvent.clear()
}
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
cEvent.set()
Sleep(1000)
}
}
function producer(productionQuantity, dict, pEvent, cEvent) {
for (var i = 0; i < productionQuantity; i++) {
while (dict.get("array").length != 0) {
cEvent.wait()
}
if (cEvent.isSet()) {
cEvent.clear()
}
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
pEvent.set()
Sleep(1000)
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var pEvent = threading.Event()
var cEvent = threading.Event()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, pEvent, cEvent)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, pEvent, cEvent)
consumerThread.join()
producerThread.join()
}
Deux fils concurrents accèdent à une ressource commune.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop eventop}
LeDict()fonction est utilisée pour créer un objet de dictionnaire pour passer à des threads concurrents.
LeDict()La fonction renvoie aThreadDict object.
ThreadDictobjet
Le dictionnaire
function threadFun1(obj) {
obj["age"] = 100
while (true) {
Log("threadFun1 obj:", obj)
Sleep(5000)
}
}
function threadFun2(obj) {
while (true) {
Log("threadFun2 obj:", obj)
Sleep(5000)
}
}
function main() {
var obj = {"age": 10}
var t1 = threading.Thread(threadFun1, obj)
var t2 = threading.Thread(threadFun2, obj)
t1.join()
t2.join()
}
Passer un objet normal à la fonction d'exécution de thread concurrent pour tester si la modification de la valeur de clé de l'objet entraînera des modifications de la valeur de clé de l'objet dans d'autres threads.
function threadFun1(threadDict) {
threadDict.set("age", 100)
while (true) {
Log(`threadFun1 threadDict.get("age"):`, threadDict.get("age"))
Sleep(5000)
}
}
function threadFun2(threadDict) {
while (true) {
Log(`threadFun2 threadDict.get("age"):`, threadDict.get("age"))
Sleep(5000)
}
}
function main() {
var threadDict = threading.Dict()
threadDict.set("age", 10)
var t1 = threading.Thread(threadFun1, threadDict)
var t2 = threading.Thread(threadFun2, threadDict)
t1.join()
t2.join()
}
Passe leThreadDictl'objet créé par leDict()fonction à la fonction d'exécution de thread en parallèle, et tester si la modification de la valeur de clé de l'objet entraînera la modification de la valeur de clé de l'objet dans d'autres threads.
Lorsqu'un objet commun est passé à une fonction de thread concurrent, il est passé comme une copie profonde.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}
Lependingfonction est utilisée pour obtenir le nombre de threads simultanés exécutés dans le programme de stratégie en cours.
Lepending()la fonction renvoie le nombre de threads simultanés que le programme de stratégie en cours exécute.
Numéro
En attente
function threadFun1() {
Log("threadFun1")
Sleep(3000)
}
function threadFun2() {
for (var i = 0; i < 3; i++) {
LogStatus(_D(), "print from threadFun2")
Sleep(3000)
}
}
function main() {
Log(`begin -- threading.pending():`, threading.pending())
var t1 = threading.Thread(threadFun1)
var t2 = threading.Thread(threadFun2)
Log(`after threading.Thread -- threading.pending():`, threading.pending())
t1.join()
t2.join()
Log(`after thread.join -- threading.pending():`, threading.pending())
}
Créez deux threads en cours d'exécution simultanée et appelez lepending()fonctionner à différents nœuds horaires.
Lorsque la stratégiemain()fonction commence à fonctionner, appelant la fonctionpending()directement renverra 1, parce que le fil principal où la stratégiemain()fonction est situé est également un fil en attente.
Il prend en charge le système de backtesting et l'environnement de trading en direct.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/eventLoop}
ThreadLes objets peuvent être créés ou retournés parthreading.Thread(), threading.getThread(), threading.mainThread(), etthreading.currentThread().
LepeekMessage()la fonction est utilisée pour obtenir un message d'un thread.
LepeekMessage()fonction renvoie le message reçu par le thread associé à l'objet de thread en cours.
chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système
Je suis en train de lire un article. Je suis en train d'essayer d'arrêter.
Le paramètretimeoutest le paramètre de temps d'arrêt. Il bloque et attend le nombre de millisecondes défini par le paramètre et renvoie les données. S'il n'y a pas de données et que le temps d'arrêt dépasse la limite, une valeur nulle est renvoyée. Sitimeoutest réglé sur 0 ou letimeoutsi le paramètre n'est pas passé, cela signifie que le processus va bloquer et attendre jusqu'à ce que les données soient reçues du canal.timeoutSi la valeur est réglée sur -1, cela signifie que le processus ne bloquera pas et ne renverra pas les données immédiatement.
temps d'arrêt faux Numéro
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 postMessage():", i)
threading.mainThread().postMessage(i)
Sleep(500)
}
})
while (true) {
var msg = threading.currentThread().peekMessage()
Log("main peekMessage():", msg)
if (msg == 9) {
break
}
Sleep(1000)
}
t1.join()
}
Envoyer des messages au fil principal à partir d'un fil concurrent.
Lorsque nous écrivons des programmes, nous devons prêter attention aux problèmes d'impasse des threads.
{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@Threads/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}
LepostMessage()fonction est utilisée pour envoyer un message à un thread.
PostMessage (message)
Le paramètremsgest le message à envoyer.
Message à envoyer vrai Tout type pris en charge par le système, tel que chaîne, nombre, bool, objet, tableau, valeur nulle, etc.
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 postMessage():", i)
threading.mainThread().postMessage(i)
Sleep(500)
}
})
for (var i = 0; i < 10; i++) {
var event = threading.mainThread().eventLoop()
Log("main event:", event)
Sleep(500)
}
t1.join()
}
Envoyer des messages dans des threads simultanés et utilisereventLoop()pour recevoir des notifications de messages.
Lorsque la fonction d'exécution d'un thread appelle lepostMessage()Nous pouvons utiliser la fonction pour envoyer un signal ou des données, un événement de message est également généré.eventLoop()fonction de réception des notifications de messages.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Threads/eventLoop eventLoop}
Lejoin()fonction est utilisée pour attendre que le thread sorte et récupère les ressources du système.
LeThreadRetobjetcontient des données sur le résultat de l'exécution.
ThreadRetobjet
rejoignez rejoindre ((timeout)
LetimeoutLe paramètre est utilisé pour définir le temps d'arrêt en millisecondes pour attendre la fin du fil.timeoutparamètre est réglé sur 0 ou letimeoutparamètre n'est pas réglé, lejoin()fonction va bloquer et attendre jusqu'à ce que le fil termine l'exécution.timeoutle paramètre est réglé sur -1,join()La fonction va revenir immédiatement.
temps d'arrêt faux Numéro
function main() {
var t1 = threading.Thread(function() {
Log("Hello thread1")
Sleep(5000)
})
var ret = t1.join(1000)
Log("ret:", ret) // ret: undefined
ret = t1.join()
Log("ret:", ret) // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}
Testez lejoin()fonction pour le temps d'arrêt et la sortie de la valeur de retour.
Lejoin()temps de sortie et de retour de la fonctionundefined.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
Leterminate()fonction est utilisée pour mettre fin de force à un thread et libérer les ressources matérielles utilisées par le thread créé.
terminé
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 10; i++) {
Log("thread1 i:", i)
Sleep(1000)
}
})
Sleep(3000)
t1.terminate()
Log("after t1.terminate()")
while (true) {
LogStatus(_D())
Sleep(1000)
}
}
Terminer l'exécution d'un thread par la force. Après avoir terminé un thread par la force, il n'y aura pas de sortie de ce thread dans le journal.
Pour les fils qui sont terminés de force par leterminate()Nous ne pouvons plus utiliser lejoin()fonction d'attendre qu'ils se terminent.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Threads/eventLoop Loop}
LegetData()Les données sont valables lorsque le thread n'a pas exécuté lejoin()fonction (en attente de sortie réussie) et n'a pas exécuté leterminate()fonction (termination du fil par la force).
LegetData()La fonction renvoie la valeur de clé correspondant à la valeur dekeyparamètre dans la paire clé-valeur stockée dans le contexte du thread en cours.
chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système
- Je ne sais pas. Je suis en train d' écrire.
Lekeyparamètre est le nom de la clé de la paire clé-valeur stockée.
clé vrai chaîne
function main() {
var t1 = threading.Thread(function() {
for (var i = 0; i < 5; i++) {
threading.currentThread().setData("count", i)
Log(`setData("count"):`, i)
Sleep(1000)
}
})
for (var i = 0; i < 5; i++) {
var count = threading.getThread(t1.id()).getData("count")
Log(`getData("count"):`, count)
Sleep(1000)
}
t1.join()
}
Enregistrer la valeur de la clécountdans l'environnement de fil en parallèle, puis lire la valeur clé decountdans le fil principal.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/
LesetData()la fonction est utilisée pour stocker des variables dans le contexte du thread.
définitionDétails (clé, valeur)
Lekeyparamètre est utilisé pour spécifier le nom de clé de la paire clé-valeur stockée.
clé
vrai
chaîne
Levalueparamètre est utilisé pour spécifier la valeur de clé de la paire clé-valeur stockée.
valeur vrai Tout type pris en charge par le système, tel que chaîne, nombre, bool, objet, tableau, valeur nulle, etc.
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Sleep(1000)
Log(`t1.getData("data"):`, t1.getData("data"))
t1.join()
}
Définissez la paire clé-valeur dans le thread concurrent et lisez la paire clé-valeur dans le thread principal.
Les données sont valables lorsque le thread n'a pas exécuté lejoin()fonction (en attente de sortie réussie) et n'a pas exécuté leterminate()La valeur du paramètrevaluedoit être une variable sérialisable.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/eventLoop eventLoop}
Leid()fonction est utilisée pour retourner lethreadIdde l'instance d'objet multithread actuelle.
La valeur de rendement de laid()la fonction estthreadId.
Numéro
Nom de l'entreprise
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.id():`, t1.id())
t1.join()
}
Créez un fil en cours d'exécution simultanée et sortez lethreadIdde ce fil parallèle dans le fil principal.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
Lename()fonction est utilisée pour renvoyer le nom de l'instance d'objet multithreaded en cours.
Lename()la fonction renvoie le nom du fil concurrent.
une chaîne
Nom (s)
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.name():`, t1.name()) // t1.name(): Thread-1
t1.join()
}
Créez un fil de discussion concurrent et sortez le nom du fil de discussion concurrent dans le fil principal.
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/thread/eventLoop eventLoop}
LeeventLoop()la fonction est utilisée pour écouter les événements reçus par le thread.
LeeventLoop()fonction renvoie les informations d'événement reçues par le fil courant.Structure de l'information sur les événements.
objet, valeur nulle
événementLoop() événement Loop (délai de réponse)
Le paramètretimeoutest le temps d'arrêt en millisecondes.timeouts'il est défini sur 0, il attend qu'un événement se produise avant de retourner. s'il est supérieur à 0, il définit le temps d'attente de l'événement. s'il est inférieur à 0, il renvoie immédiatement le dernier événement.
temps d'arrêt faux Numéro
function main() {
var t1 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop() // Blocking wait
// 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
Log(_D(), "thread1 eventMsg:", eventMsg)
}
})
var t2 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(-1) // Return immediately
Log(_D(), "thread2 eventMsg:", eventMsg)
Sleep(5000)
}
})
var t3 = threading.Thread(function() {
while (true) {
var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
Log(_D(), "thread3 eventMsg:", eventMsg)
}
})
t1.postMessage("Hello ", t1.name())
t2.postMessage("Hello ", t2.name())
t3.postMessage("Hello ", t3.name())
t1.join()
t2.join()
t3.join()
}
Exécuter trois threads simultanément et produire les informations d'événement reçues.
Le mécanisme de traitement deseventLoop()est la même que la fonction globaleEventLoop().
{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/name name},
Objet de verrouillage de thread, utilisé pour le traitement de synchronisation multi-thread.
Leacquire()la fonction est utilisée pour demander un verrouillage de fil.
acquérir
Veuillez vous référer authreading.Lock()section pour les exemples.
Leacquire()fonction est utilisée pour demander un verrouillage de thread.acquire()fonction d'un objet de verrouillage de thread, il tente d'acquérir le verrouillage. Si le verrouillage n'est pas actuellement détenu par un autre thread, le thread appelant acquiert avec succès le verrouillage et continue l'exécution. Si le verrouillage est déjà détenu par un autre thread, le thread appelantacquire()sera bloqué jusqu'à ce que le verrou soit relâché.
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release} Je suis désolé.
Lerelease()fonction est utilisée pour libérer un verrou de fil (déverrouiller).
libération
function consumer(productionQuantity, dict, pLock, cLock) {
for (var i = 0; i < productionQuantity; i++) {
pLock.acquire()
cLock.acquire()
var arr = dict.get("array")
var count = arr.shift()
dict.set("array", arr)
Log("consumer:", count, ", array:", arr)
cLock.release()
Sleep(1000)
pLock.release()
}
}
function producer(productionQuantity, dict, pLock, cLock) {
for (var i = 0; i < productionQuantity; i++) {
cLock.acquire() // cLock.acquire() placed after pLock.acquire() will not cause deadlock
pLock.acquire()
var arr = dict.get("array")
arr.push(i)
dict.set("array", arr)
Log("producer:", i, ", array:", arr)
pLock.release()
Sleep(1000)
cLock.release()
}
}
function main() {
var dict = threading.Dict()
dict.set("array", [])
var pLock = threading.Lock()
var cLock = threading.Lock()
var productionQuantity = 10
var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)
consumerThread.join()
producerThread.join()
}
Test de scénarios d'impasse
Il convient de noter que l'utilisation inappropriée de serrures à fil peut entraîner un blocage.
{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/acquérir acquérir}
Objet événement, utilisé pour la notification et le signal d'événement multi-threaded.
Leset()La fonction est utilisée pour notifier les événements (signaux définis).
le groupe
Veuillez vous référer authreading.Event()section pour les exemples.
Si le signal a été réglé en utilisantset()Il faut nettoyer le signal et le réinitialiser.
{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Leclear()fonction est utilisée pour effacer le signal.
C' est clair.
Veuillez vous référer authreading.Event()section pour les exemples.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Lewait()fonction est utilisée pour définir un événement (signal) d'attente, et va bloquer avant que l'événement (signal) est définie; il prend en charge la définition d'un paramètre de temps d'arrêt.
Lewait()la fonction renvoie si le timeout s'est produit. Si oui, elle renvoie une valeur vraie.
Boole
Attends! Attends une minute.
LetimeoutLe paramètre est utilisé pour définir le temps d'attente en millisecondes.
temps d'arrêt faux Numéro
function main() {
var event = threading.Event()
var t1 = threading.Thread(function(event) {
var ret = event.wait(100)
Log(`event.wait(100):`, ret)
ret = event.wait()
Log(`event.wait():`, ret)
}, event)
Sleep(1000)
event.set()
t1.join()
}
Testez la valeur de retour duwait() function.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
LeisSet()fonction est utilisée pour déterminer si un événement (signal) a été défini.
LeisSet()la fonction renvoie si l'événement (signal) a été défini; si l'événement (signal) a été défini, elle renvoie une valeur vraie.
Boole
estSélectionné ((()
Veuillez vous référer authreading.Event()section pour les exemples.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/Threads/ThreadEvent/wait wait}, {@fun/Threads/Threads/ThreadEvent/wait wait}, {@fun/Threads/Threads/ThreadEvent/wait wait}, {@fun/Threads/Threads/Threads/Wait wait}, {@fun/Threads/Threads/Wait wait wait}, {@fun/Threads/ThreadsEvent/wait wait wait}, {@fun/Threads/ThreadsEvent/Wait wait}, {@fun/Th
Objet de condition, utilisé pour la synchronisation multi-thread.
Lenotify()fonction est utilisée pour réveiller un fil d'attente (le cas échéant).wait()La méthode sera réveillée.
Il faut le signaler.
function consumer(dict, condition) {
while (true) {
condition.acquire()
while (dict.get("array").length == 0) {
Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
condition.wait()
}
var arr = dict.get("array")
var num = arr.shift()
Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
dict.set("array", arr)
Sleep(1000)
condition.release()
}
}
function main() {
var condition = threading.Condition()
var dict = threading.Dict()
dict.set("array", [])
var t1 = threading.Thread(consumer, dict, condition)
var t2 = threading.Thread(consumer, dict, condition)
var t3 = threading.Thread(consumer, dict, condition)
Sleep(1000)
var i = 0
while (true) {
condition.acquire()
var msg = ""
var arr = dict.get("array")
var randomNum = Math.floor(Math.random() * 5) + 1
if (arr.length >= 3) {
condition.notifyAll()
msg = "notifyAll"
} else {
arr.push(i)
dict.set("array", arr)
if (randomNum > 3 && arr.length > 0) {
condition.notify()
msg = "notify"
} else {
msg = "pass"
}
i++
}
Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
condition.release()
Sleep(1000)
}
}
Utilisez lenotify()fonction pour réveiller le fil d'attente.
Lenotify()fonction réveille un fil dans la file d'attente.
Lorsque lenotify()fonction réveille un fil, le fil récupérera le verrou de fil.
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquérir acquérir}, {@fun/Threads/ThreadCondition/release release}
LenotifyAll()la fonction réveille tous les threads en attente.
Je vous préviens.
Veuillez vous référer auThreadCondition.notify()section pour les exemples.
LenotifyAll()fonction réveille tous les fils en attente un par un, et les fils réveillés reprennent le verrou de fil.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquérir acquérir}, {@fun/Threads/ThreadCondition/release release}
Lewait()La fonction est utilisée pour faire attendre un fil dans certaines conditions de conception.
Attends!
Veuillez vous référer auThreadCondition.notify()section pour les exemples.
Lewait()La fonction relâche le verrouillage du fil et récupère le verrouillage du fil lorsqu'il est réveillé.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquérir acquérir}, {@fun/Threads/ThreadCondition/release release}
Leacquire()la fonction est utilisée pour demander un verrouillage de fil.
acquérir
Veuillez vous référer auThreadCondition.notify()section pour les exemples.
Avant utilisationwait(), vous devez demander le verrouillage de thread (verrouillage) de l'objet condition actuel.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}
Lerelease()fonction est utilisée pour libérer un verrou de fil (déverrouiller).
libération
Veuillez vous référer auThreadCondition.notify()section pour les exemples.
Après utilisationwait(), nous avons besoin de libérer le verrouillage de fil (déverrouiller) de l'objet condition actuelle.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquérir acquérir}
Objet de dictionnaire, utilisé pour le partage de données.
Leget()fonction est utilisée pour obtenir la valeur de clé enregistrée dans l'objet du dictionnaire.
Leget()Retourne la valeur de la clé spécifiée par lekey parameter.
chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système
Je vais vous donner une clé.
LekeyLe paramètre est utilisé pour spécifier le nom de la clé correspondant à la clé à obtenir.
clé vrai chaîne
function main() {
var event = threading.Event()
var dict = threading.Dict()
dict.set("data", 100)
var t1 = threading.Thread(function(dict, event) {
Log(`thread1, dict.get("data"):`, dict.get("data"))
event.set()
event.clear()
event.wait()
Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
dict.set("data", 0)
}, dict, event)
event.wait()
dict.set("data", 99)
event.set()
event.clear()
t1.join()
Log(`main thread, dict.get("data"):`, dict.get("data"))
}
Utiliser des objets événement pour notifier les threads pour lire et modifier les données.
{@fun/Threads/ThreadDict/set set} Je ne sais pas si vous êtes d'accord.
Leset()La fonction est utilisée pour définir une paire clé-valeur.
définition (clés, valeurs)
Le paramètrekeyest utilisé pour définir le nom de la clé à modifier.
clé
vrai
chaîne
Le paramètrevalueest utilisé pour définir la valeur clé à modifier.
valeur vrai chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système
Veuillez vous référer auThreadDict.get()section pour les exemples.
Je ne sais pas.
Dans la plateforme de trading FMZ Quant, il implémente principalement diverses fonctions, appels liés à la blockchain viaexchange.IO()Le document suivant décrit lesexchange.IO()La méthode d'appel de l'appareilexchange.IO("abi", ...)fonction est utilisée pour enregistrer un ABI.
exchange.IO(k, adresse, contenu abi)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"abi"signifie que la fonction est utilisée pour enregistrerABI- Je ne sais pas.
K
vrai
chaîne
LeaddressLe paramètre est utilisé pour spécifier l'adresse du contrat intelligent.
l'adresse
vrai
chaîne
LeabiContentparamètre est utilisé pour spécifier leABIdu contrat intelligent.
Le contenu
vrai
chaîne
function main() {
// register Uniswap SwapRouter02 abi
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
// Get the ```ABI``` content of the contract can be obtained with the following URL, taking the ```result``` field only, e.g:
exchange.IO("abi", routerAddress, abi)
}
Les méthodes d'appel de contrats intelligents n'ont pas besoin d'être enregistrées si elles sont des méthodes ERC20 standard.
Prends leABILe contenu du marché peut être obtenu à l'adresse URL suivante, en prenant leresultuniquement sur le terrain, par exemple:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
La méthode d'appel deexchange.IO("api", "eth", ...)fonction est utilisée pour appeler la méthode Ethereum RPC.
Leexchange.IO("api", "eth", ...)la fonction renvoie la valeur de retour de la méthode appelée RPC.
chaîne, nombre, bool, objet, tableau, nul et tous les autres types pris en charge par le système
exchange.IO(k, chaîne de blocs, méthode rpc)exchange.IO(k, chaîne de blocs, méthode rpc,...args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"api"indique que la fonction est utilisée pour étendre la demande d'appel.
K
vrai
chaîne
LeblockChainLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"eth"indique que la fonction est utilisée pour les appels de méthode RPC sur le réseau Ethereum.
Chaîne de blocs
vrai
chaîne
LerpcMethodparamètre est utilisé pour définir la méthode RPC à appeler par leexchange.IO()fonction.
RpcMéthode
vrai
chaîne
Leargparamètre est utilisé pour spécifier les paramètres de la méthode RPC à appeler.argLe type et le nombre deargLes paramètres dépendent de la méthode RPC spécifiée par lerpcMethodparamètre.
arg
faux
chaîne, nombre, bool, objet, tableau, fonction, nul et tous les autres types pris en charge par le système
function main() {
// "owner" needs to be replaced with the specific wallet address
// Parameter labels for the "latest" string position: 'latest', 'earliest' or 'pending', please refrer to https://eth.wiki/json-rpc/API#the-default-block-parameter
// The return value ethBalance is a hexadecimal string: 0x9b19ce56113070
var ethBalance = exchange.IO("api", "eth", "eth_getBalance", "owner", "latest")
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Because of the JavaScript language precision, it is necessary to use the system underlying package function BigInt, BigDecimal to process
// Convert ethBalance to readable amount, 0x9b19ce56113070 to 0.043656995388076145
Log(Number((BigDecimal(BigInt(ethBalance))/BigDecimal(Math.pow(10, ethDecimal))).toString()))
}
Vérifiez le solde d'ETH dans votre portefeuille:
function mian() {
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Number of transfers, readable amount e.g. 0.01 ETH
var sendAmount = 0.01
// Due to the JavaScript language precision, it is necessary to use the system underlying encapsulated functions BigInt, BigDecimal to process, and to convert the readable amount to the data processed on the chain
var toAmount = (BigDecimal(sendAmount)*BigDecimal(Math.pow(10, ethDecimal))).toFixed(0)
// "toAddress" is the address of the recipient's ETH wallet at the time of the transfer, which needs to be filled in specifically, and toAmount is the number of transfers
exchange.IO("api", "eth", "send", "toAddress", toAmount)
}
Pour les virements en ETH, vous pouvez définir le{gasPrice: 11, gasLimit: 111, nonce: 111}paramètre, qui est réglé sur le dernier paramètre duexchange.IO()Vous pouvez omettre lesnonceet utiliser le système par défaut, ou laissergasLimit/gasPrice/noncedésactiver et utiliser la valeur par défaut du système pour tous.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0)) // 5000000000 , in wei (5 gwei)
}
RequêtesgasPrice:
function toAmount(s, decimals) {
// The toAmount function can convert hex-encoded values to decimal values
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// Coding approve (authorization) method calls
var data = exchange.IO("encode", "0x111111111117dC0aa78b770fA6A738034120C302", "approve", "0xe592427a0aece92de3edee1f18e0157c05861564", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("data:", data)
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0))
var obj = {
"from" : "0x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // walletAddress
"to" : "0x111111111117dC0aa78b770fA6A738034120C302",
"gasPrice" : gasPrice,
"value" : "0x0",
"data" : "0x" + data,
}
var gasLimit = exchange.IO("api", "eth", "eth_estimateGas", obj)
Log("gasLimit:", toAmount(gasLimit, 0))
Log("gas fee", toAmount(gasLimit, 0) * toAmount(gasPrice, 0) / 1e18)
}
Requêteseth_estimateGas:
Le deuxième paramètre duexchange.IO()fonction avec"eth"peut appeler directement les méthodes RPC disponibles pour le serveur de nœud Ethereum.
Je ne sais pas.
Leexchange.IO("encode", ...)la fonction est appelée pour l'encodage des données.
Leexchange.IO("encode", ...)fonction renvoie les données codées.
chaîne
exchange.IO(k, format de données,... args)exchange.IO(k, adresse, format des données)exchange.IO(k, adresse, donnéesFormat,...args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"encode"signifie que la fonction est utilisée pour l'encodage des données.
K
vrai
chaîne
LeaddressLe paramètre est utilisé pour définir l'adresse du contrat intelligent.exchange.IO("encode", ...)fonction, en passant dans leaddressParamètre indique le codage de l'appel de méthode sur le contrat intelligent.exchange.IO("encode", ...)fonction, si leaddressparamètre n'est pas passé, la fonction est utilisée pour coder l'ordre de type spécifié et est fonctionnellement équivalente àabi.encodedansSolidity- Je ne sais pas.
l'adresse
faux
chaîne
LedataFormatparamètre est utilisé pour spécifier la méthode, le type et l'ordre des données codées.
donnéesFormat
vrai
chaîne
Leargparamètre est utilisé pour spécifier la valeur de données spécifique qui correspond à ladataFormatIl peut y avoir plus d'unargparamètre, ainsi que le type et leargLes paramètres dépendent de ladataFormatréglage des paramètres.
arg
faux
chaîne, nombre, tuple, tableau et tous les autres types pris en charge par le système
function main() {
// Main network address of ContractV3SwapRouterV2: 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
// Calling the unwrapWETH9 method requires registering the ABI first, which is omitted here
// "owner" represents the wallet address, which need to fill in the specific, 1 represents the number of unpacking, unpacking a WETH into ETH
var data = exchange.IO("encode", "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "unwrapWETH9(uint256,address)", 1, "owner")
Log(data)
}
Par exemple, appeler la méthode d'encodageunwrapWETH9:
function main() {
var x = 10
var address = "0x02a5fBb259d20A3Ad2Fdf9CCADeF86F6C1c1Ccc9"
var str = "Hello World"
var array = [1, 2, 3]
var ret = exchange.IO("encode", "uint256,address,string,uint256[]", x, address, str, array) // uint i.e. uint256 , the type length needs to be specified on FMZ
Log("ret:", ret)
/*
000000000000000000000000000000000000000000000000000000000000000a // x
00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address
0000000000000000000000000000000000000000000000000000000000000080 // Offset of str
00000000000000000000000000000000000000000000000000000000000000c0 // Offset of array
000000000000000000000000000000000000000000000000000000000000000b // The length of str
48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str data
0000000000000000000000000000000000000000000000000000000000000003 // The length of the array
0000000000000000000000000000000000000000000000000000000000000001 // array the first data
0000000000000000000000000000000000000000000000000000000000000002 // array the second data
0000000000000000000000000000000000000000000000000000000000000003 // array the third data
*/
}
Il est équivalent à l'exemple de codage deabi.encodedansSolidity:
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
}
Il prend en charge l'encodage d'une tuple ou d'un ordre de type contenant une tuple.
Cet ordre de type est composé de:tuple, bytesAlors quand tu appellesexchange.IO()pour le codage, vous devez continuer à passer deux paramètres:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Les paramètres transmis doivent également être conformes à la structure et au type detuple, au sens de la définitiontypesparamètre du formulaire:tuple(a uint256,b uint8,c address).
bytes:"0011"
function main() {
var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"] // ETH address, USDT address
var ret = exchange.IO("encode", "address[]", path)
Log("encode: ", ret)
}
Il prend en charge le codage séquentiel de tableaux ou de types contenant des tableaux:
Leexchange.IO()fonction encapsule leencodeméthode, qui peut renvoyer le code d'appel de fonction àhexPour une utilisation spécifique, vous pouvez vous référer aux plateformes accessibles au public
Leexchange.IO("encodePacked", ...)fonction est appelée d'une manière qui est utilisé pourencodePacked encoding.
Leexchange.IO("encodePacked", ...)Retourne leencodePackeddonnées codées.
chaîne
exchange.IO(k, format de données,... args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"encodePacked"signifie que la fonction est utilisée pour les donnéesencodePackedle codage.
K
vrai
chaîne
LedataFormatLe paramètre est utilisé pour spécifier le type et l'ordre desencodePackeddonnées codées.
donnéesFormat
vrai
chaîne
Leargparamètre est utilisé pour spécifier la valeur de données spécifique qui correspond à ladataFormatIl peut y avoir plus d'unargparamètre, ainsi que le type et leargLes paramètres dépendent de ladataFormatréglage des paramètres.
arg
vrai
chaîne, nombre, tuple, tableau et tous les autres types pris en charge par le système
function main() {
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
var tokenOutAddress = "0x6b175474e89094c44da98b954eedeac495271d0f"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
}
Lors de l' utilisationUniswap V3, vous devez passer dans les paramètres comme le chemin d'échange, vous devez utiliser leencodePackedopération de codage:
Leexchange.IO("decode", ...)La fonction est appelée d'une manière qui est utilisée pour le décryptage.
Leexchange.IO("decode", ...)Retourne une chaîne quand il n'y a qu'une seule donnée spécifiée par ledataFormatRetourne un tableau lorsqu'il y a plus d'une donnée spécifiée par ledataFormatparamètre.
Le nombre d'éléments
exchange.IO(k, donnéesFormat, données
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, et le régler sur"decode"signifie que la fonction est utilisée pour le décryptage des données.
K
vrai
chaîne
LedataFormatLe paramètre est utilisé pour spécifier le type et l'ordre des données décodées.
donnéesFormat
vrai
chaîne
Ledataparamètre est utilisé pour définir les données à décoder.
données
vrai
chaîne
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
var rawData = exchange.IO("decode", types, ret)
Log("decode:", rawData)
}
Le fonctionnement inverse de laexchange.IO("encode", ...)fonction:
function main() {
// register SwapRouter02 abi
var walletAddress = "0x398a93ca23CBdd2642a07445bCD2b8435e0a373f"
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
exchange.IO("abi", routerAddress, abi) // abi only uses the contents of the local exactOutput method, the full abi can be searched on the Internet
// encode path
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
var tokenOutAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
var dataTuple = {
"path" : path,
"recipient" : walletAddress,
"amountOut" : 1000,
"amountInMaximum" : 1,
}
// encode SwapRouter02 exactOutput
var rawData = exchange.IO("encode", routerAddress, "exactOutput", dataTuple)
Log("method hash:", rawData.slice(0, 8)) // 09b81346
Log("params hash:", rawData.slice(8))
// decode exactOutput params
var decodeRaw = exchange.IO("decode", "tuple(path bytes,recipient address,amountOut uint256,amountInMaximum uint256)", rawData.slice(8))
Log("decodeRaw:", decodeRaw)
}
L'exemple suivant effectue d'abord uneencodePackedopération sur lepathLe traitement des paramètres,exactOutputl'appel de méthode qui doit être codé plus tard nécessitepathcomme un paramètre.encodeLeexactOutputméthode du contrat de routage, qui ne comporte qu'un seul paramètre de typetuple. Le nom de la méthodeexactOutputest codé comme suit:0x09b81346, et en utilisant leexchange.IO("decode", ...)méthode de décryptage du code résultantdecodeRaw, cohérente avec la variabledataTuple.
Pour le traitement des données, leexchange.IO()fonction prend en charge non seulement le codage, mais aussi le décodage.
Leexchange.IO("key", ...)La fonction est appelée de manière à changer les clés privées.
exchange.IO(K, clé)
Le paramètrekest utilisé pour régler la fonction duexchange.IO()fonction, réglée sur"key"signifie que la fonction est utilisée pour changer la clé privée.
K
vrai
chaîne
LekeyLe paramètre est utilisé pour définir la clé privée.
clé
vrai
chaîne
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Leexchange.IO()Il est également possible d'ajouter plusieurs objets d'échange (voir: {@var/EXCHANGE/exchanges exchanges}) pour manipuler plusieurs adresses de portefeuille.
Leexchange.IO("api", ...)la fonction est appelée d'une manière qui est utilisée pour appeler les méthodes du contrat intelligent.
Leexchange.IO("api", ...)la fonction renvoie la valeur de retour de la méthode appelée contrat intelligent.
chaîne, nombre, bool, objet, tableau, nul et tous les autres types pris en charge par le système
exchange.IO(k, adresse, méthode)exchange.IO(k, adresse, méthode,... arguments)exchange.IO(k, adresse, méthode, valeur,... args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"api"indique que la fonction est utilisée pour étendre la demande d'appel.
K
vrai
chaîne
LeaddressLe paramètre est utilisé pour spécifier l'adresse du contrat intelligent.
l'adresse
vrai
chaîne
LemethodLe paramètre est utilisé pour spécifier la méthode du contrat intelligent à appeler.
méthode
vrai
chaîne
LevalueLe paramètre est utilisé pour définir la quantité d'ETH à envoyer.stateMutabilityl'attribut de la méthode de contrat intelligent à exécuter estpayable, puis levalueLe paramètre doit être passé."stateMutability": "payable"L'attribut peut être consulté depuis l'ABI.exchange.IO()La fonction déterminera le paramètre requis sur la base de lastateMutabilityL'attribut dans l'ABI qui a été enregistré.stateMutabilityl'attribut estnonpayable, puis levaluele paramètre n'a pas besoin d'être passé.
valeur
faux
Numéro, chaîne
Leargparamètre est utilisé pour spécifier les paramètres de la méthode du contrat intelligent à appeler.argparamètre, ainsi que le type et leargLes paramètres dépendent de la méthode du contrat intelligent à appeler.
arg
faux
chaîne, nombre, bool, et tous les autres types pris en charge par le système
function main(){
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302" // The contract address of the token, the token is 1INCH in the example
Log(exchange.IO("api", tokenAddress, "decimals")) // Query, print 1INCH tokens with precision index of 18
}
Ledecimalsla méthode est uneconstantLa méthode ERC20 qui ne nécessite pas de consommation de gaz et qui peut interroger les données de précision d'un jeton.decimalsLa méthode n'a pas de paramètres. Valeur de retour: les données de précision du jeton.
function main(){
// The contract address of the token, in the example the token is 1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// For example, the query yields 1000000000000000000, divided by the precision unit of the token 1e18, the wallet to which the current exchange object is bound has authorized 1 1INCH to the spender address
Log(exchange.IO("api", tokenAddress, "allowance", "owner", "spender"))
}
Leallowancela méthode est uneconstantLa méthode ERC20 qui ne génère pas de consommation de gaz et peut interroger le montant autorisé d'un jeton pour une certaine adresse de contrat.allowanceLa méthode prend 2 paramètres, le premier est l'adresse du portefeuille et le second est l'adresse autorisée.
owner: l'adresse du portefeuille, l'exemple est remplacé par la chaîne spender: l'adresse du contrat autorisé, l'exemple est remplacé par la chaîne Uniswap V3 router v1 address.
function main(){
// The contract address of the token, the token is 1INCH in the example
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// The hexadecimal string of the authorization amount: 0xde0b6b3a7640000 , the corresponding decimal string: 1e18 , 1e18 divided by the precision unit of the token, i.e. 1 token amount, so this refers to the authorization of one token
Log(exchange.IO("api", tokenAddress, "approve", "spender", "0xde0b6b3a7640000"))
}```
The ```approve``` method is a non-```constant``` method of ERC20, which generates gas consumption and is used to authorize the operation amount of a token to a contract address. The ```approve``` method takes 2 parameters, the first one is the address to be authorized and the second one is the amount to be authorized. Return value: txid.
```spender```: the address of the authorized contract, the example is replaced by the string "spender", the actual use needs to fill in the specific address, for example, it can be ```Uniswap V3 router v1``` address. ```0xde0b6b3a7640000```: the number of authorizations, here is the hexadecimal string, the corresponding decimal value is 1e18, divided by the token precision unit in the example (i.e. 1e18). The result is that 1 token is authorized. The third parameter of the ```exchange.IO()``` function is passed to the method name ```approve```, which can also be written in the form of methodId, such as "0x571ac8b0". It is also possible to write the full standard method name, for example: "approve(address,uint256)".
```javascript
function main() {
var ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var tokenInName = "ETH"
var amountIn = 0.01
var options = {gasPrice: 5000000000, gasLimit: 21000, nonce: 100} // This is an example, depending on the actual scene settings
var data = "" // The encoded data, here is the empty string, depending on the actual scene settings
var tx = exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInName == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
}
LemulticallLa méthode est un non-constantméthode deUniswap V3qui génère une consommation de gaz et est utilisée pour échanger des jetons de plusieurs façons.
Lemulticallméthode peut avoir différentes façons de passer des paramètres, vous pouvez vérifier l'ABI qui contient la méthode spécifiquement, vous devez enregistrer l'ABI avant d'appeler la méthode.
Pour des exemples spécifiques demulticallVous pouvez consulter les plateformes accessibles au public
Certains détails sont décrits ici en utilisant un pseudo-code:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: adresse du routeur v2 de Uniswap V3.value: le montant d'ETH à transférer, défini à 0 si le jeton de l'opération d'échange n'est pas ETH.deadline: deadlineest le paramètre dumulticallméthode, qui peut être réglée sur (new Date().getTime() / 1000) + 3600, ce qui indique qu'elle est valable pendant une heure.data: dataest le paramètre dumulticallméthode, les données de l'opération d'emballage à effectuer.
Semblableexchange.IO("api", "eth", "send", "toAddress", toAmount), legasLimit/gasPrice/nonceLa définition de l'appel de méthode peut être spécifiée lors de l'appel de lamulticallméthode.
Encore une fois, nous utilisons un pseudo-code pour décrire:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Le paramètre{gasPrice: 11, gasLimit: 111, nonce: 111}Les paramètres d'interface peuvent être réglés en fonction des besoins spécifiques, qui sont réglés sur le dernier paramètre duexchange.IO()fonction.
Vous pouvez omettrenonceet utiliser la valeur par défaut du système, ou laissergasLimit/gasPrice/noncedésactiver et utiliser la valeur par défaut du système pour tous.
Leexchange.IO("address")la fonction est appelée de manière à obtenir l'adresse du portefeuille configuré par l'objet d'échange {@var/EXCHANGE exchange}.
Leexchange.IO("address")la fonction renvoie l'adresse de portefeuille configurée.
chaîne
exchange.IO(k) Le titre
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"address"signifie que la fonction est utilisée pour obtenir l'adresse de portefeuille configurée.
K
vrai
chaîne
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Leexchange.IO("base", ...)la fonction est appelée de manière à définir l'adresse du nœud RPC.
exchange.IO(k, adresse)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"base"signifie que la fonction est utilisée pour basculer les nœuds RPC.
K
vrai
chaîne
Leaddressle paramètre est utilisé pour définir l'adresse du nœud RPC.
l'adresse
vrai
chaîne
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}
LeTA.MACD()fonction est utilisée pour calculer laIndicateur MACD de dissemblance et de similitude lissée exponentielle.
La valeur de rendement de laTA.MACD()la fonction est un tableau bidimensionnel avec la structure:[DIF, DEA, MACD]- Je ne sais pas.
séquence
TA.MACD ((inReal) TA.MACD ((en temps réel, en temps rapide, en temps lent, en temps de signal)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInFastPeriodparamètre est utilisé pour définir la période rapide.
OptionInFastPeriod
faux
Numéro
LeoptInSlowPeriodLe paramètre est utilisé pour définir la période lente.
OptionInSlowPeriod
faux
Numéro
LeoptInSignalPeriodLe paramètre est utilisé pour définir la période du signal.
OptionPériode de signalisation
faux
Numéro
function main(){
// You can fill in different k-line periods, such as PERIOD_M1,PERIOD_M30,PERIOD_H1...
var records = exchange.GetRecords(PERIOD_M15)
var macd = TA.MACD(records, 12, 26, 9)
// Watching the logs, you can see that three arrays are returned, corresponding to DIF, DEA and MACD.
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
macd = TA.MACD(r, 12, 26, 9)
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2])
void main() {
auto r = exchange.GetRecords(PERIOD_M15);
auto macd = TA.MACD(r, 12, 26, 9);
Log("DIF:", macd[0], "DEA:", macd[1], "MACD:", macd[2]);
}
LeTAIl prend en charge les algorithmes d'indicateurs communs.JavaScript, Python, C++les appels à la stratégie linguistique,code de bibliothèque TA open source- Je ne sais pas.
Les valeurs par défaut duoptInFastPeriod, optInSlowPeriod, etoptInSignalPeriodParamètres duTA.MACD()Les fonctions sont:12, 26, et9.
Je ne sais pas si je peux vous aider, mais j'ai besoin de vous.TA.MAJe ne sais pas si tu veux que je te le dise. Je ne veux pas que tu le dises.
LeTA.KDJ()fonction est utilisée pour calculerIndicateurs stochastiques.
La valeur de rendement de laTA.KDJ()la fonction est un tableau bidimensionnel avec la structure:[K, D, J]- Je ne sais pas.
séquence
Il s'agit d'un projet de loi. TA.KDJ ((en réel, période, kPériode, dPériode)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
Leperiodle paramètre est utilisé pour définir la période 1.
période
faux
Numéro
LekPeriodle paramètre est utilisé pour définir la période 2.
Période
faux
Numéro
LedPeriodle paramètre est utilisé pour définir la période 3.
DPériode
faux
Numéro
function main(){
var records = exchange.GetRecords(PERIOD_M15)
var kdj = TA.KDJ(records, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
}
def main():
r = exchange.GetRecords(PERIOD_M15)
kdj = TA.KDJ(r, 9, 3, 3)
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2])
void main() {
auto r = exchange.GetRecords();
auto kdj = TA.KDJ(r, 9, 3, 3);
Log("k:", kdj[0], "d:", kdj[1], "j:", kdj[2]);
}
Les valeurs par défaut pour leperiod, kPeriod, etdPeriodParamètres duTA.KDJ()Les fonctions sont:9, 3, et3.
Je ne sais pas si vous êtes d'accord avec moi.TA.MAJe ne sais pas si tu veux que je te le dise. Je ne veux pas que tu le dises.
LeTA.RSI()fonction est utilisée pour calculer laIndicateur de force.
La valeur de rendement de laTA.RSI()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux. TA.RSI ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période.
Option dans le tempsPériode
faux
Numéro
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var rsi = TA.RSI(records, 14)
Log(rsi)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
rsi = TA.RSI(r, 14)
Log(rsi)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto rsi = TA.RSI(r, 14);
Log(rsi);
}
La valeur par défaut duoptInTimePeriodparamètre duTA.RSI()la fonction est:14.
Je ne sais pas si tu veux que je te parle, mais je ne peux pas.TA.MAJe ne sais pas si tu veux que je te le dise. Je ne veux pas que tu le dises.
LeTA.ATR()fonction est utilisée pour calculer laIndicateur de volatilité réelle moyenne.
La valeur de rendement de laTA.ATR()fonction est: un tableau unidimensionnel.
séquence
TA.ATR ((inPriceHLC) est le prix de vente du produit. TA.ATR ((en prixHLC, optInTimePeriod)
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période.
Option dans le tempsPériode
faux
Numéro
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var atr = TA.ATR(records, 14)
Log(atr)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
atr = TA.ATR(r, 14)
Log(atr)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto atr = TA.ATR(r, 14);
Log(atr);
}
La valeur par défaut duoptInTimePeriodparamètre duTA.ATR()la fonction est:14.
Je ne sais pas si vous êtes d'accord avec moi.TA.MAJe ne sais pas si tu veux que je te le dise. Je ne veux pas que tu le dises.
LeTA.OBV()fonction est utilisée pour calculer laindicateur de marée énergétique.
La valeur de rendement de laTA.OBV()fonction est: un tableau unidimensionnel.
séquence
Le nombre d'heures de travail TA.OBV ((en Réel, en PrixV)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeinPriceVLe paramètre est utilisé pour spécifier les données relatives au montant de la transaction.
Dans le prix
faux
{@struct/Record Record} tableau de structure
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var obv = TA.OBV(records)
Log(obv)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
obv = TA.OBV(r)
Log(obv)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto obv = TA.OBV(r);
Log(obv);
}
Je ne sais pas si je peux vous aider.TA.MAJe ne sais pas si tu veux que je te le dise. Je ne veux pas que tu le dises.
LeTA.MA()fonction est utilisée pour calculer laIndicateur MACD.
La valeur de rendement de laTA.MA()fonction est: un tableau unidimensionnel.
séquence
TA.MAJe ne suis pas réel.TA.MA(inReal, optInTimePeriod) Le nombre de fois où les données sont utilisées est le nombre de fois où les données sont utilisées.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période.
Option dans le tempsPériode
faux
Numéro
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var ma = TA.MA(records, 14)
Log(ma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
ma = TA.MA(r, 14)
Log(ma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto ma = TA.MA(r, 14);
Log(ma);
}
La valeur par défaut duoptInTimePeriodparamètre duTA.MA()la fonction est:9.
Il est possible que l'un des éléments principaux de la réaction soit la réaction de l'individu à la réaction de l'autre.
LeTA.EMA()fonction est utilisée pour calculer laindicateur moyen exponentiel.
La valeur de rendement de laTA.EMA()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée. TA.EMA ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période.
Option dans le tempsPériode
faux
Numéro
function main(){
var records = exchange.GetRecords()
// Determine if the number of K-line bars meets the calculation period of the indicator
if (records && records.length > 9) {
var ema = TA.EMA(records, 9)
Log(ema)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 9:
ema = TA.EMA(r, 9)
Log(ema)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 9) {
auto ema = TA.EMA(r, 9);
Log(ema);
}
}
La valeur par défaut duoptInTimePeriodparamètre duTA.EMA()la fonction est:9.
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si je peux vous aider.
LeTA.BOLL()fonction est utilisée pour calculer laIndicateur des bandes de Bollinger.
La valeur de rendement de laTA.BOLL()la fonction est un tableau bidimensionnel avec la structure:[upLine, midLine, downLine]- Je ne sais pas.
séquence
Je ne peux pas vous dire ce que je veux. TA.BOLL ((en réel, période, multiplicateur)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeperiodLe paramètre est utilisé pour définir la période.
période
faux
Numéro
LemultiplierLe paramètre est utilisé pour définir le multiplicateur.
le multiplicateur
faux
Numéro
function main() {
var records = exchange.GetRecords()
if(records && records.length > 20) {
var boll = TA.BOLL(records, 20, 2)
var upLine = boll[0]
var midLine = boll[1]
var downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
}
}
def main():
r = exchange.GetRecords()
if r and len(r) > 20:
boll = TA.BOLL(r, 20, 2)
upLine = boll[0]
midLine = boll[1]
downLine = boll[2]
Log(upLine)
Log(midLine)
Log(downLine)
void main() {
auto r = exchange.GetRecords();
if(r.Valid && r.size() > 20) {
auto boll = TA.BOLL(r, 20, 2);
auto upLine = boll[0];
auto midLine = boll[1];
auto downLine = boll[2];
Log(upLine);
Log(midLine);
Log(downLine);
}
}
Les valeurs par défaut pour leperiodetmultiplierParamètres duTA.BOLL()Les fonctions sont:20et2.
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si tu veux que je te parle, mais je ne peux pas.
LeTA.Alligator()fonction est utilisée pour calculer laIndicateur d'alligator.
La valeur de rendement de laTA.Alligator()la fonction est un tableau bidimensionnel avec la structure:[jawLine, teethLine, lipsLine]- Je ne sais pas.
séquence
Je suis un crocodile. TA.Alligator ((enVéritable, mâchoireLongeur, dentsLongeur, lèvresLongeur)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LejawLengthLe paramètre est utilisé pour régler la période de la mâchoire.
la mâchoireLongeur
faux
Numéro
LeteethLengthLe paramètre est utilisé pour régler la période des dents.
dentsLongeur
faux
Numéro
LelipsLengthle paramètre est utilisé pour régler la période de la lèvre supérieure.
Longueur des lèvres
faux
Numéro
function main(){
var records = exchange.GetRecords()
var alligator = TA.Alligator(records)
Log("jawLine:", alligator[0])
Log("teethLine:", alligator[1])
Log("lipsLine:", alligator[2])
}
def main():
records = exchange.GetRecords()
alligator = TA.Alligator(records)
Log("jawLine:", alligator[0])
Log("teethLine:", alligator[1])
Log("lipsLine:", alligator[2])
void main() {
auto records = exchange.GetRecords();
auto alligator = TA.Alligator(records);
Log("jawLine:", alligator[0]);
Log("teethLine:", alligator[1]);
Log("lipsLine:", alligator[2]);
}
Les valeurs par défaut dujawLength, teethLength, etlipsLengthParamètres duTA.Alligator()Les fonctions sont:13, 8, et5.
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si je peux vous aider.
LeTA.CMF()fonction est utilisée pour calculer laIndicateur des flux de trésorerie de Chaikin.
La valeur de rendement de laTA.CMF()fonction est: un tableau unidimensionnel.
séquence
TA.CMF ((inReal) TA.CMF ((en Réel, en PrixV)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeinPriceVLe paramètre est utilisé pour spécifier les données de volume.
Dans le prix
faux
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var cmf = TA.CMF(records)
Log(cmf)
}
def main():
records = exchange.GetRecords()
cmf = TA.CMF(records)
Log(cmf)
void main() {
auto records = exchange.GetRecords();
auto cmf = TA.CMF(records);
Log(cmf);
}
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si je peux vous aider.
LeTA.Highest()fonction est utilisée pour calculer laprix le plus élevé de la période.
LeTA.Highest()La fonction renvoie la valeur maximale d'un attribut dans la dernière certaine période, à l'exclusion du bar actuel.
Numéro
TA.Le plus élevé (en Réel) TA.Le plus élevé (en réel, période, attr)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeperiodLe paramètre est utilisé pour définir la période.
période
faux
Numéro
Leattrparamètre est utilisé pour définir les attributs, facultativement:Open, Close, Low, High, Volume, OpenInterest- Je ne sais pas.
attr
faux
chaîne
function main() {
var records = exchange.GetRecords()
var highestForOpen = TA.Highest(records, 10, "Open")
Log(highestForOpen)
}
def main():
records = exchange.GetRecords()
highestForOpen = TA.Highest(records, 10, "Open")
Log(highestForOpen)
void main() {
auto records = exchange.GetRecords();
auto highestForOpen = TA.Highest(records.Open(), 10);
Log(highestForOpen);
}
Par exemple, si leTA.Highest(records, 30, "High")fonction est appelée, si le paramètre de la périodeperiodest réglée sur0, cela signifie calculer tousBarsdes données de la ligne K transmises par leinRealparamètre; si le paramètre attributattrLes données de la ligne K transmises par leinRealle paramètre est considéré comme un tableau ordinaire.
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si je peux vous aider, mais je vais vous aider.
LeTA.Lowest()fonction est utilisée pour calculer laprix le plus bas de la période.
LeTA.Lowest()La fonction renvoie la valeur minimale d'un attribut dans la dernière certaine période, à l'exclusion du bar courant.
Numéro
TA.Le plus bas ((inReal) TA.Le plus bas (en réel, période, attr)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeperiodLe paramètre est utilisé pour définir la période.
période
faux
Numéro
Leattrparamètre est utilisé pour définir les attributs, facultativement:Open, Close, Low, High, Volume, OpenInterest- Je ne sais pas.
attr
faux
chaîne
function main() {
var records = exchange.GetRecords()
var lowestForOpen = TA.Lowest(records, 10, "Open")
Log(lowestForOpen)
}
def main():
records = exchange.GetRecords()
lowestForOpen = TA.Lowest(records, 10, "Open")
Log(lowestForOpen)
void main() {
auto records = exchange.GetRecords();
auto lowestForOpen = TA.Lowest(records.Open(), 10);
Log(lowestForOpen);
}
Par exemple, si leTA.Lowest(records, 30, "Low")fonction est appelée, si le paramètre de la périodeperiodest réglée sur0, cela signifie calculer tousBarsdes données de la ligne K transmises par leinRealparamètre; si le paramètre attributattrLes données de la ligne K transmises par leinRealle paramètre est considéré comme un tableau ordinaire.
L'utilisation deTA.Highest()etTA.Lowest()Les fonctionnalitésC++Il convient de noter que laHighest()etLowest()Les fonctions ont chacune seulement 2 paramètres.
Et le premier paramètre transmis n'est pas les données de la ligne K.robtenu lorsque la fonctionauto r = exchange.GetRecords()a été appelé.
Vous devez appeler lerLa méthode de pass dans les données d'attribut spécifique.r.Close()les données relatives aux prix de clôture.Close, High, Low, Open, Volumecomme dans ler.Close()méthode d'appel.
Exemple de test deC++stratégie linguistique:
void main() {
Records r;
r.Valid = true;
for (auto i = 0; i < 10; i++) {
Record ele;
ele.Time = i * 100000;
ele.High = i * 10000;
ele.Low = i * 1000;
ele.Close = i * 100;
ele.Open = i * 10;
ele.Volume = i * 1;
r.push_back(ele);
}
for(int j = 0; j < r.size(); j++){
Log(r[j]);
}
// Note: the first parameter passed is not r, you need to call r.Close()
auto highest = TA.Highest(r.Close(), 8);
Log(highest);
}
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si je peux vous aider.
LeTA.SMA()fonction est utilisée pour calculer laindicateur de moyenne mobile simple.
La valeur de rendement de laTA.SMA()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée. TA.SMA ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période.
Option dans le tempsPériode
faux
Numéro
function main(){
var records = exchange.GetRecords(PERIOD_M30)
var sma = TA.SMA(records, 14)
Log(sma)
}
def main():
r = exchange.GetRecords(PERIOD_M30)
sma = TA.SMA(r, 14)
Log(sma)
void main() {
auto r = exchange.GetRecords(PERIOD_M30);
auto sma = TA.SMA(r, 14);
Log(sma);
}
La valeur par défaut duoptInTimePeriodparamètre duTA.SMA()la fonction est:9.
Je ne sais pas si je peux vous aider, mais je vais vous aider.TA.MAJe ne sais pas si tu veux que je te le dise. Je ne veux pas que tu le dises.
Letalib.CDL2CROWS()fonction est utilisée pour calculerDeux corbeaux (graphique en ligne K - Deux corbeaux).
La valeur de rendement de latalib.CDL2CROWS()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL2CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL2CROWS(records);
Log(ret);
}
LeCDL2CROWS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)Pour les appels dans lePythonLe langage, les paramètres de passage est différent et doit être basé sur la description ci-dessus:Records[Open,High,Low,Close].
Exemple de fractionnement d'une variablerecords(par exemple paramètreinPriceOHLC, tapez {@struct/Record Record} une gamme de structures) dans:Openliste: écrite en Python commerecords.Open.
HighListe: écrite commerecords.Highdans Python.Lowliste: écrite en Python commerecords.Low.
Closeliste: écrite en Python commerecords.Close.
Appelé dans le code de stratégie Python:
talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
L'autre.talibLes indicateurs sont décrits de la même manière et ne seront pas répétés.
Letalib.CDL3BLACKCROWS()fonction est utilisée pour calculerTrois corbeaux noirs (graphique en ligne K - Trois corbeaux noirs).
La valeur de rendement de latalib.CDL3BLACKCROWS()fonction est: un tableau unidimensionnel.
séquence
Talib.CDL3BLACKCROWS ((en PrixOHLC) est un groupe de musique américain.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3BLACKCROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3BLACKCROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3BLACKCROWS(records);
Log(ret);
}
LeCDL3BLACKCROWS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL3BLACKCROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDL3INSIDE()fonction est utilisée pour calculerTrois à l'intérieur vers le haut/vers le bas (graphique en ligne K: Trois à l'intérieur vers le haut/vers le bas).
La valeur de rendement de latalib.CDL3INSIDE()fonction est: un tableau unidimensionnel.
séquence
Talib.CDL3INSIDE ((inPriceOHLC) est une série de jeux vidéo.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3INSIDE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3INSIDE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3INSIDE(records);
Log(ret);
}
LeCDL3INSIDE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL3INSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDL3LINESTRIKE()fonction est utilisée pour calculer laStrike de trois lignes (graphique de ligne K: Strike de trois lignes).
La valeur de rendement de latalib.CDL3LINESTRIKE()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3LINESTRIKE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3LINESTRIKE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3LINESTRIKE(records);
Log(ret);
}
LeCDL3LINESTRIKE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL3LINESTRIKE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDL3OUTSIDE()fonction est utilisée pour calculerTrois à l'extérieur vers le haut/vers le bas (graphique en ligne K: Trois à l'extérieur vers le haut/vers le bas).
La valeur de rendement de latalib.CDL3OUTSIDE()fonction est: un tableau unidimensionnel.
séquence
Talib.CDL3OUTSIDE ((inPriceOHLC) est une série de jeux vidéo.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3OUTSIDE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3OUTSIDE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3OUTSIDE(records);
Log(ret);
}
LeCDL3OUTSIDE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL3OUTSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDL3STARSINSOUTH()fonction est utilisée pour calculerTrois étoiles dans le sud (graphique en ligne K: Trois étoiles dans le sud).
La valeur de rendement de latalib.CDL3STARSINSOUTH()fonction est: un tableau unidimensionnel.
séquence
Talib.CDL3STARSINSOUTH ((en PrixOHLC) est une série télévisée.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3STARSINSOUTH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3STARSINSOUTH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3STARSINSOUTH(records);
Log(ret);
}
LeCDL3STARSINSOUTH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL3STARSINSOUTH(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDL3WHITESOLDIERS()fonction est utilisée pour calculerTrois soldats blancs qui avancent (graphique en ligne K: Trois soldats blancs qui avancent).
La valeur de rendement de latalib.CDL3WHITESOLDIERS()fonction est: un tableau unidimensionnel.
séquence
Talib.CDL3 WHITESOLDIERS (en anglais seulement)
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDL3WHITESOLDIERS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDL3WHITESOLDIERS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDL3WHITESOLDIERS(records);
Log(ret);
}
LeCDL3WHITESOLDIERS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDL3WHITESOLDIERS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLABANDONEDBABY()fonction est utilisée pour calculerBébé abandonné (graphique en ligne K: Bébé abandonné).
La valeur de rendement de latalib.CDLABANDONEDBABY()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLABANDONEDBABY (en anglais) Talib.CDLABANDONEDBABY ((en PrixOHLC, optInPénétration) est une série de films télévisés américains.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est utilisé pour définir la pénétration, la valeur par défaut est 0.3.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLABANDONEDBABY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLABANDONEDBABY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLABANDONEDBABY(records);
Log(ret);
}
LeCDLABANDONEDBABY()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLABANDONEDBABY(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Letalib.CDLADVANCEBLOCK()fonction est utilisée pour calculer laBloc d'avance (graphique en ligne K: Avance).
La valeur de rendement de latalib.CDLADVANCEBLOCK()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLADVANCEBLOCK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLADVANCEBLOCK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLADVANCEBLOCK(records);
Log(ret);
}
LeCDLADVANCEBLOCK()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLADVANCEBLOCK(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLBELTHOLD()fonction est utilisée pour calculer laRestez à l'arrêt de la ceinture (graphique en ligne K: Restez à l'arrêt de la ceinture).
La valeur de rendement de latalib.CDLBELTHOLD()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBELTHOLD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBELTHOLD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBELTHOLD(records);
Log(ret);
}
LeCDLBELTHOLD()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLBELTHOLD(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLBREAKAWAY()fonction est utilisée pour calculer laDétachement (graphique en ligne K: Détachement).
La valeur de rendement de latalib.CDLBREAKAWAY()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLBRAKAWAY (en anglais)
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBREAKAWAY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBREAKAWAY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBREAKAWAY(records);
Log(ret);
}
CDLBREAKAWAY()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLBREAKAWAY(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLCLOSINGMARUBOZU()fonction est utilisée pour calculerFermeture de Marubozu (graphique en ligne K: fermeture à tête nue et pieds nus).
La valeur de rendement de latalib.CDLCLOSINGMARUBOZU()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCLOSINGMARUBOZU(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCLOSINGMARUBOZU(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCLOSINGMARUBOZU(records);
Log(ret);
}
LeCDLCLOSINGMARUBOZU()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLCLOSINGMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLCONCEALBABYSWALL()fonction est utilisée pour calculer laDisguisez l'hirondelle de bébé (graphique en ligne K: Disguisez l'hirondelle de bébé).
La valeur de rendement de latalib.CDLCONCEALBABYSWALL()fonction est: un tableau unidimensionnel.
séquence
Je suis désolé, mais je ne peux pas.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCONCEALBABYSWALL(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCONCEALBABYSWALL(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCONCEALBABYSWALL(records);
Log(ret);
}
LeCDLCONCEALBABYSWALL()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLCONCEALBABYSWALL(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLCOUNTERATTACK()fonction est utilisée pour calculerContre-attaque (graphique de ligne K: Contre-attaque).
La valeur de rendement de latalib.CDLCOUNTERATTACK()la fonction est un tableau unidimensionnel.
séquence
Talib.CDL contre-attaque
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLCOUNTERATTACK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLCOUNTERATTACK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLCOUNTERATTACK(records);
Log(ret);
}
LeCDLCOUNTERATTACK()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLCOUNTERATTACK(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLDARKCLOUDCOVER()fonction est utilisée pour calculerCouverture nuageuse sombre (graphique en ligne K: couverture nuageuse sombre).
La valeur de rendement de latalib.CDLDARKCLOUDCOVER()la fonction est un tableau unidimensionnel.
séquence
Je ne sais pas si je peux vous aider. Je ne sais pas si vous avez des problèmes.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est utilisé pour définir la pénétration, la valeur par défaut est de 0,5.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDARKCLOUDCOVER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDARKCLOUDCOVER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDARKCLOUDCOVER(records);
Log(ret);
}
LeCDLDARKCLOUDCOVER()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLDARKCLOUDCOVER(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Letalib.CDLDOJI()fonction est utilisée pour calculerDoji (graphique en ligne K: Doji).
La valeur de rendement de latalib.CDLDOJI()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDOJI(records);
Log(ret);
}
LeCDLDOJI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLDOJISTAR()fonction est utilisée pour calculer laÉtoile de Doji (graphique en ligne K: Étoile de Doji).
La valeur de rendement de latalib.CDLDOJISTAR()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDOJISTAR(records);
Log(ret);
}
LeCDLDOJISTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLDOJISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLDRAGONFLYDOJI()fonction est utilisée pour calculerDragonfly Doji (Tableau de ligne K: Dragonfly Doji).
La valeur de rendement de latalib.CDLDRAGONFLYDOJI()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux vous aider.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLDRAGONFLYDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLDRAGONFLYDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLDRAGONFLYDOJI(records);
Log(ret);
}
LeCDLDRAGONFLYDOJI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLDRAGONFLYDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLENGULFING()fonction est utilisée pour calculer laModèle d' engorgement (graphique en K: engorgement).
La valeur de rendement de latalib.CDLENGULFING()la fonction est un tableau unidimensionnel.
séquence
Je suis désolé.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLENGULFING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLENGULFING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLENGULFING(records);
Log(ret);
}
LeCDLENGULFING()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLENGULFING(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLEVENINGDOJISTAR()fonction est utilisée pour calculer laÉtoile du Doji du Soir (graphique en ligne K: Étoile du Doji du Soir).
La valeur de rendement de latalib.CDLEVENINGDOJISTAR()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux vous aider. Je ne sais pas si je peux vous aider.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est utilisé pour définir la pénétration, la valeur par défaut est 0.3.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLEVENINGDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLEVENINGDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLEVENINGDOJISTAR(records);
Log(ret);
}
LeCDLEVENINGDOJISTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLEVENINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Letalib.CDLEVENINGSTAR()fonction est utilisée pour calculer laÉtoile du soir (graphique en ligne K: Étoile du soir).
La valeur de rendement de latalib.CDLEVENINGSTAR()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLEVENINGSTAR ((en PrixOHLC) est une série télévisée. Je ne sais pas si je peux vous aider.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est utilisé pour définir la pénétration, la valeur par défaut est 0.3.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLEVENINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLEVENINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLEVENINGSTAR(records);
Log(ret);
}
LeCDLEVENINGSTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLEVENINGSTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Letalib.CDLGAPSIDESIDEWHITE()fonction est utilisée pour calculerLignes blanches côte à côte à l'écart vers le haut/vers le bas (graphique en ligne K: lignes blanches côte à côte à l'écart vers le haut/vers le bas).
La valeur de rendement de latalib.CDLGAPSIDESIDEWHITE()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLGAPSIDESIDEWHITE ((enPriceOHLC) est une série télévisée américaine.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLGAPSIDESIDEWHITE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLGAPSIDESIDEWHITE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLGAPSIDESIDEWHITE(records);
Log(ret);
}
LeCDLGAPSIDESIDEWHITE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLGAPSIDESIDEWHITE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLGRAVESTONEDOJI()fonction est utilisée pour calculer laLe Doji de la pierre tombale (graphique en ligne K: Doji de la pierre tombale).
La valeur de rendement de latalib.CDLGRAVESTONEDOJI()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je fais.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLGRAVESTONEDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLGRAVESTONEDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLGRAVESTONEDOJI(records);
Log(ret);
}
LeCDLGRAVESTONEDOJI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLGRAVESTONEDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHAMMER()fonction est utilisée pour calculerMarteau (graphique en ligne K: Marteau).
La valeur de rendement de latalib.CDLHAMMER()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHAMMER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHAMMER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHAMMER(records);
Log(ret);
}
LeCDLHAMMER()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHANGINGMAN()fonction est utilisée pour calculerL'homme pendu (graphique en ligne K: L'homme pendu).
La valeur de rendement de latalib.CDLHANGINGMAN()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHANGINGMAN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHANGINGMAN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHANGINGMAN(records);
Log(ret);
}
LeCDLHANGINGMAN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHANGINGMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHARAMI()fonction est utilisée pour calculer laModèle de Harami (graphique en lignes K: lignes négatives et positives).
La valeur de rendement de latalib.CDLHARAMI()la fonction est un tableau unidimensionnel.
séquence
Talib.CDLHARAMI (en anglais)
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHARAMI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHARAMI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHARAMI(records);
Log(ret);
}
LeCDLHARAMI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHARAMI(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHARAMICROSS()fonction est utilisée pour calculer laModèle croisé Harami (graphique en K-ligne: lignes négatives et positives croisées).
La valeur de rendement de latalib.CDLHARAMICROSS()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHARAMICROSS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHARAMICROSS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHARAMICROSS(records);
Log(ret);
}
LeCDLHARAMICROSS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHARAMICROSS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHIGHWAVE()fonction est utilisée pour calculer laBougie à ondes élevées (graphique en ligne K: Long Leg Cross).
La valeur de rendement de latalib.CDLHIGHWAVE()la fonction est un tableau unidimensionnel.
séquence
Talib.CDLHIGHWAVE ((en PrixOHLC) est un groupe de musique américain.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIGHWAVE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIGHWAVE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIGHWAVE(records);
Log(ret);
}
LeCDLHIGHWAVE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHIGHWAVE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHIKKAKE()fonction est utilisée pour calculer laModèle Hikkake (graphique en ligne K: piège).
La valeur de rendement de latalib.CDLHIKKAKE()la fonction est un tableau unidimensionnel.
séquence
Talib.CDLHIKKAKE ((en PrixOHLC) est une série de films télévisés réalisés par la société américaine.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIKKAKE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIKKAKE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIKKAKE(records);
Log(ret);
}
LeCDLHIKKAKE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHIKKAKE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHIKKAKEMOD()fonction est utilisée pour calculer laModèle Hikkake modifié (graphique en ligne K: piège modifié).
La valeur de rendement de latalib.CDLHIKKAKEMOD()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHIKKAKEMOD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHIKKAKEMOD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHIKKAKEMOD(records);
Log(ret);
}
LeCDLHIKKAKEMOD()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHIKKAKEMOD(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLHOMINGPIGEON()fonction est utilisée pour calculer laPigeon volant (graphique en ligne K: Pigeon).
La valeur de rendement de latalib.CDLHOMINGPIGEON()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLHOMINGPIGEON(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLHOMINGPIGEON(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLHOMINGPIGEON(records);
Log(ret);
}
LeCDLHOMINGPIGEON()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLHOMINGPIGEON(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLIDENTICAL3CROWS()fonction est utilisée pour calculerTrois corbeaux identiques (graphique en ligne K: les mêmes trois corbeaux).
La valeur de rendement de latalib.CDLIDENTICAL3CROWS()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLIDENTICAL3CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLIDENTICAL3CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLIDENTICAL3CROWS(records);
Log(ret);
}
LeCDLIDENTICAL3CROWS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLIDENTICAL3CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLINNECK()fonction est utilisée pour calculer laModèle dans le cou (graphique en ligne K: décolleté).
La valeur de rendement de latalib.CDLINNECK()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLINNECK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLINNECK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLINNECK(records);
Log(ret);
}
LeCDLINNECK()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLINNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLINVERTEDHAMMER()fonction est utilisée pour calculer laMarteau renversé (graphique en ligne K: Marteau renversé).
La valeur de rendement de latalib.CDLINVERTEDHAMMER()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLINVERTEDHAMMER ((en PrixOHLC) est un groupe de musique américain.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLINVERTEDHAMMER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLINVERTEDHAMMER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLINVERTEDHAMMER(records);
Log(ret);
}
LeCDLINVERTEDHAMMER()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLINVERTEDHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLKICKING()fonction est utilisée pour calculerCoup de pied (graphique en ligne K: coup de pied).
La valeur de rendement de latalib.CDLKICKING()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLKICKING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLKICKING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLKICKING(records);
Log(ret);
}
LeCDLKICKING()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLKICKING(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLKICKINGBYLENGTH()fonction est utilisée pour calculer lacoups de pied - taureau/ours déterminé par le Marubozu plus long (graphique en ligne K: coups de pied taureau/ours coups de pied).
La valeur de rendement de latalib.CDLKICKINGBYLENGTH()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas faire ça. Je peux pas faire ça.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLKICKINGBYLENGTH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLKICKINGBYLENGTH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLKICKINGBYLENGTH(records);
Log(ret);
}
LeCDLKICKINGBYLENGTH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLKICKINGBYLENGTH(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLLADDERBOTTOM()fonction est utilisée pour calculer laBas de l'échelle (graphique en ligne K: Bas de l'échelle).
La valeur de rendement de latalib.CDLLADDERBOTTOM()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLADDERBOTTOM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLADDERBOTTOM(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLADDERBOTTOM(records);
Log(ret);
}
LeCDLLADDERBOTTOM()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLLADDERBOTTOM(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLLONGLEGGEDDOJI()fonction est utilisée pour calculer laDoji à pattes longues (graphique en ligne K: Doji à pattes longues).
La valeur de rendement de latalib.CDLLONGLEGGEDDOJI()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLONGLEGGEDDOJI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLONGLEGGEDDOJI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLONGLEGGEDDOJI(records);
Log(ret);
}
LeCDLLONGLEGGEDDOJI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLLONGLEGGEDDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLLONGLINE()fonction est utilisée pour calculer laLumière de ligne longue (graphique de ligne K: Ligne longue).
La valeur de rendement de latalib.CDLLONGLINE()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux vous aider.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLLONGLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLLONGLINE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLLONGLINE(records);
Log(ret);
}
LeCDLLONGLINE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLLONGLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLMARUBOZU()fonction est utilisée pour calculer laMarubozu (graphique en ligne K: tête nue et pied nu).
La valeur de rendement de latalib.CDLMARUBOZU()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMARUBOZU(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMARUBOZU(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMARUBOZU(records);
Log(ret);
}
LeCDLMARUBOZU()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLMATCHINGLOW()fonction est utilisée pour calculerFaible correspondance (graphique en ligne K: Faible correspondance).
La valeur de rendement de latalib.CDLMATCHINGLOW()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMATCHINGLOW(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMATCHINGLOW(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMATCHINGLOW(records);
Log(ret);
}
LeCDLMATCHINGLOW()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLMATCHINGLOW(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLMATHOLD()fonction est utilisée pour calculerMaintien du tapis (graphique en ligne K: Maintien du tapis).
La valeur de rendement de latalib.CDLMATHOLD()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas faire ça. Je suis désolée.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est facultatif et est utilisé pour spécifier le pourcentage de la largeur de la ligne de tendance haussière/baissante, la valeur par défaut est de 0,5.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMATHOLD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMATHOLD(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMATHOLD(records);
Log(ret);
}
LeCDLMATHOLD()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLMATHOLD(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Letalib.CDLMORNINGDOJISTAR()fonction est utilisée pour calculer laMorning Doji Star (Tableau en ligne K: Morning Doji Star) est une étoile du matin..
La valeur de rendement de latalib.CDLMORNINGDOJISTAR()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux vous aider. Je ne sais pas si tu veux que je te dise quelque chose.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est utilisé pour spécifier le degré de chevauchement entre le prix d'ouverture de validation et la partie solide, la valeur par défaut est de 0,3.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMORNINGDOJISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMORNINGDOJISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMORNINGDOJISTAR(records);
Log(ret);
}
LeCDLMORNINGDOJISTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLMORNINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Letalib.CDLMORNINGSTAR()fonction est utilisée pour calculerÉtoile du matin (graphique en ligne K: Étoile du matin).
La valeur de rendement de latalib.CDLMORNINGSTAR()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux vous aider. Je ne sais pas si je peux vous aider.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInPenetrationLe paramètre est le seuil de pourcentage de fluctuation des prix requis pour la confirmation de la tendance et prend une valeur dans la plage [0,1], avec une valeur par défaut de 0,3.
OptInPénétration
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLMORNINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLMORNINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLMORNINGSTAR(records);
Log(ret);
}
LeCDLMORNINGSTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLMORNINGSTAR(Records[Open,High,Low,Close],Penetration=0.3) = Array(outInteger)
Letalib.CDLONNECK()fonction est utilisée pour calculer laModèle sur le cou (graphique en ligne K: Modèle sur le cou).
La valeur de rendement de latalib.CDLONNECK()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLONNECK(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLONNECK(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLONNECK(records);
Log(ret);
}
LeCDLONNECK()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLONNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLPIERCING()fonction est utilisée pour calculer laModèle de perçage (graphique en ligne K: Modèle de perçage).
La valeur de rendement de latalib.CDLPIERCING()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLPIERCING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLPIERCING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLPIERCING(records);
Log(ret);
}
LeCDLPIERCING()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLPIERCING(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLRICKSHAWMAN()fonction est utilisée pour calculerL'homme à la rickshaw (graphique en ligne K: L'homme à la rickshaw).
La valeur de rendement de latalib.CDLRICKSHAWMAN()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas faire ça.
LeinPriceOHLCLe paramètre est utilisé pour spécifier les données de ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLRICKSHAWMAN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLRICKSHAWMAN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLRICKSHAWMAN(records);
Log(ret);
}
LeCDLRICKSHAWMAN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLRICKSHAWMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLRISEFALL3METHODS()fonction est utilisée pour calculerTrois méthodes de hausse/baisse (graphique en ligne K: Trois méthodes de hausse/baisse).
La valeur de rendement de latalib.CDLRISEFALL3METHODS()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLRISEFALL3METHODS ((en PrixOHLC) est une méthode utilisée par les autorités compétentes.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLRISEFALL3METHODS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLRISEFALL3METHODS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLRISEFALL3METHODS(records);
Log(ret);
}
LeCDLRISEFALL3METHODS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLRISEFALL3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLSEPARATINGLINES()fonction est utilisée pour calculerLes lignes de séparation (graphique de lignes K: lignes de séparation).
La valeur de rendement de latalib.CDLSEPARATINGLINES()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSEPARATINGLINES(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSEPARATINGLINES(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSEPARATINGLINES(records);
Log(ret);
}
LeCDLSEPARATINGLINES()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLSEPARATINGLINES(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLSHOOTINGSTAR()fonction est utilisée pour calculer laÉtoile filante (graphique en K: Étoile filante).
La valeur de rendement de latalib.CDLSHOOTINGSTAR()la fonction est un tableau unidimensionnel.
séquence
Talib.CDLShootingSTAR (en anglais)
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSHOOTINGSTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSHOOTINGSTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSHOOTINGSTAR(records);
Log(ret);
}
LeCDLSHOOTINGSTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLSHOOTINGSTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLSHORTLINE()fonction est utilisée pour calculer laLumière de ligne courte (graphique de ligne K: Ligne courte).
La valeur de rendement de latalib.CDLSHORTLINE()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLSShortLine ((en PrixOHLC) est une chaîne de télévision américaine.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSHORTLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSHORTLINE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSHORTLINE(records);
Log(ret);
}
LeCDLSHORTLINE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLSHORTLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLSPINNINGTOP()fonction est utilisée pour calculerSpinning Top (graphique en ligne K: Spinning Top).
La valeur de rendement de latalib.CDLSPINNINGTOP()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSPINNINGTOP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSPINNINGTOP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSPINNINGTOP(records);
Log(ret);
}
LeCDLSPINNINGTOP()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLSPINNINGTOP(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLSTALLEDPATTERN()fonction est utilisée pour calculerModèle bloqué (graphique en ligne K: Modèle bloqué).
La valeur de rendement de latalib.CDLSTALLEDPATTERN()fonction est: un tableau unidimensionnel.
séquence
Il y a un autre problème.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSTALLEDPATTERN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSTALLEDPATTERN(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSTALLEDPATTERN(records);
Log(ret);
}
LeCDLSTALLEDPATTERN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLSTALLEDPATTERN(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLSTICKSANDWICH()fonction est utilisée pour calculer laSandwich à la broche (graphique en K: Sandwich à la broche).
La valeur de rendement de latalib.CDLSTICKSANDWICH()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLSTICKSANDWICH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLSTICKSANDWICH(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLSTICKSANDWICH(records);
Log(ret);
}
LeCDLSTICKSANDWICH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLSTICKSANDWICH(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLTAKURI()fonction est utilisée pour calculerTakuri (doji de la mouche-dragon avec une très longue ligne d'ombre inférieure) (graphique de ligne K: Takuri).
La valeur de rendement de latalib.CDLTAKURI()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTAKURI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTAKURI(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTAKURI(records);
Log(ret);
}
LeCDLTAKURI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLTAKURI(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLTASUKIGAP()fonction est utilisée pour calculer laTasuki Gap (graphique en ligne K: Tasuki Gap).
La valeur de rendement de latalib.CDLTASUKIGAP()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTASUKIGAP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTASUKIGAP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTASUKIGAP(records);
Log(ret);
}
LeCDLTASUKIGAP()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLTASUKIGAP(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLTHRUSTING()fonction est utilisée pour calculer laModèle de poussée (graphique en K: Modèle de poussée).
La valeur de rendement de latalib.CDLTHRUSTING()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTHRUSTING(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTHRUSTING(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTHRUSTING(records);
Log(ret);
}
LeCDLTHRUSTING()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLTHRUSTING(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLTRISTAR()fonction est utilisée pour calculer laModèle Tristar (graphique en ligne K: Modèle Tristar).
La valeur de rendement de latalib.CDLTRISTAR()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLTRISTAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLTRISTAR(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLTRISTAR(records);
Log(ret);
}
LeCDLTRISTAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLTRISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLUNIQUE3RIVER()fonction est utilisée pour calculer laRivière Unique 3 (graphique en ligne K: Rivière Unique 3).
La valeur de rendement de latalib.CDLUNIQUE3RIVER()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLUNIQUE3RIVER(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLUNIQUE3RIVER(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLUNIQUE3RIVER(records);
Log(ret);
}
LeCDLUNIQUE3RIVER()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLUNIQUE3RIVER(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLUPSIDEGAP2CROWS()fonction est utilisée pour calculerL'écart à la hausse deux corbeaux (graphique en ligne K: écart à la hausse deux corbeaux).
La valeur de rendement de latalib.CDLUPSIDEGAP2CROWS()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLUPSIDEGAP2CROWS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLUPSIDEGAP2CROWS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLUPSIDEGAP2CROWS(records);
Log(ret);
}
LeCDLUPSIDEGAP2CROWS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLUPSIDEGAP2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.CDLXSIDEGAP3METHODS()fonction est utilisée pour calculerTrois méthodes pour l'écart à la hausse et à la baisse (graphique en K: Trois méthodes pour l'écart à la hausse et à la baisse).
La valeur de rendement de latalib.CDLXSIDEGAP3METHODS()fonction est: un tableau unidimensionnel.
séquence
Talib.CDLXSIDEGAP3METHODS ((en PrixOHLC) est une méthode utilisée par les autorités compétentes pour déterminer le prix de l'offre.
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLXSIDEGAP3METHODS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLXSIDEGAP3METHODS(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLXSIDEGAP3METHODS(records);
Log(ret);
}
LeCDLXSIDEGAP3METHODS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CDLXSIDEGAP3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Letalib.AD()fonction est utilisée pour calculer laChaikin A/D Line (indicateur stochastique de ligne).
La valeur de rendement de latalib.AD()fonction est: un tableau unidimensionnel.
séquence
talib.AD(en prix HLCV)
LeinPriceHLCVle paramètre est utilisé pour spécifier les données de la ligne K.
Le montant de l'aide est calculé en fonction de l'évolution de la situation.
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.AD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AD(records.High, records.Low, records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AD(records);
Log(ret);
}
LeAD()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:AD(Records[High,Low,Close,Volume]) = Array(outReal)
Letalib.ADOSC()fonction est utilisée pour calculer laL'indicateur de la fréquence d'écoulement de l'aéronef est utilisé pour déterminer la fréquence de l'aéronef..
La valeur de rendement de latalib.ADOSC()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.ADOSC ((inPriceHLCV, optInFastPeriod, optInSlowPeriod) est une série de jeux vidéo télévisés réalisés par les entreprises américaines.
LeinPriceHLCVle paramètre est utilisé pour spécifier les données de la ligne K.
Le montant de l'aide est calculé en fonction de l'évolution de la situation.
vrai
{@struct/Record Record} tableau de structure
LeoptInFastPeriodparamètre est utilisé pour définir la période rapide.
OptionInFastPeriod
faux
Numéro
LeoptInSlowPeriodLe paramètre est utilisé pour définir la période lente.
OptionInSlowPeriod
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ADOSC(records, 3, 10)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADOSC(records.High, records.Low, records.Close, records.Volume, 3, 10)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADOSC(records, 3, 10);
Log(ret);
}
LeADOSC()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ADOSC(Records[High,Low,Close,Volume],Fast Period = 3,Slow Period = 10) = Array(outReal)
Letalib.OBV()fonction est utilisée pour calculerSur le volume du bilan (marée d'énergie).
La valeur de rendement de latalib.OBV()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.OBV ((en Réel, en PrixV)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeinPriceVle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix
faux
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.OBV(records, records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.OBV(records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.OBV(records);
Log(ret);
}
LeOBV()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:OBV(Records[Close],Records[Volume]) = Array(outReal)
Letalib.ACOS()fonction est utilisée pour calculerVecteur trigonométrique ACos (fonction inverse du cosinus).
La valeur de rendement de latalib.ACOS()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-1, 0, 1]
var ret = talib.ACOS(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.ACOS(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.ACOS(data);
Log(ret);
}
LeACOS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ACOS(Records[Close]) = Array(outReal)
Letalib.ASIN()fonction est utilisée pour calculer laASin vectoriel trigonométrique (fonction sinusoïdale inverse).
La valeur de rendement de latalib.ASIN()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-1, 0, 1]
var ret = talib.ASIN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.ASIN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.ASIN(data);
Log(ret);
}
LeASIN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ASIN(Records[Close]) = Array(outReal)
Letalib.ATAN()fonction est utilisée pour calculer laTrigonométrie vectorielle ATan (fonction de tangente inverse).
La valeur de rendement de latalib.ATAN()fonction est: un tableau unidimensionnel.
séquence
Talib.ATAN ((inReal) est un groupe de rock américain.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-3.14/2, 0, 3.14/2]
var ret = talib.ATAN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14/2, 0, 3.14/2]
ret = talib.ATAN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14/2, 0, 3.14/2};
auto ret = talib.ATAN(data);
Log(ret);
}
LeATAN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ATAN(Records[Close]) = Array(outReal)
Letalib.CEIL()fonction est utilisée pour calculerPlafond vectoriel (fonction d'arrondissement).
La valeur de rendement de latalib.CEIL()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas faire ça.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.CEIL(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CEIL(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CEIL(records);
Log(ret);
}
LeCEIL()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CEIL(Records[Close]) = Array(outReal)
Letalib.COS()fonction est utilisée pour calculer laLe vecteur trigonométrique Cos (fonction cosinus).
La valeur de rendement de latalib.COS()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous aider.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-3.14, 0, 3.14]
var ret = talib.COS(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14, 0, 3.14]
ret = talib.COS(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14, 0, 3.14};
auto ret = talib.COS(data);
Log(ret);
}
LeCOS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:COS(Records[Close]) = Array(outReal)
Letalib.COSH()fonction est utilisée pour calculerVecteur trigonométrique Cosh (valeur cosinus hyperbolique).
La valeur de rendement de latalib.COSH()la fonction est un tableau unidimensionnel.
séquence
Talib.COSH ((inReal) est une chaîne de télévision.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-1, 0, 1]
var ret = talib.COSH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.COSH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.COSH(data);
Log(ret);
}
LeCOSH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:COSH(Records[Close]) = Array(outReal)
Letalib.EXP()fonction est utilisée pour calculer laExp (fonction exponentielle) en arithmétique de vecteur.
La valeur de rendement de latalib.EXP()fonction est: un tableau unidimensionnel.
séquence
Talib.EXP ((inReal) est une série télévisée.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [0, 1, 2]
var ret = talib.EXP(data) // e^0, e^1, e^2
Log(ret)
}
import talib
import numpy as np
def main():
data = [0, 1.0, 2.0]
ret = talib.EXP(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {0, 1.0, 2.0};
auto ret = talib.EXP(data);
Log(ret);
}
LeEXP()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:EXP(Records[Close]) = Array(outReal)
Letalib.FLOOR()fonction est utilisée pour calculer laPlafond vectoriel (arrondis à la baisse).
La valeur de rendement de latalib.FLOOR()la fonction est un tableau unidimensionnel.
séquence
Talib.FLOOR (en vrai)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.FLOOR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.FLOOR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.FLOOR(records);
Log(ret);
}
LeFLOOR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:FLOOR(Records[Close]) = Array(outReal)
Letalib.LN()fonction est utilisée pour calculer laLe vecteur log naturel (logarithme naturel).
La valeur de rendement de latalib.LN()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [1, 2, 3]
var ret = talib.LN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [1.0, 2.0, 3.0]
ret = talib.LN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {1, 2, 3};
auto ret = talib.LN(data);
Log(ret);
}
LeLN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:LN(Records[Close]) = Array(outReal)
Letalib.LOG10()fonction est utilisée pour calculerVecteur Log10 (fonction logarithmique).
La valeur de rendement de latalib.LOG10()la fonction est un tableau unidimensionnel.
séquence
Talib.LOG10 (en réalité)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [10, 100, 1000]
var ret = talib.LOG10(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [10.0, 100.0, 1000.0]
ret = talib.LOG10(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {10, 100, 1000};
auto ret = talib.LOG10(data);
Log(ret);
}
LeLOG10()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:LOG10(Records[Close]) = Array(outReal)
Letalib.SIN()fonction est utilisée pour calculerVecteur trigonométrique Sin (valeur sinus).
La valeur de rendement de latalib.SIN()la fonction est un tableau unidimensionnel.
séquence
Talib.SIN ((inReal) est un groupe de rock américain.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-3.14/2, 0, 3.14/2]
var ret = talib.SIN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-3.14/2, 0, 3.14/2]
ret = talib.SIN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-3.14/2, 0, 3.14/2};
auto ret = talib.SIN(data);
Log(ret);
}
LeSIN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SIN(Records[Close]) = Array(outReal)
Letalib.SINH()fonction est utilisée pour calculer laVecteur Trigonométrique (fonction sinusoïdale hyperbolique).
La valeur de rendement de latalib.SINH()fonction est: un tableau unidimensionnel.
séquence
Talib.SINH ((inReal) est une chaîne de télévision.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-1, 0, 1]
var ret = talib.SINH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.SINH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.SINH(data);
Log(ret);
}
LeSINH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SINH(Records[Close]) = Array(outReal)
Letalib.SQRT()fonction est utilisée pour calculer laLa racine carrée du vecteur.
La valeur de rendement de latalib.SQRT()fonction est: un tableau unidimensionnel.
séquence
Talib.SQRT (en réalité)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [4, 64, 100]
var ret = talib.SQRT(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [4.0, 64.0, 100.0]
ret = talib.SQRT(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {4, 64, 100};
auto ret = talib.SQRT(data);
Log(ret);
}
LeSQRT()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SQRT(Records[Close]) = Array(outReal)
Letalib.TAN()fonction est utilisée pour calculer laVecteur Trigonométrique Tan (tangente).
La valeur de rendement de latalib.TAN()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-1, 0, 1]
var ret = talib.TAN(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.TAN(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.TAN(data);
Log(ret);
}
LeTAN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TAN(Records[Close]) = Array(outReal)
Letalib.TANH()fonction est utilisée pour calculer laVecteur trigonométrique Tanh (fonction de tangente hyperbolique).
La valeur de rendement de latalib.TANH()fonction est: un tableau unidimensionnel.
séquence
Talib.TANH ((inReal) est une chaîne de télévision.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var data = [-1, 0, 1]
var ret = talib.TANH(data)
Log(ret)
}
import talib
import numpy as np
def main():
data = [-1.0, 0, 1.0]
ret = talib.TANH(np.array(data))
Log(ret)
void main() {
std::vector<double> data = {-1, 0, 1};
auto ret = talib.TANH(data);
Log(ret);
}
LeTANH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TANH(Records[Close]) = Array(outReal)
Letalib.MAX()La fonction est utilisée pour calculer la valeur la plus élevée (maximale) pour unpériode spécifique.
La valeur de rendement de latalib.MAX()fonction est: un tableau unidimensionnel.
séquence
Talib.MAX (en réalité) Talib.MAX (en temps réel, en temps partiel)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MAX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAX(records);
Log(ret);
}
LeMAX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MAX(Records[Close],Time Period = 30) = Array(outReal)
Letalib.MAXINDEX()fonction est utilisée pour calculerl'indice de la valeur la plus élevée au cours de la période spécifiée (indice maximal).
La valeur de rendement de latalib.MAXINDEX()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux. Talib.MAXINDEX ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MAXINDEX(records, 5)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAXINDEX(records.Close, 5)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAXINDEX(records, 5);
Log(ret);
}
LeMAXINDEX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MAXINDEX(Records[Close],Time Period = 30) = Array(outInteger)
Letalib.MIN()La fonction est utilisée pour calculer la valeur la plus basse (valeur minimale)** pour la période spécifiée.
La valeur de rendement de latalib.MIN()fonction est: un tableau unidimensionnel.
séquence
Talib.MIN ((inReal) talib.MIN ((en réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MIN(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIN(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIN(records);
Log(ret);
}
LeMIN()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MIN(Records[Close],Time Period = 30) = Array(outReal)
Letalib.MININDEX()fonction est utilisée pour calculerl'indice de valeur le plus bas (indice de valeur minimale)pour la période spécifiée.
La valeur de rendement de latalib.MININDEX()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée. talib.MININDEX ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MININDEX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MININDEX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MININDEX(records);
Log(ret);
}
LeMININDEX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MININDEX(Records[Close],Time Period = 30) = Array(outInteger)
Letalib.MINMAX()fonction est utilisée pour calculerles valeurs minimales et maximales pour la période spécifiée.
La valeur de rendement de latalib.MINMAX()la fonction est un tableau bidimensionnel. le premier élément de ce tableau bidimensionnel est le tableau des valeurs minimales, et le deuxième élément est le tableau des valeurs maximales.
séquence
Talib.MINMAX (en réalité) Talib.MINMAX ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MINMAX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINMAX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINMAX(records);
Log(ret);
}
LeMINMAX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MINMAX(Records[Close],Time Period = 30) = [Array(outMin),Array(outMax)]
Letalib.MINMAXINDEX()fonction est utilisée pour calculerl'indice des valeurs inférieure et supérieure (indice minimum et indice maximum) au cours de la période spécifiée.
La valeur de rendement de latalib.MINMAXINDEX()la fonction est: un tableau bidimensionnel. Le premier élément de ce tableau bidimensionnel est le tableau indexé minimum, et le deuxième élément est le tableau indexé maximum.
séquence
Talib.MINMAXINDEX (en réalité) Talib.MINMAXINDEX ((en réel, en temps réel)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MINMAXINDEX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINMAXINDEX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINMAXINDEX(records);
Log(ret);
}
LeMINMAXINDEX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MINMAXINDEX(Records[Close],Time Period = 30) = [Array(outMinIdx),Array(outMaxIdx)]
Letalib.SUM()fonction est utilisée pour calculerRésumé.
La valeur de rendement de latalib.SUM()fonction est: un tableau unidimensionnel.
séquence
Talib.SUM ((en Réel) talib.SUM ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.SUM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SUM(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SUM(records);
Log(ret);
}
LeSUM()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SUM(Records[Close],Time Period = 30) = Array(outReal)
Letalib.HT_DCPERIOD()fonction est utilisée pour calculer laLa transformation de Hilbert - période dominante du cycle.
La valeur de rendement de latalib.HT_DCPERIOD()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_DCPERIOD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_DCPERIOD(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_DCPERIOD(records);
Log(ret);
}
LeHT_DCPERIOD()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:HT_DCPERIOD(Records[Close]) = Array(outReal)
Letalib.HT_DCPHASE()fonction est utilisée pour calculer laLa transformation de Hilbert - phase dominante du cycle.
La valeur de rendement de latalib.HT_DCPHASE()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_DCPHASE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_DCPHASE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_DCPHASE(records);
Log(ret);
}
LeHT_DCPHASE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:HT_DCPHASE(Records[Close]) = Array(outReal)
Letalib.HT_PHASOR()fonction est utilisée pour calculer laTransformation de Hilbert - composants phasoriques (transformation de Hilbert, composants de phase).
La valeur de rendement de latalib.HT_PHASOR()la fonction est un tableau bidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_PHASOR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_PHASOR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_PHASOR(records);
Log(ret);
}
LeHT_PHASOR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:HT_PHASOR(Records[Close]) = [Array(outInPhase),Array(outQuadrature)]
Letalib.HT_SINE()fonction est utilisée pour calculer laTransformation de Hilbert - onde sinusoïdale.
La valeur de rendement de latalib.HT_SINE()la fonction est: un tableau bidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_SINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_SINE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_SINE(records);
Log(ret);
}
LeHT_SINE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:HT_SINE(Records[Close]) = [Array(outSine),Array(outLeadSine)]
Letalib.HT_TRENDMODE()fonction est utilisée pour calculer laTransformation de Hilbert - Mode tendance et cycle.
La valeur de rendement de latalib.HT_TRENDMODE()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je fais.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_TRENDMODE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_TRENDMODE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_TRENDMODE(records);
Log(ret);
}
LeHT_TRENDMODE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:HT_TRENDMODE(Records[Close]) = Array(outInteger)
Letalib.ATR()fonction est utilisée pour calculer laPlage réelle moyenne.
La valeur de rendement de latalib.ATR()la fonction est un tableau unidimensionnel.
séquence
Talib.ATR ((enPriceHLC) est une marque américaine. Talib.ATR ((inPriceHLC, optInTimePeriod) est une série de téléchargements télévisés.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ATR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ATR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ATR(records);
Log(ret);
}
LeATR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.NATR()fonction est utilisée pour calculer laPlage réelle moyenne normalisée.
La valeur de rendement de latalib.NATR()la fonction est un tableau unidimensionnel.
séquence
Talib.NATR ((en PrixHLC) Talib.NATR ((en PrixHLC, optInTimePeriod) est une série de tests de dépistage de l'infection.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.NATR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.NATR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.NATR(records);
Log(ret);
}
LeNATR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:NATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.TRANGE()fonction est utilisée pour calculer laDimension réelle.
La valeur de rendement de latalib.TRANGE()fonction est: un tableau unidimensionnel.
séquence
Talib.TRANGE ((en PrixHLC) est un jeu vidéo.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.TRANGE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRANGE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRANGE(records);
Log(ret);
}
LeTRANGE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TRANGE(Records[High,Low,Close]) = Array(outReal)
Letalib.BBANDS()fonction est utilisée pour calculerLes bandes de Bollinger.
La valeur de rendement de latalib.BBANDS()Le tableau contient trois éléments qui sont: le tableau de ligne supérieure, le tableau de ligne moyenne et le tableau de ligne inférieure.
séquence
Je ne peux pas vous aider. Talib.BBANDS (en temps réel, en période de temps) Talib.BBANDS ((en réel, optInTimePeriod, optInNbDevUp) Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn) Il est possible de modifier le nom de l'équipe. talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType) est un type de bande de données qui est utilisé par les utilisateurs.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 5.
Option dans le tempsPériode
faux
Numéro
LeoptInNbDevUpLe paramètre est utilisé pour définir le multiplicateur en amont, la valeur par défaut est 2.
OptionNbDevUp
faux
Numéro
LeoptInNbDevDnparamètre est utilisé pour définir le multiplicateur de la ligne inférieure, la valeur par défaut est 2.
OptionNbDevDn
faux
Numéro
LeoptInMATypeLe paramètre est utilisé pour définir le type moyen, la valeur par défaut est 0.
OptiMAType
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.BBANDS(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.BBANDS(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.BBANDS(records);
Log(ret);
}
LeBBANDS()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:BBANDS(Records[Close],Time Period = 5,Deviations up = 2,Deviations down = 2,MA Type = 0) = [Array(outRealUpperBand),Array(outRealMiddleBand),Array(outRealLowerBand)]
Letalib.DEMA()fonction est utilisée pour calculer laMoyenne mobile exponentielle double.
La valeur de rendement de latalib.DEMA()la fonction est un tableau unidimensionnel.
séquence
Talib.DEMA (en) réel Talib.DEMA ((en réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.DEMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.DEMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.DEMA(records);
Log(ret);
}
LeDEMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:DEMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.EMA()fonction est utilisée pour calculer laMoyenne mobile exponentielle.
La valeur de rendement de latalib.EMA()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.EMA ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.EMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.EMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.EMA(records);
Log(ret);
}
LeEMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:EMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.HT_TRENDLINE()fonction est utilisée pour calculer laLa transformation de Hilbert - ligne de tendance instantanée (transformation de Hilbert, tendance instantanée).
La valeur de rendement de latalib.HT_TRENDLINE()fonction est: un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
function main() {
var records = exchange.GetRecords()
var ret = talib.HT_TRENDLINE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.HT_TRENDLINE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.HT_TRENDLINE(records);
Log(ret);
}
LeHT_TRENDLINE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:HT_TRENDLINE(Records[Close]) = Array(outReal)
Letalib.KAMA()fonction est utilisée pour calculer laMoyenne mobile adaptative de Kaufman.
La valeur de rendement de latalib.KAMA()fonction est: un tableau unidimensionnel.
séquence
Talib.KAMA ((inReal) est une chaîne de télévision Talib.KAMA ((en réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.KAMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.KAMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.KAMA(records);
Log(ret);
}
LeKAMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:KAMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.MA()fonction est utilisée pour calculer laMoyenne mobile.
La valeur de rendement de latalib.MA()fonction est: un tableau unidimensionnel.
séquence
talib.MAJe ne suis pas réel.talib.MA(inReal, optInTimePeriod) Le nombre de fois où les données sont utilisées est le nombre de fois où les données sont utilisées.talib.MA(inReal, optInTimePeriod, optInMAType) Le type d'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission de l'émission
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
LeoptInMATypeLe paramètre est utilisé pour définir le type moyen, la valeur par défaut est 0.
OptiMAType
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MA(records);
Log(ret);
}
LeMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MA(Records[Close],Time Period = 30,MA Type = 0) = Array(outReal)
Letalib.MAMA()fonction est utilisée pour calculer laMoyenne mobile adaptative MESA.
La valeur de rendement de latalib.MAMA()la fonction est: un tableau bidimensionnel.
séquence
Talib.MAMA (en vrai) Talib.MAMA ((InReal, optInFastLimit) est une série de jeux vidéo. Talib.MAMA ((inReal, optInFastLimit, optInSlowLimit) est une série de jeux vidéo.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInFastLimitparamètre est utilisé pour définir la limite rapide, la valeur par défaut est de 0,5.
OpteInFastLimit est en cours de développement.
faux
Numéro
LeoptInSlowLimitparamètre est utilisé pour définir la limite lente, la valeur par défaut est de 0,05.
Option InSlowLimit
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MAMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MAMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MAMA(records);
Log(ret);
}
LeMAMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MAMA(Records[Close],Fast Limit = 0.5,Slow Limit = 0.05) = [Array(outMAMA),Array(outFAMA)]
Letalib.MIDPOINT()fonction est utilisée pour calculer laPériode moyenne (Période moyenne).
La valeur de rendement de latalib.MIDPOINT()la fonction est un tableau unidimensionnel.
séquence
Talib.MIDPOINT (en réalité) Talib.MIDPOINT ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MIDPOINT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIDPOINT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIDPOINT(records);
Log(ret);
}
LeMIDPOINT()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MIDPOINT(Records[Close],Time Period = 14) = Array(outReal)
Letalib.MIDPRICE()fonction est utilisée pour calculer laPrix moyen au cours de la période (prix moyen).
La valeur de rendement de latalib.MIDPRICE()la fonction est un tableau unidimensionnel.
séquence
talib.MIDPRICE ((enPriceHL) est le nom donné à la marque talib.MIDPRICE ((enPriceHL, optInTimePeriod) est le prix moyen du produit.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MIDPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MIDPRICE(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MIDPRICE(records);
Log(ret);
}
LeMIDPRICE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MIDPRICE(Records[High,Low],Time Period = 14) = Array(outReal)
Letalib.SAR()fonction est utilisée pour calculer laSAR parabolique.
La valeur de rendement de latalib.SAR()fonction est: un tableau unidimensionnel.
séquence
Talib.SAR (en anglais) Talib.SAR ((en PrixHL, optInAccélération) Talib.SAR ((inPriceHL, optInAcceleration, optInMaximum) est une marque américaine.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInAccelerationLe paramètre est utilisé pour régler le facteur d'accélération, la valeur par défaut est de 0,02.
Option Accélération
faux
Numéro
LeoptInMaximumparamètre est utilisé pour régler le maximum AF, la valeur par défaut est de 0,2.
Option maximale
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.SAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SAR(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SAR(records);
Log(ret);
}
LeSAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SAR(Records[High,Low],Acceleration Factor = 0.02,AF Maximum = 0.2) = Array(outReal)
Letalib.SAREXT()fonction est utilisée pour calculer laSAR parabolique - prolongé (régulation parabolique améliorée).
La valeur de rendement de latalib.SAREXT()la fonction est un tableau unidimensionnel.
séquence
Talib.SAREXT (en anglais) Talib.SAREXT ((inPriceHL, optInStartValue) est un système de paiement par carte de crédit. Talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse) est le nom de l'appareil utilisé pour le calcul du prix. talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong) Il est également possible d'utiliser les données de base de l'appareil dans le cadre de la procédure de détection des risques. talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong) Il est également possible de modifier la valeur de l'échantillon en utilisant les paramètres suivants: talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong) Il est également possible de modifier la valeur de l'échantillon en utilisant les paramètres suivants: talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort) Il est également possible de modifier la valeur de l'échantillon en utilisant les paramètres suivants: talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort) Il est également possible de modifier la valeur de l'échantillon en fonction de la taille de l'échantillon. talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort, optInAccelerationMaxShort) Il est également possible d'utiliser les paramètres suivants:
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInStartValueparamètre est utilisé pour définir la valeur de démarrage, la valeur par défaut est 0.
Option InStartValue est utilisée
faux
Numéro
LeoptInOffsetOnReverseLe paramètre est utilisé pour définir Offset sur Reverse, la valeur par défaut est 0.
Option InOffsetOnReverse est activée.
faux
Numéro
LeoptInAccelerationInitLongparamètre est utilisé pour régler l'AF Init Long, la valeur par défaut est de 0,02.
Opter dans l'accélération dans le long
faux
Numéro
LeoptInAccelerationLongLe paramètre est utilisé pour régler l'AF Long, la valeur par défaut est 0.02.
Option AccélérationLong
faux
Numéro
LeoptInAccelerationMaxLongLe paramètre est utilisé pour régler le AF Max Long, la valeur par défaut est de 0,2.
OptionInAccélérationMaxLong
faux
Numéro
LeoptInAccelerationInitShortparamètre est utilisé pour définir AF Init Short, la valeur par défaut est 0.02.
Opter dans l'accélération dans le court
faux
Numéro
LeoptInAccelerationShortparamètre est utilisé pour définir AF Short, la valeur par défaut est 0.02.
Option Accélération courte
faux
Numéro
LeoptInAccelerationMaxShortparamètre est utilisé pour définir AF Max Short, la valeur par défaut est de 0,2.
Option Accélération maxime courte
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.SAREXT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SAREXT(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SAREXT(records);
Log(ret);
}
LeSAREXT()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SAREXT(Records[High,Low],Start Value = 0,Offset on Reverse = 0,AF Init Long = 0.02,AF Long = 0.02,AF Max Long = 0.2,AF Init Short = 0.02,AF Short = 0.02,AF Max Short = 0.2) = Array(outReal)
Letalib.SMA()fonction est utilisée pour calculerMoyenne mobile simple.
La valeur de rendement de latalib.SMA()fonction est: un tableau unidimensionnel.
séquence
Talib.SMA ((inReal) est un groupe de rock américain. Talib.SMA ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.SMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.SMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.SMA(records);
Log(ret);
}
LeSMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:SMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.T3()fonction est utilisée pour calculer laLa moyenne mobile exponentielle triple (T3) (moyenne mobile exponentielle triple).
La valeur de rendement de latalib.T3()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux. Talib.T3 ((en réel, optInTimePeriod) Talib.T3 ((inReal, optInTimePeriod, optInVFactor) est le nombre de fois où le facteur de temps est utilisé.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 5.
Option dans le tempsPériode
faux
Numéro
LeoptInVFactorle paramètre est utilisé pour régler le facteur de volume, la valeur par défaut est de 0,7.
Facteur optInV
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.T3(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.T3(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.T3(records);
Log(ret);
}
LeT3()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:T3(Records[Close],Time Period = 5,Volume Factor = 0.7) = Array(outReal)
Letalib.TEMA()fonction est utilisée pour calculerMoyenne mobile exponentielle triple.
La valeur de rendement de latalib.TEMA()la fonction est un tableau unidimensionnel.
séquence
Talib.TEMA (en réel) Talib.TEMA ((en réel, en temps réel)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.TEMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TEMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TEMA(records);
Log(ret);
}
LeTEMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TEMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.TRIMA()fonction est utilisée pour calculer laMoyenne mobile triangulaire (moyenne mobile tri-exponentielle).
La valeur de rendement de latalib.TRIMA()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous aider. Talib.TRIMA (en temps réel, en temps réel)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.TRIMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRIMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRIMA(records);
Log(ret);
}
LeTRIMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TRIMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.WMA()fonction est utilisée pour calculer laMoyenne mobile pondérée (WMA).
La valeur de rendement de latalib.WMA()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.WMA ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.WMA(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WMA(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WMA(records);
Log(ret);
}
LeWMA()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:WMA(Records[Close],Time Period = 30) = Array(outReal)
Letalib.LINEARREG()fonction est utilisée pour calculerRégression linéaire.
La valeur de rendement de latalib.LINEARREG()la fonction est un tableau unidimensionnel.
séquence
Je ne sais pas si je peux le faire. talib.LINEARREG ((en réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG(records);
Log(ret);
}
LeLINEARREG()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:LINEARREG(Records[Close],Time Period = 14) = Array(outReal)
Letalib.LINEARREG_ANGLE()fonction est utilisée pour calculer laAngle de régression linéaire.
La valeur de rendement de latalib.LINEARREG_ANGLE()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux le faire. Talib.LINEARREG_ANGLE (en temps réel ou en temps réel)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_ANGLE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_ANGLE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_ANGLE(records);
Log(ret);
}
LeLINEARREG_ANGLE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:LINEARREG_ANGLE(Records[Close],Time Period = 14) = Array(outReal)
Letalib.LINEARREG_INTERCEPT()fonction est utilisée pour calculer laInterception de régression linéaire.
La valeur de rendement de latalib.LINEARREG_INTERCEPT()fonction est: un tableau unidimensionnel.
séquence
Je suis désolé, mais je n'ai pas le temps. Il y a une différence de temps entre les deux.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_INTERCEPT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_INTERCEPT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_INTERCEPT(records);
Log(ret);
}
LeLINEARREG_INTERCEPT()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:LINEARREG_INTERCEPT(Records[Close],Time Period = 14) = Array(outReal)
Letalib.LINEARREG_SLOPE()fonction est utilisée pour calculer laPente de régression linéaire.
La valeur de rendement de latalib.LINEARREG_SLOPE()fonction est: un tableau unidimensionnel.
séquence
Je ne sais pas si je peux le faire. Talib.LINEARREG_SLOPE ((en temps réel, optez en temps réel)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.LINEARREG_SLOPE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.LINEARREG_SLOPE(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.LINEARREG_SLOPE(records);
Log(ret);
}
LeLINEARREG_SLOPE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:LINEARREG_SLOPE(Records[Close],Time Period = 14) = Array(outReal)
Letalib.STDDEV()fonction est utilisée pour calculerDéviation type.
La valeur de rendement de latalib.STDDEV()fonction est: un tableau unidimensionnel.
séquence
Talib.STDDEV (en vrai) Talib.STDDEV ((en temps réel, optInTimePeriod) Je ne sais pas si je peux vous aider.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 5.
Option dans le tempsPériode
faux
Numéro
LeoptInNbDevLe paramètre est utilisé pour définir les écarts, la valeur par défaut est 1.
OptionNbV
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.STDDEV(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STDDEV(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STDDEV(records);
Log(ret);
}
LeSTDDEV()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:STDDEV(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Letalib.TSF()fonction est utilisée pour calculerPrévisions de séries chronologiques.
La valeur de rendement de latalib.TSF()la fonction est un tableau unidimensionnel.
séquence
Talib.TSF ((inReal) est une chaîne de télévision. Talib.TSF ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.TSF(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TSF(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TSF(records);
Log(ret);
}
LeTSF()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TSF(Records[Close],Time Period = 14) = Array(outReal)
Letalib.VAR()fonction est utilisée pour calculerVariance.
La valeur de rendement de latalib.VAR()fonction est: un tableau unidimensionnel.
séquence
Talib.VAR ((inReal) est un groupe de rock américain. Talib.VAR ((en temps réel, optInTimePeriod) Talib.VAR ((en réel, optInTimePeriod, optInNbDev)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 5.
Option dans le tempsPériode
faux
Numéro
LeoptInNbDevLe paramètre est utilisé pour définir les écarts, la valeur par défaut est 1.
OptionNbV
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.VAR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.VAR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.VAR(records);
Log(ret);
}
LeVAR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:VAR(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Letalib.ADX()fonction est utilisée pour calculer laIndice de mouvement directionnel moyen.
La valeur de rendement de latalib.ADX()la fonction est un tableau unidimensionnel.
séquence
Talib.ADX ((inPriceHLC) est une marque américaine. Talib.ADX ((inPriceHLC, optInTimePeriod) est une série de jeux vidéo télévisés.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ADX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADX(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADX(records);
Log(ret);
}
LeADX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ADX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.ADXR()fonction est utilisée pour calculer laRating moyen de l'indice de mouvement directionnel (indice d'évaluation).
La valeur de rendement de latalib.ADXR()la fonction est un tableau unidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux. Talib.ADXR ((inPriceHLC, optInTimePeriod) est une série de jeux vidéo télévisés.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ADXR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ADXR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ADXR(records);
Log(ret);
}
LeADXR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ADXR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.APO()fonction est utilisée pour calculer laL'oscillateur de prix absolu.
La valeur de rendement de latalib.APO()fonction est: un tableau unidimensionnel.
séquence
Talib.APO ((inReal) est un groupe de rock américain. Talib.APO ((en réel, optInFastPeriod) Talib.APO ((en réel, en période rapide, en période lente)) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType) est un type de type de fichier qui est utilisé par les utilisateurs.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInFastPeriodparamètre est utilisé pour définir la période rapide, la valeur par défaut est 12.
OptionInFastPeriod
faux
Numéro
LeoptInSlowPeriodLe paramètre est utilisé pour définir la période lente, la valeur par défaut est 26.
OptionInSlowPeriod
faux
Numéro
LeoptInMATypeLe paramètre est utilisé pour définir le type moyen, la valeur par défaut est 0.
OptiMAType
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.APO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.APO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.APO(records);
Log(ret);
}
LeAPO()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:APO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Letalib.AROON()fonction est utilisée pour calculer laAroon (indicateur Aroon).
La valeur de rendement de latalib.AROON()la fonction est un tableau bidimensionnel.
séquence
Talib.AROON (en anglais) Talib.AROON ((en PrixHL, optInTimePeriod) est un groupe de musique américain.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.AROON(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AROON(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AROON(records);
Log(ret);
}
LeAROON()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:AROON(Records[High,Low],Time Period = 14) = [Array(outAroonDown),Array(outAroonUp)]
Letalib.AROONOSC()fonction est utilisée pour calculer laOssillateur d'Aroon.
La valeur de rendement de latalib.AROONOSC()fonction est: un tableau unidimensionnel.
séquence
Talib.AROONOSC (en anglais) Talib.AROONOSC ((en PrixHL, optInTimePeriod) est une marque américaine.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.AROONOSC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AROONOSC(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AROONOSC(records);
Log(ret);
}
LeAROONOSC()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:AROONOSC(Records[High,Low],Time Period = 14) = Array(outReal)
Letalib.BOP()fonction est utilisée pour calculer laL'équilibre du pouvoir.
La valeur de rendement de latalib.BOP()la fonction est un tableau unidimensionnel.
séquence
Talib.BOP ((en PrixOHLC) est un groupe de travail
LeinPriceOHLCle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prix OHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.BOP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.BOP(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.BOP(records);
Log(ret);
}
LeBOP()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:BOP(Records[Open,High,Low,Close]) = Array(outReal)
Letalib.CCI()fonction est utilisée pour calculer laIndice des canaux de produits de base (indicateur homéopathique).
La valeur de rendement de latalib.CCI()la fonction est un tableau unidimensionnel.
séquence
Talib.CCI (en) Talib.CCI ((en PrixHLC, optInTimePeriod) est un groupe de télévision américain.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CCI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CCI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CCI(records);
Log(ret);
}
LeCCI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CCI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.CMO()fonction est utilisée pour calculer laLe taux d'intérêt de l'entreprise est calculé sur la base de l'indice de rentabilité..
La valeur de rendement de latalib.CMO()fonction est: un tableau unidimensionnel.
séquence
Talib.CMO ((inReal) est un acteur de la télévision. talib.CMO ((en réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.CMO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CMO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CMO(records);
Log(ret);
}
LeCMO()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:CMO(Records[Close],Time Period = 14) = Array(outReal)
Letalib.DX()fonction est utilisée pour calculer laIndice de mouvement directionnel.
La valeur de rendement de latalib.DX()fonction est: un tableau unidimensionnel.
séquence
Talib.DX ((inPriceHLC) est une marque américaine. Talib.DX ((inPriceHLC, optInTimePeriod) est une marque américaine.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.DX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.DX(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.DX(records);
Log(ret);
}
LeDX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:DX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.MACD()fonction est utilisée pour calculerMoyenne mobile convergence/divergence (moyenne mobile lissée exponentiellement).
La valeur de rendement de latalib.MACD()la fonction est: un tableau bidimensionnel.
séquence
Talib.MACD ((inReal) est un groupe de rock américain. Talib.MACD ((en réel, optInFastPeriod) Talib.MACD ((en réel, optInFastPeriod, optInSlowPeriod) Talib.MACD ((en temps réel, en temps rapide, en temps lent, en temps de signal)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInFastPeriodparamètre est utilisé pour définir la période rapide, la valeur par défaut est 12.
OptionInFastPeriod
faux
Numéro
LeoptInSlowPeriodLe paramètre est utilisé pour définir la période lente, la valeur par défaut est 26.
OptionInSlowPeriod
faux
Numéro
LeoptInSignalPeriodLe paramètre est utilisé pour définir la période du signal, la valeur par défaut est 9.
OptionPériode de signalisation
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MACD(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACD(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACD(records);
Log(ret);
}
LeMACD()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MACD(Records[Close],Fast Period = 12,Slow Period = 26,Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Letalib.MACDEXT()fonction est utilisée pour calculerMACD avec type MA contrôlable.
La valeur de rendement de latalib.MACDEXT()la fonction est un tableau bidimensionnel.
séquence
Je ne peux pas vous dire ce que je veux. Je suis désolé, je ne peux pas. talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType) est le type de type de fichier qui est utilisé pour créer un fichier talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod) est le type de fichier qui est utilisé pour démarrer une application. talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType) Il est également possible d'utiliser le type de fichier dans le tableau suivant: talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod) Il est également possible d'utiliser le type de fichier dans le mode réel. talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod, optInSignalMAType) Il est également possible d'utiliser le type de fichier dans le tableau suivant:
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInFastPeriodparamètre est utilisé pour définir la période rapide, la valeur par défaut est 12.
OptionInFastPeriod
faux
Numéro
LeoptInFastMATypeLe paramètre est utilisé pour définir le type de moyenne rapide, la valeur par défaut est 0.
Optionnel dans le type FastMAType
faux
Numéro
LeoptInSlowPeriodLe paramètre est utilisé pour définir la période lente, la valeur par défaut est 26.
OptionInSlowPeriod
faux
Numéro
LeoptInSlowMATypeLe paramètre est utilisé pour définir le type de moyenne lente, la valeur par défaut est 0.
Le type de fichier
faux
Numéro
LeoptInSignalPeriodLe paramètre est utilisé pour définir la période du signal, la valeur par défaut est 9.
OptionPériode de signalisation
faux
Numéro
LeoptInSignalMATypeLe paramètre est utilisé pour définir le type de moyenne du signal, la valeur par défaut est 0.
Le type de fichier
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MACDEXT(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACDEXT(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACDEXT(records);
Log(ret);
}
LeMACDEXT()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MACDEXT(Records[Close],Fast Period = 12,Fast MA = 0,Slow Period = 26,Slow MA = 0,Signal Period = 9,Signal MA = 0) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Letalib.MACDFIX()fonction est utilisée pour calculerLa convergence/divergence des moyennes mobiles est fixée 12/26.
La valeur de rendement de latalib.MACDFIX()la fonction est un tableau bidimensionnel.
séquence
Je ne peux pas faire ça. Talib.MACDFIX ((en réel, optInSignalPériode)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInSignalPeriodLe paramètre est utilisé pour définir la période du signal, la valeur par défaut est 9.
OptionPériode de signalisation
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MACDFIX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MACDFIX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MACDFIX(records);
Log(ret);
}
LeMACDFIX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MACDFIX(Records[Close],Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Letalib.MFI()fonction est utilisée pour calculer laIndice des flux de trésorerie.
La valeur de rendement de latalib.MFI()la fonction est un tableau unidimensionnel.
séquence
Talib.IFM ((inPriceHLCV) talib.MFI ((inPriceHLCV, optInTimePeriod) est le taux de change le plus élevé au cours de la période de référence.
LeinPriceHLCVle paramètre est utilisé pour spécifier les données de la ligne K.
Le montant de l'aide est calculé en fonction de l'évolution de la situation.
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MFI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MFI(records.High, records.Low, records.Close, records.Volume)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MFI(records);
Log(ret);
}
LeMFI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MFI(Records[High,Low,Close,Volume],Time Period = 14) = Array(outReal)
Letalib.MINUS_DI()fonction est utilisée pour calculer laIndicateur directionnel négatif.
La valeur de rendement de latalib.MINUS_DI()la fonction est un tableau unidimensionnel.
séquence
Talib.MINUS_DI (en) talib.MINUS_DI ((en PrixHLC, optInTimePeriod)
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MINUS_DI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINUS_DI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINUS_DI(records);
Log(ret);
}
LeMINUS_DI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MINUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.MINUS_DM()fonction est utilisée pour calculer laMotion négative.
La valeur de rendement de latalib.MINUS_DM()la fonction est un tableau unidimensionnel.
séquence
Talib.MINUS_DM ((enPriceHL) est une marque américaine. Talib.MINUS_DM ((en PrixHL, optInTimePeriod) est le nombre de fois où le produit est vendu.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MINUS_DM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MINUS_DM(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MINUS_DM(records);
Log(ret);
}
LeMINUS_DM()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MINUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Letalib.MOM()fonction est utilisée pour calculerL' élan.
La valeur de rendement de latalib.MOM()la fonction est un tableau unidimensionnel.
séquence
Talib.MOM (en vrai) Talib.MOM ((en réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 10.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.MOM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MOM(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MOM(records);
Log(ret);
}
LeMOM()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MOM(Records[Close],Time Period = 10) = Array(outReal)
Letalib.PLUS_DI()fonction est utilisée pour calculer laIndicateur de direction.
La valeur de rendement de latalib.PLUS_DI()fonction est: un tableau unidimensionnel.
séquence
Je suis désolée. Talib.PLUS_DI ((en PrixHLC, optInTimePeriod) est une série d'articles qui ont été publiés par le Bureau de l'emploi.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.PLUS_DI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PLUS_DI(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PLUS_DI(records);
Log(ret);
}
LePLUS_DI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:PLUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Letalib.PLUS_DM()fonction est utilisée pour calculerPlus le mouvement directionnel.
La valeur de rendement de latalib.PLUS_DM()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.PLUS_DM ((en PrixHL, optInTimePeriod) Il est temps de faire le point.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.PLUS_DM(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PLUS_DM(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PLUS_DM(records);
Log(ret);
}
LePLUS_DM()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:PLUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Letalib.PPO()fonction est utilisée pour calculer laOssillateur de prix en pourcentage.
La valeur de rendement de latalib.PPO()la fonction est un tableau unidimensionnel.
séquence
Talib.PPO ((inReal) est un groupe de rock américain. Talib.PPO ((en réalité, optInFastPeriod) Talib.PPO ((en réel, optInFastPeriod, optInSlowPeriod) Talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType) est un type de fichier qui est défini par le type de fichier.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInFastPeriodparamètre est utilisé pour définir la période rapide, la valeur par défaut est 12.
OptionInFastPeriod
faux
Numéro
LeoptInSlowPeriodLe paramètre est utilisé pour définir la période lente, la valeur par défaut est 26.
OptionInSlowPeriod
faux
Numéro
LeoptInMATypeLe paramètre est utilisé pour définir le type moyen, la valeur par défaut est 0.
OptiMAType
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.PPO(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.PPO(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.PPO(records);
Log(ret);
}
LePPO()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:PPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Letalib.ROC()fonction est utilisée pour calculerTaux de variation : ((prix/prevPrice) -1) *100 (indicateur de taux de variation).
La valeur de rendement de latalib.ROC()la fonction est un tableau unidimensionnel.
séquence
Talib.ROC ((inReal) est un groupe de rock américain. Talib.ROC ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 10.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ROC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROC(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROC(records);
Log(ret);
}
LeROC()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ROC(Records[Close],Time Period = 10) = Array(outReal)
Letalib.ROCP()fonction est utilisée pour calculerTaux de variation Pourcentage: (prix-prevPrice) /prevPrice (taux de variation des prix).
La valeur de rendement de latalib.ROCP()fonction est: un tableau unidimensionnel.
séquence
Talib.ROCP ((inReal) est un groupe de musique américain. Talib.ROCP ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 10.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCP(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCP(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCP(records);
Log(ret);
}
LeROCP()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ROCP(Records[Close],Time Period = 10) = Array(outReal)
Letalib.ROCR()fonction est utilisée pour calculer laTaux de variation du ratio: (prix/prix précédent) (ratio de variation des prix).
La valeur de rendement de latalib.ROCR()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.ROCR ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 10.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCR(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCR(records);
Log(ret);
}
LeROCR()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ROCR(Records[Close],Time Period = 10) = Array(outReal)
Letalib.ROCR100()fonction est utilisée pour calculerTaux de variation du ratio 100 échelle: (prix/prevPrice) *100 (ratio de variation des prix).
La valeur de rendement de latalib.ROCR100()fonction est: un tableau unidimensionnel.
séquence
Talib.ROCR100 ((inReal) est un groupe de médias locaux. Talib.ROCR100 ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 10.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ROCR100(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ROCR100(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ROCR100(records);
Log(ret);
}
LeROCR100()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ROCR100(Records[Close],Time Period = 10) = Array(outReal)
Letalib.RSI()fonction est utilisée pour calculer laIndice de force relative.
La valeur de rendement de latalib.RSI()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.RSI ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.RSI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.RSI(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.RSI(records);
Log(ret);
}
LeRSI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:RSI(Records[Close],Time Period = 14) = Array(outReal)
Letalib.STOCH()fonction est utilisée pour calculer laIndicateur stochastique.
La valeur de rendement de latalib.STOCH()la fonction est un tableau bidimensionnel.
séquence
Talib.STOCH (en) Talib.STOCH ((inPriceHLC, optInFastK_Period) est un système de paiement par carte de crédit. Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period) est un système de gestion des prix qui est utilisé par les sociétés pour évaluer les prix. talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType) est le type de fichier qui est utilisé pour le traitement des données. talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period) Il est possible de modifier le type de fichier ou le type de fichier. talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period, optInSlowD_MAType) Il est possible de modifier le type de fichier en utilisant le mode de fichier suivant:
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInFastK_PeriodLe paramètre est utilisé pour définir la période Fast-K, la valeur par défaut est 5.
Optionnellement
faux
Numéro
LeoptInSlowK_Periodparamètre est utilisé pour définir la période Slow-K, la valeur par défaut est 3.
OptionNombre de jours
faux
Numéro
LeoptInSlowK_MATypele paramètre est utilisé pour définir le type moyen Slow-K, la valeur par défaut est 0.
Le type de fichier
faux
Numéro
LeoptInSlowD_Periodparamètre est utilisé pour définir la période Slow-D, la valeur par défaut est 3.
OptionNombre d'heures
faux
Numéro
LeoptInSlowD_MATypeLe paramètre est utilisé pour définir le type moyen Slow-D, la valeur par défaut est 0.
Le type de fichier
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCH(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCH(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCH(records);
Log(ret);
}
LeSTOCH()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:STOCH(Records[High,Low,Close],Fast-K Period = 5,Slow-K Period = 3,Slow-K MA = 0,Slow-D Period = 3,Slow-D MA = 0) = [Array(outSlowK),Array(outSlowD)]
Letalib.STOCHF()fonction est utilisée pour calculer laIndicateur stochastique rapide (indicateur STOCH rapide).
La valeur de rendement de latalib.STOCHF()la fonction est un tableau bidimensionnel.
séquence
Talib.STOCHF ((inPriceHLC) est une société de conseil spécialisée dans le commerce de détail. Talib.STOCHF ((inPriceHLC, optInFastK_Period) est un système de paiement par carte de crédit. Talib.STOCHF ((inPriceHLC, optInFastK_Période, optInFastD_Période) est un système de paiement par carte de crédit qui est utilisé par les banques pour effectuer des paiements en espèces. Talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period, optInFastD_MAType) est le type de fichier qui est utilisé pour déchiffrer le fichier.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInFastK_PeriodLe paramètre est utilisé pour définir la période Fast-K, la valeur par défaut est 5.
Optionnellement
faux
Numéro
LeoptInFastD_PeriodLe paramètre est utilisé pour définir la période Fast-D, la valeur par défaut est 3.
Optionnel dans le temps
faux
Numéro
LeoptInFastD_MATypele paramètre est utilisé pour définir le type moyen Fast-D, la valeur par défaut est 0.
Le type de fichier
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCHF(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCHF(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCHF(records);
Log(ret);
}
LeSTOCHF()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:STOCHF(Records[High,Low,Close],Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Letalib.STOCHRSI()fonction est utilisée pour calculer laIndice de force relative stochastique.
La valeur de rendement de latalib.STOCHRSI()la fonction est: un tableau bidimensionnel.
séquence
Talib.STOCHRSI (en vrai) Talib.STOCHRSI (en temps réel, dans le temps) Talib.STOCHRSI ((en temps réel, optInTimePeriod, optInFastK_Period) Talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period) Il est également possible de modifier le code de l'appareil en utilisant les paramètres suivants: talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType) est le type de type de fichier qui est utilisé pour déchiffrer le fichier.
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
LeoptInFastK_PeriodLe paramètre est utilisé pour définir la période Fast-K, la valeur par défaut est 5.
Optionnellement
faux
Numéro
LeoptInFastD_PeriodLe paramètre est utilisé pour définir la période Fast-D, la valeur par défaut est 3.
Optionnel dans le temps
faux
Numéro
LeoptInFastD_MATypele paramètre est utilisé pour définir le type moyen Fast-D, la valeur par défaut est 0.
Le type de fichier
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.STOCHRSI(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.STOCHRSI(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.STOCHRSI(records);
Log(ret);
}
LeSTOCHRSI()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:STOCHRSI(Records[Close],Time Period = 14,Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Letalib.TRIX()fonction est utilisée pour calculer laRate-of-change (ROC) d'un jour pour une EMA triple lisse.
La valeur de rendement de latalib.TRIX()fonction est: un tableau unidimensionnel.
séquence
Talib.TRIX (en réalité) Talib.TRIX ((en temps réel, optInTimePeriod)
LeinRealle paramètre est utilisé pour spécifier les données de la ligne K.
En réalité
vrai
{@struct/Record Record} les tableaux de structure, les tableaux numériques
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 30.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.TRIX(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TRIX(records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TRIX(records);
Log(ret);
}
LeTRIX()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TRIX(Records[Close],Time Period = 30) = Array(outReal)
Letalib.ULTOSC()fonction est utilisée pour calculer laL'oscillateur ultime.
La valeur de rendement de latalib.ULTOSC()la fonction est un tableau unidimensionnel.
séquence
Je suis désolée. Talib.ULTOSC ((inPriceHLC, optInTimePeriod1) est un système de mesure de l'évolution de la consommation de l'électricité. Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2) est un système de traitement de données basé sur les données fournies par les fournisseurs. Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3) Il est possible de modifier le nom de la marque.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriod1Le paramètre est utilisé pour définir la première période, la valeur par défaut est 7.
OptionInTimePériode1
faux
Numéro
LeoptInTimePeriod2Le paramètre est utilisé pour définir la deuxième période, la valeur par défaut est 14.
optInTimePériode2
faux
Numéro
LeoptInTimePeriod3Le paramètre est utilisé pour définir la troisième période, la valeur par défaut est 28.
optInTimePériode3
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.ULTOSC(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.ULTOSC(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.ULTOSC(records);
Log(ret);
}
LeULTOSC()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:ULTOSC(Records[High,Low,Close],First Period = 7,Second Period = 14,Third Period = 28) = Array(outReal)
Letalib.WILLR()fonction est utilisée pour calculerWilliams
La valeur de rendement de latalib.WILLR()fonction est: un tableau unidimensionnel.
séquence
Talib.WILLR ((inPriceHLC) est un jeu vidéo. Talib.WILLR ((inPriceHLC, optInTimePeriod) est une série de jeux vidéo télévisés.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
LeoptInTimePeriodLe paramètre est utilisé pour définir la période, la valeur par défaut est 14.
Option dans le tempsPériode
faux
Numéro
function main() {
var records = exchange.GetRecords()
var ret = talib.WILLR(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WILLR(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WILLR(records);
Log(ret);
}```
The ```WILLR()``` function is described in the talib library documentation as: ```WILLR(Records[High,Low,Close],Time Period = 14) = Array(outReal)```
### talib.AVGPRICE
The ```talib.AVGPRICE()``` function is used to calculate **Average Price**.
The return value of the ```talib.AVGPRICE()``` function is a one-dimensional array.
array
talib.AVGPRICE(inPriceOHLC)
The ```inPriceOHLC``` parameter is used to specify the K-line data.
inPriceOHLC
true
{@struct/Record Record} structure array
```javascript
function main() {
var records = exchange.GetRecords()
var ret = talib.AVGPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.AVGPRICE(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.AVGPRICE(records);
Log(ret);
}
LeAVGPRICE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:AVGPRICE(Records[Open,High,Low,Close]) = Array(outReal)
Letalib.MEDPRICE()fonction est utilisée pour calculer laPrix médian.
La valeur de rendement de latalib.MEDPRICE()la fonction est un tableau unidimensionnel.
séquence
Talib.MEDPRICE ((en PrixHL) est une société de services à la personne.
LeinPriceHLle paramètre est utilisé pour spécifier les données de la ligne K.
Dans le prixHL
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.MEDPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.MEDPRICE(records.High, records.Low)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.MEDPRICE(records);
Log(ret);
}
LeMEDPRICE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:MEDPRICE(Records[High,Low]) = Array(outReal)
Letalib.TYPPRICE()fonction est utilisée pour calculerPrix typique.
La valeur de rendement de latalib.TYPPRICE()la fonction est un tableau unidimensionnel.
séquence
Talib.TYPPRICE ((en PrixHLC) est un groupe de travail
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.TYPPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.TYPPRICE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.TYPPRICE(records);
Log(ret);
}
LeTYPPRICE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:TYPPRICE(Records[High,Low,Close]) = Array(outReal)
Letalib.WCLPRICE()fonction est utilisée pour calculer laPrix de clôture pondéré.
La valeur de rendement de latalib.WCLPRICE()la fonction est un tableau unidimensionnel.
séquence
Talib.WCLPRICE ((inPriceHLC) est un groupe de musique américain.
LeinPriceHLCle paramètre est utilisé pour spécifier les données de la ligne K.
enPriceHLC
vrai
{@struct/Record Record} tableau de structure
function main() {
var records = exchange.GetRecords()
var ret = talib.WCLPRICE(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.WCLPRICE(records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.WCLPRICE(records);
Log(ret);
}
LeWCLPRICE()la fonction est décrite dans la documentation de la bibliothèque talib comme suit:WCLPRICE(Records[High,Low,Close]) = Array(outReal)