Retorna o número de versão atual do sistema.
Número da versão actual do sistema, como:3.6- Não.
cordel
Versão (((
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
O número de versão do sistema é o número de versão do programa do docker.
A função de sono, fazendo com que o programa pare por um período de tempo.
Sono (milissegundos)
OmillisecondO parâmetro é utilizado para definir a duração do sono e o número de milissegundos.
milissegundos
verdade
Número
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");
}
Por exemplo, ao executar oSleep(1000)Função, o programa irá dormir por 1 segundo.Sleep(0.1)Suporta um parâmetro mínimo de0.000001, ou seja, hibernação de nanossegundos, onde 1 nanossegundo é igual a1e-6milissegundos.
Quando se escreve estratégias noPythonA linguagem, oSleep(millisecond)A função de intervalo de sondagem deve ser utilizada para operações de tempo de espera.time.sleep(second)função dePythonÉ...timeIsto é porque usando otime.sleep(second)função em uma estratégia faz o programa de estratégia esperar por um período de tempo na verdade quando backtesting (não pulando sobre a série de tempo do sistema de backtesting), por isso faz com que a estratégia para backtest muito lentamente.
Determinar se o ambiente de execução da estratégia é um sistema de backtesting.
A estratégia retorna um valor verdadeiro, por exemplo:trueQuando executado no ambiente do sistema de backtesting, a estratégia retorna um valor falso, por exemplo:falsequando executado num ambiente de negociação em tempo real.
Bool
É Virtual?
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.");
}
}
Determinar se o ambiente em execução atual é um sistema de backtesting, utilizado para ser compatível com a diferença entre backtesting e negociação em tempo real.
Envia um e-mail.
Uma entrega bem-sucedida de e-mail retorna um valor verdadeiro, por exemplo,true, e uma entrega falhada retorna um valor falso, por exemplo,false- Não.
Bool
Correio ((smtpServidor, smtpUsuário, smtpPassword, mailTo, título, corpo)
Utilizado para especificar oSMTPEndereço de serviço do remetente do correio electrónico.
SmtpServer
verdade
cordel
Usado para especificar o endereço de e-mail do remetente.
Nome do usuário
verdade
cordel
OSMTPpalavra-passe para a caixa de correio do remetente do email.
SmtpPassword
verdade
cordel
Usado para especificar o endereço de e-mail do destinatário do e-mail.
mailTo
verdade
cordel
Endereço de email.
Título
verdade
cordel
Corpo de e-mail.
corpo
verdade
cordel
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");
}
OsmtpPasswordParâmetro define a palavra-passe para oSMTPserviço, não a senha da caixa de correio.
Ao definir osmtpServerParâmetro, se você precisa mudar a porta, você pode adicionar o número da porta diretamente no parâmetrosmtpServerPor exemplo: QQ mailsmtp.qq.com:587, disponível para ensaio.
Em caso de erro:unencryped connection, você precisa modificar osmtpServerdoMailFunção. O formato do parâmetro é:ssl://xxx.com:xxx, por exemplo, osslmétodo deSMTPpara correio QQ:ssl://smtp.qq.com:465ousmtp://xxx.com:xxx- Não.
Não funciona no sistema de backtesting.
Não, não, não, não.
Versão assíncrona doMail function.
OMail_Gofunção retorna um objeto simultâneo imediatamente, e você pode usar owaitUm método de que o objeto concorrente para obter o resultado da entrega de correio. uma entrega de correio bem sucedida retorna um valor verdadeiro, por exemplo,true, e uma entrega falhada retorna um valor falso, por exemplo,false- Não.
Objeto
Mail_Go ((smtpServer, smtpUsername, smtpPassword, mailTo, título, corpo)
É utilizado para especificar oSMTPEndereço de serviço do remetente do correio electrónico.
SMTPServer
verdade
cordel
É usado para especificar o endereço de e-mail do remetente do e-mail.
Nome do usuário
verdade
cordel
OSMTPpalavra-passe para a caixa de correio do remetente do email.
SmtpPassword
verdade
cordel
É usado para especificar o endereço de e-mail do destinatário do e-mail.
E-mail para
verdade
cordel
Endereço de email.
Título
verdade
cordel
Corpo do email.
corpo
verdade
cordel
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.
Não funciona no sistema de backtesting.
Não, não, não.
Registros de erros de filtragem.
SetErrorFilter (filtros)
Estringência de expressão regular. filtros verdade cordel
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");
}
Filtrar erros comuns.
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);
}
Filtrar uma mensagem de erro de interface.
Os registros de erros correspondentes a esta expressão regular não serão carregados no sistema de registros. Você pode chamá-lo várias vezes (sem limite no número de vezes) para definir várias condições de filtro. As expressões regulares definidas várias vezes serão acumuladas e entrarão em vigor ao mesmo tempo. Você pode definir uma cadeia vazia para redefinir a expressão regular usada para filtrar registros de erros:SetErrorFilter("")Os registos filtrados não são mais escritos no arquivo de banco de dados correspondente ao ID de negociação ao vivo no diretório do docker para evitar que os relatórios de erros frequentes inchaçam o arquivo de banco de dados.
Obtenha a identificação do processo de negociação.
Retornar a identificação do processo de negociação em tempo real. cordel
GetPid ((()
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
Recebi a última mensagem de erro.
Última mensagem. cordel
GetLastError (()
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);
}
Não funciona no sistema de backtesting.
Recebe o comando de interação estratégica.
O formato do comando retornado éControlName:Data. ControlNameé o nome do controlo, eDataSe o comando interativo não tiver caixas de entrada, caixas suspensas e outros componentes (por exemplo, um comando de botão sem caixas de entrada), então o formato do comando retornado éControlName, que retorna apenas o nome do controlo.
cordel
Obter Comando ((()
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);
}
}
Detecta o comando de interação e utiliza oLogFunção para emitir o comando de interação quando detectado.
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);
}
}
Por exemplo, o controle interativo estratégia adiciona um controle sem uma caixa de entrada, o controle interativo é chamado:buy, a informação relativa à descrição do controlo é:buy, que é um controle de botão. Continue adicionando um controle com uma caixa de entrada. O controle interativo é chamado:selle a mensagem de descrição do controlo é:sellO código de interação é projetado na estratégia para responder aos diferentes controles de interação:
Não funciona no sistema de backtesting.
Obter o valor de Meta escrito ao gerar o código de registro estratégia.
Metadados.
cordel
GetMeta ((()
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);
}
}
Exemplo de cenário de aplicação: utilizaçãoMetaLimitar o montante dos activos geridos pela estratégia.
O cenário de aplicação: necessidade de fazer limites de capital para diferentes locatários estratégicos.MetaO valor definido para a geração do código de registo não pode exceder 190 caracteres e oGetMeta()A função só suporta a negociação em tempo real.Meta) é definido no momento da geração de um código de registo de estratégia, oGetMeta()Função retorna nulo. Não funciona no sistema de backtesting.
Para primitivoSocketacesso, apoiotcp, udp, tls, unixSuporte a 4 protocolos de comunicação populares:mqtt, nats, amqp, kafka- Suporte para ligação a bases de dados:sqlite3, mysql, postgres, clickhouse.
ODial()Uma chamada normal retorna um objeto de conexão que tem três métodos:read, writeeclose. OreadO método é utilizado para ler os dados, owriteO método é utilizado para enviar dados e oclosemétodo é utilizado para fechar a ligação.
OreadO método suporta os seguintes parâmetros:
ws.read().ws.read(2000)Especifica um timeout de dois segundos (2000 milissegundos).-1significa que a função retorna imediatamente, independentemente da presença ou ausência de mensagens, por exemplo:ws.read(-1)- Não.
Passando o parâmetro-2significa que a função retorna imediatamente com ou sem uma mensagem, mas apenas a mensagem mais recente é devolvida e a mensagem tamponada é descartada.ws.read(-2).read()Descrição do buffer de funções:
Os dados recebidos empurrados pelo protocolo WebSocket podem causar acúmulo de dados se o intervalo de tempo entre a estratégiaread()Os dados são armazenados no buffer, que tem uma estrutura de dados de uma fila com um máximo de 2000.
| Scenário | Nenhum parâmetro | Parâmetro: -1 | Parâmetro: -2 | Parâmetro: 2000, em milissegundos |
|---|---|---|---|---|
| Dados já no buffer | Retorne os dados mais antigos imediatamente | Retorne os dados mais antigos imediatamente | Retorna os dados mais recentes imediatamente | Retorne os dados mais antigos imediatamente |
| Não há dados no buffer | Retornar quando bloqueado para dados | Retorne nulo imediatamente | Retorne nulo imediatamente | Esperar 2000 ms, retornar nulo se não houver dados, retornar nulo se houver dados |
| A conexão WebSocket é desconectada ou reconectada pelo subjacente | read() função retorna a cadeia vazia, ou seja: |
Objeto
Marque (adressos) Marque (endereço, tempo limite)
Endereço solicitado. Endereço verdade cordel segundos de tempo de espera, tempo de espera Falso Número
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();
}
}
Exemplo de chamada de função 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();
}
Para acessar a interface WebSocket do 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");
}
Acesso à interface do ticker do 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");
}
Acesso à interface do ticker do WebSocket da 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");
}
Para acessar a interface de autenticação do 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
O objeto de conexão devolvido pela função Dial quando se conecta a um banco de dados tem duas funções de método que são exclusivas para ele:
exec(sqlString): Usado para executar instruções SQL de uma forma semelhante aoDBExec() function.fd()Ofd()função retorna uma manipulação (por exemplo, a variável manipulação é manipulação) a ser usada por outros fios para reconectar (mesmo que o objeto criado por Dial já tenha sido fechado pela execução doclose()A função de fechar a ligação) passando a alça para oDial()função, por exemplo,Dial(handle)Conexão de reutilização.
O seguinte é um exemplo da função Dial ligando a umsqlite3 database.Detalhes doaddressParâmetro, separado pelo|símbolo após o endereço normal:wss://ws.okx.com:8443/ws/v5/publicSe houver|caracteres na cadeia de parâmetros, então||A parte depois disso é algumas configurações de parâmetros de função, e cada parâmetro está conectado com&A primeira é a dess5Os parâmetros de substituição e de compressão podem ser definidos em conjunto do seguinte modo:Dial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")
| Funções suportadas pelo parâmetro de endereço da função Dial | Descrição do parâmetro |
|---|---|
| Parâmetros relacionados com a compressão de dados do protocolo WebSocket: compress=parâmetro valor | compress é o método de compressão, comprimir opções de parâmetros são: gzip_raw, gzip, etc. Se o método gzip não é padrão gzip, você pode usar o método estendido: gzip_raw |
| Parâmetros relacionados com a compressão de dados do protocolo WebSocket: mode=valor do parâmetro | modo é o modo de compressão, o parâmetro de modo pode ser duplo, enviar, recv. dual é compressão bidirecional, enviar dados comprimidos, receber dados comprimidos. enviar é enviar dados comprimidos. recv é receber dados comprimidos, descompressão local. |
| O protocolo WebSocket define os parâmetros de auto-reconexão relacionados: reconnect=valor do parâmetro | reconnect é se deve definir reconnect, reconnect=true é para habilitar reconnect. O padrão é não reconnect quando este parâmetro não é definido. |
| O protocolo WebSocket define os parâmetros de auto-reconexão subjacentes: intervalo=valor do parâmetro | o intervalo é o intervalo de tentativa de reinicialização, em milissegundos, o intervalo=10000 é o intervalo de tentativa de reinicialização de 10 segundos, o padrão é de 1 segundo quando não está definido, ou seja, o intervalo=1000. |
| O protocolo WebSocket define os parâmetros relacionados com a reconexão automática subjacente: carga útil=valor do parâmetro | A carga útil é a mensagem de assinatura que precisa ser enviada quando o WebSocket é reconectado, por exemplo: payload=okokok. |
| Parâmetros relacionados com calças5 proxy: proxy=valor do parâmetro | proxy é a configuração de proxy ss5, formato de valor do parâmetro: socks5://name:pwd@192.168.0.1:1080, nome é o nome de usuário do servidor ss5, pwd é a senha de login do servidor ss5, 1080 é a porta de serviço ss5. |
ODial()A função só é suportada para negociação ao vivo.
Ao se conectar a um banco de dados usando a função Dial, a cadeia de conexão é escrita com referência ao projeto de driver de linguagem go para cada banco de dados.
| Base de dados suportadas | Projetos de impulso | Corda de ligação | Observações |
|---|---|---|---|
| Sqlite3 | github.com/mattn/go-sqlite3 | sqlite3://file:test.db?cache=shared&mode=memory | Osqlite3://Prefixo indica que está a ser utilizado um banco de dados sqlite3, exemplo de chamada:Dial("sqlite3://test1.db") |
| mysql | github.com/go-sql-driver/mysql | mysql://username:yourpassword@tcp(localhost:3306)/a sua base de dados?charset=utf8mb4 | – |
| Postgres | github.com/lib/pq | postgres://user=postgres dbname=yourdatabase sslmode=disable password=yourpassword host=localhost port=5432 | – |
| Cliquehouse | github.com/ClickHouse/clickhouse-go | - Não, não, não, não. | – |
Por favor, note que quando opayloadO conteúdo definido noaddressParâmetro contém caracteres=ou outros caracteres especiais, pode afetar a análise doaddressParâmetro doDialfunção, como o exemplo a seguir.
Exemplo de chamada de interface privada do websocket 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}}")
}
A seguinte chamada no código funciona bem:
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
Se você escrever isso diretamente empayload, não funcionará corretamente, por exemplo:
client = Dial("wss://ws.backpack.exchange|payload=" + JSON.stringify(payload))
Atualmente, apenas o JavaScript suporta o uso domqtt, nats, amqp, ekafkaO código de estratégia da linguagem JavaScript é usado como exemplo para mostrar o uso dos quatro protocolos:mqtt, nats, amqp, ekafka:
// 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")
}
}
Referência de documentação pormenorizada:Explorando FMZ: Prática do protocolo de comunicação entre as estratégias de negociação ao vivo
Envie um pedido HTTP.
Retorna os dados de resposta da solicitação.JSONstring, ele pode ser analisado peloJSON.parse()função naJavaScriptA estratégia linguística, e pelajson::parse()função naC++Se o depuração for definido como verdadeiro na estrutura de opções, o valor de retorno é um objeto (JSON); se o depuração for definido como falso, o valor de retorno é uma cadeia.
cadeia, objeto
HttpQuery (URL) HttpQuery ((url, opções)
URL de solicitação HTTP. URL do endereço verdade cordel As configurações relacionadas com solicitações HTTP, por exemplo, podem ser estruturadas da seguinte forma:
{
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
}
tlsimpressões digitais.
As configurações suportadas incluem as seguintes opções:
Chrome_:"chrome_103", "chrome_104", "chrome_105", "chrome_106", "chrome_107", "chrome_108", "chrome_109", "chrome_110", "chrome_111", "chrome_112", "chrome_117"- Não.
Safari_:"safari_15_6_1", "safari_16_0", "safari_ipad_15_6", "safari_ios_15_5", "safari_ios_15_6", "safari_ios_16_0"- Não.
Firefox_:"firefox_102", "firefox_104", "firefox_105", "firefox_106", "firefox_108", "firefox_110", "firefox_117"- Não.
Opera_:"opera_89", "opera_90", "opera_91"- Não.
- Não, não, não."zalando_android_mobile", "zalando_ios_mobile"- Não.
- Não."nike_ios_mobile", "nike_android_mobile"- Não.
arranha-céus:"cloudscraper"- Não.
- Sim, sim."mms_ios"- Não.
mesh_:"mesh_ios", "mesh_ios_1", "mesh_ios_2", "mesh_android", "mesh_android_1", "mesh_android_2"- Não.
Confirmado:"confirmed_ios", "confirmed_android"- Não.
Está bem."okhttp4_android_7", "okhttp4_android_8", "okhttp4_android_9", "okhttp4_android_10", "okhttp4_android_11", "okhttp4_android_12", "okhttp4_android_13",true, oHttpQuerychamada de função retorna a mensagem de resposta completa.false, apenas os dados doBodyda mensagem de resposta é devolvida.profilecampo pode ser deixado de fora.opções Falso Objeto
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);
}
Um exemplo de acesso à interface API de ticker pública 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/");
}
A função HttpQuery usa configurações de proxy.
OHttpQuery()Função só suportaJavaScript, C++linguagem,PythonA linguagem pode utilizar ourllibA biblioteca para enviar solicitações HTTP diretamente.HttpQuery()O sistema é utilizado principalmente para aceder às interfaces da troca que não requerem uma assinatura, como as interfaces públicas como as informações do ticker.HttpQuery()O sistema de backtesting pode ser utilizado para enviar solicitações (apenasGETO backtesting limita-se a utilizar 20 visitas a diferentesURLs, eHttpQuery()As visitas cacharão os dados.URLA segunda vez em que se acede aoHttpQuery()A função retorna os dados em cache e não ocorrem mais solicitações reais de rede.
Não, não, não, não.
Envia uma solicitação HTTP, uma versão assíncrona doHttpQuery function.
OHttpQuery_Go()função imediatamente retorna um objeto concorrente que pode ser usado para obter o resultado de uma solicitação HTTP usando owaitMétodo deJSON.parse()função pode ser usado para analisar oJSON.parse()função naJavaScriptestratégia linguística.
Objeto
HttpQuery_Go (URL) HttpQuery_Go ((url, opções)
URL de solicitação HTTP. URL do endereço verdade cordel As configurações relacionadas com solicitações HTTP, por exemplo, podem ser estruturadas da seguinte forma:
{
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, esteHttpQuery_Gochamada de função retorna a mensagem de resposta completa.false, apenas os dados doBodyda mensagem de resposta é devolvida.profilecampo pode ser deixado de fora.opções Falso Objeto
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
Acesso assíncrono à interface pública da bolsa para dados agregados de ticker.
OHttpQuery_Go()Função só suportaJavaScript, oPythonA linguagem pode ser utilizada com ourllibA biblioteca para enviar solicitações HTTP diretamente.HttpQuery_Go()O sistema de transferência de dados é utilizado principalmente para aceder a interfaces que não requerem uma assinatura na bolsa, tais como interfaces públicas como informações de ticker.HttpQuery_Gofunção não é suportada no sistema de backtesting.
Não, não, não, não.
Esta função codifica os dados de acordo com os parâmetros transmitidos.
OEncodeFunção que retorna os dados após codificação e criptografia.
cordel
Encode ((algo, inputFormat, outputFormat, dados) Encode ((algo, inputFormat, outputFormat, dados, chaveFormat, chave)
O parâmetroalgoé o algoritmo utilizado no cálculo da codificação.raw(não é utilizado algoritmo), o"sinal", algotambém suporta: algotambém suporta: algopode ser escrito como ed25519.seedCalculo.
algo
verdade
cordel
Utilizado para especificar o formato de dados dodataParâmetro.inputFormatO parâmetro pode ser definido como um dos seguintes:raw, hex, base64, string. hexcodificado, base64codificado, e outputFormatO parâmetro pode ser definido como um dos seguintes:raw, hex, base64, string. hexcodificado, base64codificado, e datasão os dados a processar.
dados
verdade
cordel
Utilizado para especificar o formato de dados dokeyParâmetro.keyO parâmetro pode ser definido como um dos seguintes:raw, hex, base64, string. hexcodificado, base64codificado, e keyé a chave secreta usada paraHMACO parâmetrokeyé exigido quando o parâmetroalgoestá definido emsignousignTx. OkeyParâmetro não utilizado paraHMACcriptografia quando oalgoO parâmetro é definido como
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
}
Exemplo de chamada de função 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);
}
O parâmetroalgotambém suporta:
OEncode()A função só é suportada para negociação ao vivo.keyekeyFormatOs parâmetros não são transmitidos, entãokeyNão se utiliza encriptação.
Obtenha o carimbo de tempo do momento atual.
OUnixNano()A função retorna o selo de tempo do nanossegundo.
Número
UnixNano ((()
function main() {
var time = UnixNano() / 1000000
Log(_N(time, 0))
}
def main():
time = UnixNano()
Log(time)
void main() {
auto time = UnixNano();
Log(time);
}
Se precisar de marcas de tempo de milissegundos, pode usar o seguinte código:
Não, não, não.
Obtenha o carimbo do momento atual no segundo nível.
Devolve a marca de tempo de segundo nível. Número
Unix ((()
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
Não, não, não, não.
Obter as informações do sistema do dispositivo onde o docker está localizado.
Informações do sistema. cordel
GetOS ((()
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
Por exemplo, uma chamada para oGetOS()função para um docker em execução noMac OSsistema operacional pode retornar:darwin/amd64Porque os computadores da Apple têm várias arquiteturas de hardware.darwiné o nome doMac OS system.
Computa o hash MD5 do parâmetrodata.
Valor hash MD5. cordel
MD5 (dados)
Os dados que requerem cálculo MD5. dados verdade cordel
function main() {
Log("MD5", MD5("hello world"))
}
def main():
Log("MD5", MD5("hello world"))
void main() {
Log("MD5", MD5("hello world"));
}
Chamando oMD5("hello world")função, o valor de retorno é:5eb63bbbe01eeed093cb22bb8f5acdc3.
Não, não, não, não.
Funções de interface de banco de dados.
Um objeto que contém o resultado da execução de umQuadradodeclaração, por exemplo:
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
Objeto
DBExec ((sql)
Quadradocadeia de instruções. Quadrado verdade cordel
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;"));
}
Suporte de base de dados em memória, paraDBExecParâmetros funcionais, se:Quadradodeclaração começa com:É adequado para operações de banco de dados que não requerem salvação persistente, por exemplo:
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);
}
Crie uma mesa.
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));
}
Adicionar, excluir, verificar e alterar os registos na tabela.
A funçãoDBExec()Pode operar o banco de dados de negociação ao vivo (base de dados SQLite) através da passagem de parâmetros.SQLiteO sistema reservou tabelas na base de dados de negociação ao vivo:kvdb, cfg, log, profit, chart, não operar nessas mesas.TransaçõesO sistema de gestão de dados não é suportado e não é recomendado executar tais operações, que podem causar conflitos no sistema.DBExec()A função só é suportada para negociação ao vivo.
Não, não, não.
Crie um UUID.
UUID de 32 bits. cordel
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);
}
OUUID()A função suporta apenas negociação ao vivo.
Ouça para os eventos, ele retorna quando há qualquerWebSocketdados legíveis ou tarefas simultâneas, tais como:exchange.Go(), HttpQuery_Go(), etc. são concluídas.
Se o objeto devolvido não for um valor nulo, oEventO conteúdo do retorno é o tipo de desencadeador de evento.
{"Seq":1,"Event":"Exchange_GetTrades","ThreadId":0,"Index":3,"Nano":1682068771309583400}
Objeto
EventLoop ((() EventLoop (Timeout)
O parâmetrotimeouté a definição de timeout, em milissegundos.timeoutespera que um evento ocorra antes de retornar se for definido como 0. Se for maior que 0, define o evento para esperar por um timeout e retorna o evento mais recente imediatamente se for menor que 0.
tempo de espera
Falso
Número
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);
}
A primeira chamada para oEventLoop()função no código inicializa o mecanismo para o evento ouvido, e se o primeiroEventLoop()O sistema subjacente envolve uma estrutura de fila que cacheia um máximo de 500 chamadas de evento.EventLoop()função não é chamada a tempo de tirá-los durante a execução do programa, mais tarde eventos callbacks fora do 500 cache serão perdidos.EventLoop()função não afetam a fila de cache do sistema WebSocket subjacente ou os caches de funções simultâneas, tais comoexchange.Go()Para estes caches, ainda é necessário usar os respectivos métodos para recuperar os dados.EventLoop()função para dados que foram recuperados antes doEventLoop()A função retorna os resultados.EventLoop()A estratégia é baseada em eventos, que são gerados por eventos, que são gerados por eventos, que são gerados por eventos.EventLoop()função retorna um evento, apenas atravessa todas as fontes de dados.exchange.Go()tentam obter dados.EventLoop()A função suporta apenas negociação ao vivo.
Ouça os eventos no thread principal quando chamado da função principalmain(). nas estratégias escritas noJavaScriptA linguagem, othreading.Thread()função cria um thread, que também pode ser chamado na função de execução do thread
{@fun/Global/Dial Dial}, {@fun/Trade/exchange.Go exchange.Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
O__ServeA função é usada para criar o serviço HTTP, o serviço TCP e o serviço Websocket (baseado no protocolo HTTP).
Retorna uma cadeia que registra o endereço IP e a porta do serviço criado.127.0.0.1:8088, [::]:8089.
cordel
__Serve ((serveURI, manipulador) __Serve ((serveURI, manipulador,...args)
OserveURIO parâmetro é usado para configurar o protocolo, endereço IP, porta e outras configurações da ligação do serviço, tais comohttp://0.0.0.0:8088?gzip=true, isto é,http://:8088?gzip=true.
serveURIdefinição de parâmetros, tais comotcp://127.0.0.1:6666?tls=true; pode adicionar certificados e chaves privadas, tais comotls=true&cert_pem=xxxx&cert_key_pem=xxxx.serveURIconfigurações de parâmetros, tais como:http://127.0.0.1:6666?gzip=true; pode definir as configurações de compressão:gzip=true- Não.
OserveURIParâmetro é usado para Https, tais comohttps://127.0.0.1:6666?tls=true&gzip=truePode acrescentarcert_pemecert_key_pemParâmetros para carregar o certificado.ServirURI
verdade
cordel
OhandlerO parâmetro é usado para passar na função de processamento de roteamento (protocolo HTTP), função de processamento de mensagens (protocolo TCP) e função de processamento de fluxo (Websocket).
A função de chamada de volta transmitida pelo parâmetrohandlerPode definir vários parâmetros, o primeiro parâmetro é o objeto ctx (objeto de contexto).
manipulador
verdade
função
O parâmetro real da função callback passado como o parâmetrohandlerPode haver vários parâmetrosarg, por exemplo:
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
Os parâmetros1, 2, 3Passado em quando chamar o__Serve()função correspondem aos parâmetrosa, b, cPassado na função de chamada de volta.
arg Falso cadeia, número, bool, objeto, matriz, função, valor nulo e outros tipos suportados pelo sistema
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
WebsocketVocê pode definir um ramo de roteamento no caminho e projetar o código de implementação paraWebsocketPode consultar o código de exemplo nesta secção.A função de chamada de volta transmitida pelo parâmetrohandlerrecebe umctxParâmetro.ctxParâmetro é um objeto de contexto utilizado para obter e escrever dados, com os seguintes métodos:
HTTP/1.1, tcp.http://127.0.0.1:8088?num=123, e a função de processamento de chamada de retorno transmitida pelo parâmetrohandlerretorno"123"Quando?ctx.query("num")é chamado.User-Agentnos cabeçalhos do presente pedido:ctx.header("User-Agent").GET, POST, etc.ctxobjeto de contexto para o protocolo Websocket; devolvendo um valor booleano (verdadeiro) se a mudança for bem-sucedida e um valor booleano (falso) se falhar.readmétodo não é suportado no protocolo HTTP comum. Você pode especificar o parâmetro timeouttimeout_msem milissegundos.JSON.stringify()para codificar o objeto JSON em uma cadeia de caracteres e, em seguida, escrevê-lo.WebSocketprotocolo, você pode usar este método para passar a cadeia codificada para o cliente.{@fun/Global/HttpQuery HttpQuery}, {@fun/Global/HttpQuery_Go HttpQuery_Go}
A estrutura de dados é uma tabela KV que é salvada permanentemente no arquivo de banco de dados local do docker.
Dados de valores-chave salvos de forma persistentek-vpares de chaves e valores.
cadeia, número, bool, objeto, matriz, valor nulo
_G() _G(k) _G(k, v)
O parâmetroké o nome da chave no par chave-valor guardado e não é sensível a minúsculas e minúsculas.
k
Falso
string, valor nulo
O parâmetrové o valor chave no par chave-valor salvo, que pode ser qualquer dado que possa serJSONserializado.
v
Falso
cadeia, número, bool, objeto, matriz, valor nulo
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();
}
Uma base de dados separada para cada negociação em tempo real, os dados salvos pelo_G()A função estará sempre lá se a estratégia for reiniciada ou o docker parar de funcionar._G()Quando se utiliza o_G()Função para persistir os dados salvos, deve ser usado razoavelmente de acordo com a memória e espaço no disco rígido do dispositivo de hardware, e não deve ser abusado.
Ao ligar para o_G()A função é executada em uma negociação ao vivo e não são passados parâmetros, o_G()função retorna oIdO número de transacções em tempo real._G()função, o parâmetrové passado como nulo para indicar a exclusão dok-vQuando se chama o_G()função, apenas o parâmetroké passado na cadeia, e o_G()função retorna o valor da chave correspondente ao parâmetro guardadok. Ao ligar para o_G()função, apenas o parâmetroké passado em um valor nulo, indicando que todos os registos dok-vQuando o par de chaves-valores é excluído.k-vOs pares chave-valor foram salvos persistentemente, o_G()função é chamada novamente, passando no nome da chave que foi salvada persistentemente como parâmetrok. Passando o novo valor da chave como parâmetrovVou atualizar isso.k-vPares chave-valor.
Não, não, não, não.
Converte marcas de tempo de milissegundos ouDateObjetos para cordas de tempo.
Uma cadeia de tempo. cordel
_D() _D (horário) _D (horário, fmt)
Marca de tempo de milissegundos ouDateObjeto.
Marca de data e hora
Falso
Número, objeto
Formatar string,JavaScriptformato padrão da língua:yyyy-MM-dd hh:mm:ss; Pythonformato padrão da língua:%Y-%m-%d %H:%M:%S; C++formato padrão da língua:%Y-%m-%d %H:%M:%S- Não.
fmt
Falso
cordel
function main(){
var time = _D()
Log(time)
}
def main():
strTime = _D()
Log(strTime)
void main() {
auto strTime = _D();
Log(strTime);
}
Obter e imprimir a cadeia de tempo atual:
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));
}
O carimbo de data e hora é 1574993606000, utilizando a conversão de código:
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
}
Formatação com o parâmetrofmté diferente paraJavaScript, Python, eC++línguas, conforme indicado nos seguintes exemplos:
Retorna a cadeia de tempo atual sem passar quaisquer parâmetros._D()função naPythonestratégia, você precisa estar ciente de que os parâmetros passados são carimbos de tempo de segundo nível (carimbos de tempo de nível de milissegundos nas estratégias JavaScript e C ++, onde 1 segundo é igual a 1000 milissegundos)._D()Função para analisar uma cadeia de tempo com uma marca de tempo legível na negociação ao vivo, você precisa prestar atenção ao fuso horário e configuração de hora do sistema operacional onde o programa docker está localizado._D()A função analisa um carimbo de tempo em uma cadeia de tempo legível dependendo do tempo do sistema docker.
Não, não, não, não.
Formatar um número com vírgula flutuante.
O número de vírgula flutuante formatado de acordo com a definição de precisão. Número
_N() _N (número) _N (número, precisão)
O número de vírgula flutuante que precisa ser formatado.
Número
verdade
Número
A definição de precisão para a formatação, o parâmetroprecisioné um inteiro, e o parâmetroprecisionpadrões para 4.
precisão
Falso
Número
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);
}
Por exemplo,_N(3.1415, 2)eliminará o valor após3.1415duas casas decimais e a função retorna3.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);
}
Se você precisa mudar todos os dígitos N à esquerda do ponto decimal para 0, você pode escrever assim:
O parâmetroprecisionPode ser um número inteiro positivo, negativo inteiro.
{@fun/Trade/exchange.SetPrecision exchange.SetPrecision}
Tente novamente a função de tolerância a falhas da interface.
Valor de retorno da função de chamada de retorno quando executada. Todos os tipos são suportados pelo sistema excetovalor lógico falsoevalor nulo.
_C (((pfn) - Não, não, não.
O parâmetropfné uma referência de função, que é umaFunção de recallback- Não.
pfn
verdade
função
Parâmetros paraFunções de recallback, pode haver mais de um parâmetroargTipo e número de parâmetrosargDepende dos parâmetros doFunção de recallback- Não.
arg
Falso
string, number, bool, object, array, function, todos os tipos são suportados pelo sistema, como valores nulos
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);
}
Para funções tolerantes a erros sem parâmetros:
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);
}
Para funções com parâmetros tolerantes a erros:
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
Também pode ser usado para tolerância a falhas de funções personalizadas:
O_C()função continuará a chamar a função especificada até que retorne com sucesso (a função referenciada pelo parâmetropfnretornozeroouFalsoQuando for chamado, tentará ligar novamente.pfnPor exemplo:_C(exchange.GetTicker). O intervalo de tentativa de reinicialização padrão é de 3 segundos, você pode chamar o_CDelay()função para definir o intervalo de reatendimento._CDelay(1000)A utilização de um dispositivo de ensaio para alterar o intervalo de ensaio_C()Função para 1 segundo.
A tolerância de falhas pode ser feita para, mas não se limita a, as seguintes funções:
exchange.GetTicker()exchange.GetDepth()exchange.GetTrades()exchange.GetRecords()exchange.GetAccount()exchange.GetOrders()exchange.GetOrder()exchange.GetPositions()Todos podem ser chamados pelo_C()A função de tolerância a falhas._C()a função não é limitada à tolerância de falha da função acima listada, o parâmetropfné uma referência de função em vez de uma chamada de função.
Observe que é_C(exchange.GetTicker), não_C(exchange.GetTicker()).Retorna o número de períodos de intersecção da matrizarr1e a matrizarr2.
Número de períodos transversais da matrizarr1e a matrizarr2- Não.
Número
_Cross ((arr1, arr2)
Os elementos são matrizes de tiponumber- Não.
arr1
verdade
matriz
Os elementos são matrizes de tiponumber- Não.
arr2
verdade
matriz
// 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));
}
Um conjunto de dados pode ser simulado para testar a função _Cross ((Arr1, Arr2):
Se o valor de retorno do_Cross()Se a função é um número positivo, indica o período de penetração ascendente, se é um número negativo, indica o período de penetração descendente, 0 significa o mesmo que o preço atual.Análise e instruções de utilização sobre a função integrada.
A funçãoJSONParse()é usado para analisarJSON strings.
JSONObjeto.
Objeto
JSONParse (s)
JSONA corda.
s
verdade
cordel
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.
}
As cadeias de caracteres JSON com grandes valores podem ser analisadas corretamente, e ele irá analisar grandes valores como tipos de cadeia.JSONParse()função não é suportada no sistema de backtest.
Registros de saída.
Registo (...msgs)
O parâmetromsgé o conteúdo da saída e o parâmetromsgpodem ser passadas mais de uma.
msg
Falso
string, número, bool, objeto, matriz, qualquer tipo suportado pelo sistema, como zero.
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
MúltiplosmsgOs parâmetros podem ser transmitidos:
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@");
}
Ele suporta a definição da cor da mensagem de saída, se usarmos a definição de cor e empurrar ao mesmo tempo, precisamos definir a cor primeiro e usar@Caracter para definir o último empurrão.
function main() {
Log("`data:image/png;base64,AAAA`")
}
def main():
Log("`data:image/png;base64,AAAA`")
void main() {
Log("`data:image/png;base64,AAAA`");
}
OLog()Função de impressãobase64imagens codificadas, começando com`e termina com`, por exemplo:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
OLog()função suporta a impressão directa dePythonÉ...matplotlib.pyplotO objecto contém osavefigO método de impressão pode ser impresso diretamente utilizando oLogfunção, por exemplo:
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
OLog()A função suporta a comutação de idiomas.Log()A função produz texto que irá mudar para a língua correspondente automaticamente com base na configuração da língua na página da plataforma, por exemplo:
OLog()A função produz uma mensagem de log na área de log do sistema de negociação ao vivo ou backtesting, e o log é salvo na base de dados de negociação ao vivo quando a negociação ao vivo está em execução.Log()função produz uma mensagem de log terminando com o@Push para o endereço de e-mail, endereço WebHook, etc configurado noPush ConfiguraçõesA transferência de mensagens não é suportada porFerramentas de depuraçãoHá um limite de frequência para o push de mensagens. As regras de restrição específicas são as seguintes: dentro de um ciclo de 20 segundos de uma negociação ao vivo, apenas a última mensagem de push será retida e empurrada, e outras mensagens serão filtradas e não empurradas (a saída de log de push pela função Log será impressa e exibida normalmente na área de log).
ParaWebHookPush, você pode usar o programa de serviço escrito porGolang:
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)
}
ConjuntoWebHookemPush Configurações: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ- Não.
Depois de executar o escritoGolangprograma de serviço, começamos a executar a estratégia de negociação ao vivo, o seguinte é a estratégia escrita emJavaScriptA estratégia é executada através daLog()função e empurrando a mensagem:
function main() {
Log("msg", "@")
}
Um programa de serviço escrito noGolangA linguagem recebe o push e o programa de serviço imprime a mensagem:
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
Não, não, não, não, não.
Registre o valor de lucro e lucro, imprima o valor de lucro e lucro e trace a curva de retorno com base no valor de lucro e lucro.
LogProfit (lucro) LogProfit ((lucro,...args)
O parâmetroprofitsão os dados relativos às receitas, que são dados pelo algoritmo de conceção e pelo cálculo da estratégia.
lucro
verdade
Número
Parâmetro alargado para a saída de informações acessórias para o registo de receitas,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, número, bool, objeto, matriz, qualquer tipo suportado pelo sistema, como zero.
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);
}
}
OLogProfitfunção, se terminar com o caractere&, elabora apenas o gráfico de receitas e não imprime o registo de receitas.
Não, não, não, não.
Limpa todos os registos de receitas, gráficos de receitas.
LogProfitReset (em inglês) LogProfitReset (remain)
OremainO parâmetro é utilizado para especificar o número de entradas de registo (valor inteiro) a manter.
permanecer
Falso
Número
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);
}
Não, não, não, não.
Informações de saída na barra de estado do sistema de backtesting ou página de negociação em tempo real.
LogStatus ((...msgs)
O parâmetromsgé o conteúdo da saída e o parâmetromsgpodem ser passadas mais de uma.
msg
Falso
string, número, bool, objeto, matriz, qualquer tipo suportado pelo sistema, como zero.
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");
}
Suporta a definição da cor do conteúdo de saída:
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() + "`");
}
Exemplo de saída de dados na barra de estado:
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() + "`");
}
Suporta o design de controles de botões na barra de status (estrutura de botões antiga):
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() + "`");
}
Configure a função de descrição desativada do botão da barra de estado (estrutura do botão antigo):
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);
}
}
Em combinação com oGetCommand()função, construir a função de interação do botão da barra de estado (estrutura do botão antigo):
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);
}
}
Os dados de entrada também são suportados ao construir botões de barra de estado para interação, e os comandos de interação são capturados peloGetCommand()adicionarinputelementos (estrutura de botão antigo) para a estrutura de dados do comando do botão na barra de status, por exemplo, adicionando"input": {"name": "number of open positions", "type": "number", "defValue": 1}para{"type": "button", "cmd": "open", "name": "open position"}fará com que apareça um popup com um controle de caixa de entrada quando o botão for clicado (o valor padrão na caixa de entrada é 1, que é os dados definidos pordefValuePor exemplo, quando o seguinte código de teste é executado, depois de clicar no botão "open positionGetCommand()A função irá então capturar a mensagem: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);
}
}
Suporta controles de botões agrupados (estrutura de botões antiga), funcionalmente consistente combotões da barra de estado que suportam a entrada de dadosOs comandos interativos são finalmente capturados peloGetCommand()A diferença é que com o"group"configuração de campo, quando o botão é clicado para desencadear a interação, o diálogo que aparece na página contém um conjunto degrupode controles de entrada configurados para inserir um grupo de dados de uma só vez.
Alguns pontos a observar sobre o"group"campo na estrutura do comando do botão da barra de estado e do comando do botão do grupo:
typePropriedade em grupo suporta apenas os seguintes quatro tipos, e odefValueproperty é o valor padrão.
|símbolo para separar cada opção numa caixa suspensa conforme definida.
"name": "tradePrice@orderType==1"A definição, o que faz ocomércioPriceO controlo de entrada só está disponível quando oordem TipoO controlo "drop-down" é selecionado comoOrdem pendente.|símbolos para separar o conteúdo da descrição em chinês e em inglês.name, descriptionem grupo ename, descriptionna estrutura do botão não têm as mesmas definições, embora tenham os mesmos nomes de campo.
A definição denameA definição de grupo também é diferente da definição denameem entrada.Log("cmd:", cmd)Declaração no seguinte exemplo de ensaio:cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, ou seja, o que é devolvido peloGetCommand()Função quando ocorre uma interação:open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.typePropriedade do comando do botão suporta apenas:"button"- Não.
Os comandos de botão que suportam dados de entrada, ou seja, comandos com oinputconjunto de propriedades, otypePropriedade na informação de configuração doinputcampo suporta múltiplos tipos de controlo.
Considere os seguintes exemplos: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);
}
}
Quando o comando do botão de grupo da barra de estado (implementadogroupcampo) e o comando do botão da barra de estado (implementadoinputcampo) são clicados para desencadear a interação (estrutura de botão antigo), o controle da caixa suspensa na caixa de diálogo que aparece na página também suporta múltiplas seleções.
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...
Use a estrutura de botões mais recente para construir os botões na tabela da barra de status. Para mais informações, consulte:Guia do utilizador - Controles interativos na barra de estado.
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() + "`");
}
Combinação horizontal de células dentro do quadro traçado peloLogStatus()Função:
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() + "`");
}
Mergulhar verticalmente as células na tabela desenhada peloLogStatus()Função:
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() + "`");
}
Exibição de paginação da tabela da barra de estado:
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() + "`");
}
Além de exibir tabelas em páginas, várias tabelas também podem ser exibidas em uma ordem de cima para baixo:
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() + "`");
}
Suporte para definir o modo de rolagem horizontal e vertical da tabela de barra de estado.scrollatributo de"auto", quando o número de linhas verticais da tabela de barras de estado exceder 20 linhas, o conteúdo será rolado.scrollO atributo pode ser usado para aliviar o problema de atraso de escrever uma grande quantidade de dados na barra de status durante a negociação ao vivo.
A produção de informação a partir daLogStatus()A função quando a negociação ao vivo está em execução não é salvada no banco de dados de negociação ao vivo, mas atualiza apenas o conteúdo da barra de status da negociação ao vivo atual.
OLogStatus()Função de impressãobase64imagens codificadas, começando com`e termina com`Por exemplo:LogStatus("`data:image/png;base64,AAAA`")- Não.
OLogStatus()Função de suporte de passagemmatplotlib.pyplotobjetos diretamente noPython, desde que o objeto contenha osavefigmétodo, pode ser passado como um parâmetro para oLogStatus()função, por exemplo:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
Quando a estratégia está executando negociação ao vivo, se você passar pelo histórico na página de negociação ao vivo, a barra de status vai dormir e parar de atualizar.base64imagens codificadas na barra de status, e também suporta a saídabase64Como os dados da cadeia da imagem codificada são geralmente muito longos, o código de amostra não é mostrado.
Não, não, não.
Ativar ou desactivar o registo das informações de encomenda.
AtivarLog (ativado)
Se oenableO parâmetro é definido como falso, por exemplo:false, o registo de encomendas (ou seja, o registo gerado por funções comoexchange.Buy()) não é impressa nem inscrita na base de dados das negociações em tempo real.
permitir
verdade
Bool
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}
Personalizar a função de desenho de gráficos.
Objeto gráfico. Objeto
Gráfico (opções)
OoptionsO parâmetro é a configuração do gráfico.Chart()Parâmetro de funçãooptionsé umJSONSerializávelHighStocksParâmetro paraHighcharts.StockChart- Um extra.__isStockatributo é adicionado sobre o parâmetro nativo, e se__isStock:falseSe o gráfico de referência for especificado, ele é exibido como um gráfico normal.__isStockatributo é definido em um valor falso, por exemplofalse, ou seja, o gráfico utilizado é umHighchartsSe o__isStockAtributo é definido para um valor verdadeiro, por exemplotrue, ou seja, o gráfico utilizado é umHighstocksgráfico (por defeito)__isStockÉ verdade, por exemplo.true) Pode consultar oBiblioteca de gráficos HighStocks- Não.
opções
verdade
Objeto, matriz de objetos
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});
}
}
Configuração de desenho de gráficos múltiplos:
extension.layoutatributo
Se o atributo for definido com o valor extension.heightatributo
O atributo é usado para definir a altura do gráfico, como um valor numérico ou como extension.colatributo
O atributo é usado para definir a largura do gráfico, a largura da página é dividida em 12 células, conjunto 8, ou seja, o gráfico ocupa 8 largura de células.// 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);
}
}
Exemplo de um desenho simples:
// 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);
}
}
Exemplo de desenho de curva trigonométrica:
/*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;
}
}
Exemplos complexos de utilização de gráficos híbridos:
// 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);
Cartões de tipopiesão gráficos sem uma linha do tempo, e você precisa atualizar a configuração do gráfico diretamente ao atualizar os dados.c.update(chartCfg)Após a atualização dos dados, do seguinte modo:
OChart()função retorna um objeto gráfico que tem 4 métodos:add(), reset(), update(), del().
update()método:
Oupdate()O parâmetro deste método é o objeto de configuração do gráfico (JSON).del()método:
Odel()O método pode excluir a série de dados do índice especificado com base no parâmetro de série passado.add()método:
Oadd()O método pode escrever dados para o gráfico, com os seguintes parâmetros em ordem:series: utilizado para definir o índice da série de dados, que é um número inteiro.data: usado para definir os dados específicos a serem escritos, é uma matriz.index(opcional): utilizado para definir o índice de dados, é um número inteiro.-1refere-se aos últimos dados do conjunto de dados.
Por exemplo, ao desenhar uma linha, modificar os dados no último ponto da linha:chart.add(0, [1574993606000, 13.5], -1), isto é, alterar os dados no penúltimo primeiro ponto do gráficoseries[0].data- Não.
OindexO parâmetro não é definido, o que significa que os dados são adicionados ao último ponto da série de dados corrente.reset()método:
Oreset()O método é utilizado para esvaziar os dados do gráfico.reset()método pode tomar um parâmetroremainPara especificar o número de entradas a manter.remainé passado para limpar todos os dados.Não, não, não, não.
A função é usada para desenho personalizado no tempo de execução da estratégia usando um método de desenho similar aoPine language.
O objeto gráfico.KLineChart()função retorna um objeto gráfico com vários métodos, entre os quais você precisa prestar atenção abegin()eclose(). A operação de desenho deve começar por umbegin()Função chamada e termina com aclose()chamada de função ao atravessar os dados KLine para executar a operação de desenho.
Objeto
KLineChart (opções)
OoptionsO parâmetro é a configuração do gráfico.
opções
verdade
Objeto, matriz de objetos
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
Se um objeto de controlo de gráfico for necessário para desenhar na área de desenho personalizado da estratégia, use oKLineChart()A função para criar o objeto.KLineChart()A função é uma estrutura de configuração de gráfico, a usada no código de referência é simples:{overlay: true}Esta estrutura de configuração de gráfico define apenas o conteúdo do desenho a ser emitido no gráfico principal.overlayé definido em um valor falso, por exemplo:false, o conteúdo do gráfico é saída no gráfico secundário. Se você precisa especificar uma função de desenho para desenhar no gráfico principal, você também pode especificar o parâmetrooverlaycomo um valor verdadeiro na chamada de função específica, por exemplo: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
As funções da interface de desenho doPineAs línguas suportadas na operação de desenho são:barcolor, que define a cor da linha K.
barcolor ((color, offset, editável, show_last, title, display) Parâmetros de exibição são opcionais:
none , all
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// Not supported for now
bgcolor, preenche o fundo da linha K com a cor especificada.
bgcolor ((color, offset, editável, show_last, título, exibição, sobreposição) Parâmetros de exibição são opcionais:
none , all
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, traçar uma série de dados num gráfico.
plot ((série, título, cor, largura de linha, estilo, trackprice, histbase, offset, join, editável, show_last, display) Os parâmetros de estilo são opcionais:
stepline_diamond , stepline , cross , areabr , area , circles , columns , histogram , linebr , line Parâmetros de exibição opcionais: none , all
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, preencher o fundo entre dois gráficos ouhlinecom as cores fornecidas.
preencher ((linha1, linha2, cor, título, editável, preencher espaços, exibição) Parâmetros de exibição são opcionais:
none , all
Desde oJavaScriptlinguagem não pode especificar parâmetros de entrada com base nos nomes das funções parâmetros formais, para resolver este problema, você pode usar um{key: value}estrutura para especificar os parâmetros a passar a um determinado nome de parâmetro formal.
Por exemplo, o código de referência utiliza{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)'}Especifica ocolorParâmetro dofillfunção.
Se você precisa especificar vários parâmetros com nomes de parâmetros de forma consecutiva, você pode usar{key1: value1, key2: value2, key3: value3}- Não.
Por exemplo, neste exemplo, um extratitleÉ especificado o parâmetro:{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)', title: 'fill'}- Não.
Para o valor da cor, você pode definir com'rgba(255, 0, 0, 0, 0.2)'ou com'#FF0000'.
c.hline(bar.High)
c.hline(bar.High)
// Not supported for now
hline, a linha horizontal é apresentada a um determinado nível de preço fixo.
linha ((preço, título, cor, estilo de linha, largura de linha, editável, exibição) Os parâmetros do estilo de linha são opcionais:
dashed , dotted , solid Parâmetros de exibição são opcionais: none , all
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// Not supported for now
plotarrow, traçar setas para cima e para baixo no gráfico.
Plotarrow ((série, título, colorup, colorordown, offset, minheight, maxheight, editável, show_last, display) Parâmetros de exibição são opcionais:
none , all
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// Not supported for now
plotshape, desenhar formas visuais no gráfico.
plotshape (série, título, estilo, localização, cor, offset, texto, textcolor, editável, tamanho, show_last, display) Os parâmetros de estilo são opcionais:
diamond size.autoÉ pequeno. Parâmetros de exibição são opcionais:, square , label_down , label_up , arrow_down , arrow_up , circle , flag , triangle_down , triangle_up , cross , xcross Os parâmetros de localização são opcionais: bar superior , bar inferior , top , bottom , absolute Os parâmetros de tamanho são opcionais: 10px , 14px , 20px , 40px , 80px , comparando size.tiny, size.small, size.normal, size.large, size.huge na língua Pine. none , all
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// Not supported for now
plotchar, desenhe formas visuais no gráfico usando qualquer caracter Unicode dado.
plotchar ((série, título, char, localização, cor, offset, texto, textcolor, editável, tamanho, show_last, display) Os parâmetros de localização são opcionais:
bar superior size.autoÉ pequeno. Parâmetros de exibição são opcionais:, bar inferior , top , bottom , absolute Os parâmetros de tamanho são opcionais: 10px , 14px , 20px , 40px , 80px , comparando size.tiny, size.small, size.normal, size.large, size.huge na língua Pine. none , all
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, traçar um gráfico de linha K em um gráfico.
plotcandle ((aberto, alto, baixo, fechado, título, cor, wickcolor, editável, show_last, bordercolor, display) Parâmetros de exibição são opcionais:
none , all
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// Not supported for now
signal, uma função não disponível na linguagem Pine, é usada para desenhar sinais de compra e venda aqui.
sinal ((direção, preço, qty, id) O parâmetro
long é passado para indicar a direção da transação, você pode escolher long , closelong , short , closeshort . bar.Highé a posição do eixo Y do sinal de marcação. O parâmetro transmitido 1.5 indica o número de transações do sinal. O quarto parâmetro pode ser transmitido para substituir o conteúdo de texto padrão desenhado, e o texto padrão do marcador de sinal desenhado é a direção da transação, por exemplocloselong .
c.reset()
c.reset()
// Not supported for now
reset, uma função não disponível na linguagem Pine, é usada para esvaziar os dados do gráfico.
Reiniciar (permanecer) O
reset()O método pode assumir um parâmetro,remain, para especificar o número de dados a conservar.remainsignifica limpar todos os dados.
Estratégia desenho personalizado só pode usar uma das formas deKLineChart()função ouChart()Para algumas configurações de cor e estilo utilizadas noKLineChart()chamada de função, por favor, consulte oUse a função KLineChart para facilitar o desenho de estratégias.
Não, não, não, não.
Limpa o tronco.
LogReset (permanecer)
OremainO parâmetro é utilizado para definir o número de entradas de registo recentes a manter.
permanecer
Falso
Número
function main() {
// Keep the last 10 logs and clear the rest
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
O log de inicialização para cada início da estratégia conta como um, por isso, se nenhum parâmetro for passado e não houver saída de log no início da estratégia, nenhum log será exibido, esperando que o log docker seja devolvido (não é uma exceção).
Não, não, não, não.
Utilizado para recuperar o espaço de armazenamento ocupado porSQLiteQuando se excluem dados após a chamada doLogReset()Função para limpar o registro.
LogVacuum ((()
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
A razão é queSQLitenão recupera o espaço ocupado ao excluir dados, e precisa executarVACUUMA operação de transferência de arquivos ocorre quando esta função é chamada, e o atraso é grande, por isso é recomendado chamar em um intervalo de tempo adequado.
Não, não, não, não.
Ele é usado para a saída de informações de depuração na coluna de informação de depuração na página de negociação ao vivo.123456, oconsole.logfunção de saída de depuração de informações na página de negociação ao vivo, e, ao mesmo tempo, criar um arquivo de log com a extensão.loge escrever informações de depuração no/logs/storage/123456/no diretório do docker ao qual pertence a negociação ao vivo, com o prefixo nome do arquivostdout_.
console.log (...msgs)
O parâmetromsgé o conteúdo da saída e o parâmetromsgpodem ser passadas mais de uma.
msg
Falso
string, number, bool, object, array, null e outros tipos suportados pelo sistema.
function main() {
console.log("test console.log")
}
# Not supported
// Not supported
JavaScriptA linguagem suporta esta função.[object Object], por isso tente produzir o maior número possível de informações legíveis.Não, não, não, não.
Usado para saída de erro no campo 123456, oconsole.errorfunção cria um arquivo de log com a extensão.logem/logs/storage/123456/diretório do docker onde o comércio ao vivo pertence, e escreve a saída de erro com o prefixostderr_.
Console.error ((...msgs)
O parâmetromsgé o conteúdo da saída e o parâmetromsgpodem ser passadas mais de uma.
msg
Falso
string, number, bool, object, array, null e outros tipos suportados pelo sistema.
function main() {
console.error("test console.error")
}
# Not supported
// Not supported
JavaScriptA linguagem suporta esta função.[object Object], por isso tente produzir o maior número possível de informações legíveis.Não, não, não, não.
Obter a estrutura {@struct/Ticker Ticker} do local ou contrato correspondente ao par de negociação atualmente definido, código do contrato, ou seja, os dados do ticker.GetTicker ()função é uma função membro do objeto de troca {@var/EXCHANGE exchange}, o uso deexchangefunções (métodos) de membros de objeto relacionadas apenas comexchange, e não será repetido no documento.
Oexchange.GetTicker()A função retorna a estrutura {@struct/Ticker Ticker} quando a solicitação de dados é bem-sucedida e retorna o valor nulo quando a solicitação de dados falha.
{@struct/Ticker Ticker}, valor nulo
troca.GetTicker ((() troca.GetTicker (símbolo)
O parâmetrosymbolÉ utilizado para especificar o par de negociação específico e o código do contrato correspondente aos dados {@struct/Ticker Ticker} solicitados.
Ao ligar para oexchange.GetTicker(symbol)função,exchangeSe você precisar solicitar dados de mercado com a moeda denominada como USDT e a moeda de negociação como BTC, o parâmetrosymbolé:"BTC_USDT", e o formato é o formato dos pares de negociação definido pela plataforma FMZ.
Ao ligar para oexchange.GetTicker(symbol)função,exchangeSe você precisa solicitar os dados de mercado do contrato perpétuo padrão U do BTCsymbolé:"BTC_USDT.swap", e o formato é uma combinação dospar de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelo símbolo exchange.GetTicker(symbol)função,exchangeSe você precisar solicitar os dados de mercado do contrato de opção U-standard do BTCsymbolé:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo), o formato é a combinação dopar de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter
símbolo Falso cordel
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);
}
Para os objectos de troca de futuros (ou seja,exchangeouexchanges[0]), é necessário definir o código do contrato utilizando oexchange.SetContractType()função antes de chamar a função ticker, que não será repetida.
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);
}
Utilize osymbolParâmetro para solicitar dados de mercado para um símbolo específico (símbolo spot).
OTickerdados devolvidos peloexchange.GetTicker()O sistema de backtesting é um sistema de testes de desempenho.HigheLowOs valores simulados são os valores tomados da venda e da compra no mercado nesse momento.Tickerdados devolvidos peloexchange.GetTicker()O mercado real é o mercado em que aHigheLowvalores são baseados nos dados devolvidos pela troca encapsuladaTickInterface, que inclui os preços mais altos e mais baixos dentro de um determinado período (normalmente um período de 24 horas).
As trocas que não suportam oexchange.GetTicker()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetTicker | – | Futuros_Aevo |
{@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTickers exchange.GetTickers}
Obter a estrutura {@struct/Depth Depth} do local ou contrato correspondente ao par de negociação atualmente definido, código do contrato, ou seja, dados da carteira de ordens.
Oexchange.GetDepth()A função retorna a estrutura {@struct/Depth Depth} se a solicitação de dados for bem-sucedida e retorna nulo se a solicitação de dados falhar.
{@struct/Depth Depth}, valor nulo
troca.GetDepth ((() troca.GetDepth (símbolo)
O parâmetrosymbolé usado para especificar o par de negociação específico e o código do contrato correspondente aos dados {@struct/Depth Depth} solicitados. Se este parâmetro não for passado, os dados do livro de ordens do par de negociação atualmente definido e o código do contrato serão solicitados por padrão.exchange.GetDepth(symbol)função,exchangeSe você precisar solicitar para obter os dados da carteira de ordens com a moeda denominada como USDT e a moeda da transação como BTC, o parâmetrosymbolé:"BTC_USDT", e o formato é o formato do par de negociação definido pela plataforma FMZ.exchange.GetDepth(symbol)função,exchangeSe você precisa solicitar os dados do livro de pedidos do contrato perpétuo padrão U do BTCsymbolé:"BTC_USDT.swap", e o formato é uma combinação dospar de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelo carácter exchange.GetDepth(symbol)função,exchangeSe você precisar solicitar os dados do livro de ordens do contrato de opção U-standard do BTCsymbolé:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo), o formato é a combinação dopar de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter
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);
}
Testeexchange.GetDepth()Função:
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);
}
Quando o configuradoexchangeObjeto é um objeto de troca de futuros, usar osymbolParâmetro para solicitar os dados do livro de ordens de um símbolo específico (símbolo de futuros).
No sistema de backtesting, os dados de cada grau são devolvidos peloexchange.GetDepth()função quando se utiliza oSimulação de TicO sistema de backtesting é um sistema de simulação de valores.exchange.GetDepth()função quando se utiliza oCarrapatos reaisO backtesting é um instante profundo de segundo nível.
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
Obter a matriz de estrutura {@struct/Trade Trade} do ponto ou contrato correspondente ao par de negociação atualmente definido, código do contrato, ou seja, os dados da transação de mercado.
Oexchange.GetTrades()A função retorna uma matriz de estruturas {@struct/Trade Trade} se a solicitação de dados for bem-sucedida e retorna valores nulos se a solicitação de dados falhar.
{@struct/Trade Trade} matrizes, valores nulos
Troca.GetTrades ((() troca.GetTrades (símbolo)
O parâmetrosymbolé usado para especificar o par de negociação específico e o código do contrato correspondente aos dados de matriz {@struct/Trade Trade} solicitados. Se este parâmetro não for passado, os dados de registro de transação mais recentes do par de negociação atualmente definido e o código do contrato serão solicitados por padrão.exchange.GetTrades(symbol)função,exchangeSe você precisar solicitar para obter os dados da carteira de ordens com a moeda denominada como USDT e a moeda de negociação como BTC, o parâmetrosymbolé:"BTC_USDT", e o formato é o formato do par de negociação definido pela plataforma FMZ.exchange.GetTrades(symbol)função,exchangeSe você precisa solicitar os dados do livro de pedidos do contrato perpétuo padrão U do BTCsymbolé:"BTC_USDT.swap", e o formato é uma combinação dospar de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelo carácter exchange.GetTrades(symbol)função,exchangeSe você precisar solicitar os dados do livro de ordens do contrato de opção U-standard do BTCsymbolé:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo), o formato é a combinação dopar de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter
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);
}
Teste oexchange.GetTrades()Função:
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);
}
Quando o configuradoexchangeObjeto é um objeto de troca de futuros, usar osymbolParâmetro para solicitar dados de registo de transacções de mercado para um símbolo específico (símbolo de futuros).
exchange.GetTrades()A função para obter os pares de negociação atuais, o histórico de transações do mercado (não o seu próprio) correspondente aos contratos. Algumas bolsas não suportam essa função, e os dados específicos retornados é quanto do intervalo de registros de transações depende da troca e precisa ser manuseado de acordo com a situação específica.exchange.GetRecords ()A função retorna a mesma ordem de dados, ou seja, o último elemento da matriz é o dado mais próximo do tempo atual.
Oexchange.GetTrades()função retorna uma matriz vazia ao usarSimulação de TicOs dados devolvidos pelo sistema de backtesting são os dados de base de dados que o sistema de backtesting retorna.exchange.GetTrades()Função no momento da utilizaçãoCarrapatos reaisO backtesting no sistema de backtesting é os dados instantâneos do fluxo de ordens, ou seja, a matriz de estrutura {@struct/Trade Trade}.
As trocas que não suportam oexchange.GetTrades()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetTrades | – | Futures_BitMart / Futures_Bibox |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}
Obter a matriz de estrutura {@struct/Record Record} do ponto ou contrato correspondente ao par de negociação atualmente definido, código do contrato, ou seja, dados de linha K.
Oexchange.GetRecords()A função retorna uma matriz de estruturas {@struct/Record Record} quando a solicitação de dados é bem-sucedida e retorna valores nulos quando a solicitação de dados falha.
{@struct/Record Record} matrizes, valores nulos
troca.GetRecords ((() Troca.GetRecords (símbolo) exchange.GetRecords (símbolo, ponto) exchange.GetRecords (símbolo, ponto, limite) troca.GetRecords (período) troca.GetRecords (período, limite)
O parâmetrosymbolé usado para especificar o par de negociação específico e o código do contrato correspondente aos dados de matriz {@struct/Record Record} solicitados. Se este parâmetro não for passado, os dados da linha K do par de negociação atualmente definido e o código do contrato serão solicitados por padrão.exchange.GetRecords(symbol)função,exchangeSe você precisar solicitar para obter os dados com a moeda denominada como USDT e a moeda da transação como BTC, o parâmetrosymbolé:"BTC_USDT", e o formato é o formato do par de negociação definido pela plataforma FMZ.exchange.GetRecords(symbol)função,exchangeSe você precisa solicitar os dados do livro de pedidos do contrato perpétuo padrão U do BTCsymbolé:"BTC_USDT.swap", e o formato é uma combinação dospar de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelo carácter exchange.GetRecords(symbol)função,exchangeSe você precisar solicitar os dados do livro de ordens do contrato de opção U-standard do BTCsymbolé:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo), o formato é a combinação dopar de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter periodespecifica o período dos dados de linha K solicitados, por exemplo: {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15}, etc. O valor do parâmetroperiodSe este parâmetro não for passado, o período dos dados de linha K solicitados por padrão é o período de linha K padrão da configuração atual de estratégia em tempo real / backtest.
período
Falso
Número
O parâmetrolimité usado para especificar o comprimento dos dados de linha K solicitados. Se esse parâmetro não for passado, o comprimento de solicitação padrão é o número máximo de barras de linha K solicitadas em um momento da interface de linha K de troca. Este parâmetro pode causar a busca para consultar os dados de linha K de troca e o consumo de tempo da chamada de função aumentará durante a consulta de busca.
limite
Falso
Número
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]);
}
Obtenha dados da linha K para um período personalizado.
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]);
}
Dados de barra de linha K de saída:
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);
}
Quando o configuradoexchangeObjeto é um objeto de troca de futuros, usar osymbol, period, elimitParâmetros para solicitar os dados da linha K de um produto específico (produto futuro).
O período de linha K padrão pode ser definido nas páginas de backtest e de negociação real.exchange.GetRecords()Se nenhum parâmetro for especificado quando a função for chamada, os dados de linha K correspondentes serão devolvidos de acordo com o período de linha K definido no backtest e nos parâmetros reais do mercado.
O valor de retorno é uma matriz deRecordOs dados de linha K retornados serão acumulados ao longo do tempo, o limite superior das barras de linhaexchange.SetMaxBarLen()O limite padrão é de 5000 bares quando não está definido. Quando os dados da linha K atingem o limite de acumulação da barra da linha K, eles serão atualizados adicionando uma barra da linha K e excluindo a primeira barra da linha K (por exemplo, fila de entrada/saída).TradeA utilização de um conjunto de linhas K (ou de uma matriz estruturada) em tempo real para gerar linhas K.
Se a interface K-line do exchange suportar consultas de paginação, várias solicitações de API serão feitas ao chamar oexchange.SetMaxBarLen()função para definir um maior comprimento da linha K.
Quando oexchange.GetRecords()A função é chamada inicialmente, o número de barras de linha K obtidas difere entre backtesting e negociação real: - O sistema de backtesting obterá um certo número de barras de linha K antes do início do intervalo de tempo de backtesting com antecedência (o padrão é 5000, as configurações do sistema de backtesting e a quantidade de dados afetarão o número final retornado), como os dados iniciais de linha K. - O número de barras de linha K obtidas durante a negociação real é baseado na quantidade máxima de dados que podem ser obtidos a partir da interface de linha K da bolsa.
OperiodO parâmetro é definido em 5, que é uma solicitação para obter dados de linha K com um período de 5 segundos.periodO sistema subjacente utiliza a interface relevante deexchange.GetTrades()Os dados de registo de transacções são obtidos através de um sistema de registo de transacções, que permite obter os dados de registo de transacções e sintetizar os dados de linha K necessários.periodSe o parâmetro for divisível por 60, os dados de linha K necessários são sintetizados utilizando um mínimo de dados de linha K de 1 minuto (se possível, os dados de linha K necessários são sintetizados utilizando um período maior).
O backtesting de nível simulado no sistema de backtesting requer a configuração do período de linha K subjacente (quando o sistema de backtesting simula o backtesting de nível, os dados de linha K correspondentes são usados para gerar dados Tick de acordo com o período de linha K subjacente definido).
OC++linguagem tem o seguinte exemplo de código se você precisa construir seus próprios dados de linha 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);
}
As trocas que não suportam oexchange.GetRecords()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetRecords | Zaif / Coincheck / BitFlyer | Futuros_Aevo |
{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}
Obter o período de linha K definido na página do site da plataforma de negociação FMZ Quant quando backtesting e executando a estratégia em negociação ao vivo, ou seja, o período de linha K padrão usado ao chamar oexchange.GetRecords()Função sem passar parâmetros.
Período de linha K em segundos, valor inteiro em segundos. Número
troca.GetPeriod ((()
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");
}
Não, não, não, não.
Definir o comprimento máximo da linha K.
troca.SetMaxBarLen ((n)
O parâmetroné utilizada para especificar o comprimento máximo da linha K.
n
verdade
Número
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]);
}
Oexchange.SetMaxBarLen()A função afeta dois aspectos para o tempo de execução da estratégia de criptomoedas:
Não, não, não, não.
Obter o conteúdo original devolvido pela últimarestsolicitação do objeto de troca atual ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).
Os dados de resposta para orestpedido.
cordel
troca.GetRawJSON()
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);
}
Oexchange.GetRawJSON()A função não é suportada por estratégias noC++ language.
{@var/EXCHANGE exchange}
Obter a taxa de câmbio atualmente definida para o objeto de troca.
Valor corrente da taxa de câmbio do objeto de câmbio. Número
troca.GetRate()
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());
}
Seexchange.SetRate()A taxa de conversão não foi fixada, oexchange.GetRate()A função retorna um valor de taxa padrão de 1, ou seja, os dados relacionados com a moeda atualmente exibida (quoteCurrency) não foram convertidos.
Se o valor da taxa de câmbio tiver sido definido utilizandoexchange.SetRate(), por exemplo,exchange.SetRate(7)Em seguida, todas as informações de preços, tais como cotações, profundidades e preços de encomenda obtidos através doexchangeObjeto de câmbio será convertido multiplicando pela taxa de câmbio definida7- Não.
Seexchangecorresponde a uma troca com USD como moeda denominada, após a chamadaexchange.SetRate(7), todos os preços no mercado ao vivo serão convertidos para um preço próximo do yuan7Neste ponto, o valor da taxa de câmbio obtido utilizandoexchange.GetRate()é7.
{@fun/Trade/exchange.SetRate exchange.SetRate}
Oexchange.SetData()A função é usada para definir os dados carregados quando a estratégia está em execução.
O comprimento da cadeia após o parâmetrovalueCodificação JSON.
Número
exchange.SetData ((chave, valor)
Nome da recolha de dados.
Chave
verdade
cordel
Os dados a carregar peloexchange.SetData()A estrutura de dados é a mesma que o formato de dados solicitado peloexchange.GetData()Função de solicitação de dados externos, ou seja:"schema": ["time", "data"]- Não.
Valor
verdade
matriz
/*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);
}
}
Requer que os dados para o parâmetrovalueser do mesmo formato que odataVocê pode ver que a marca de tempo1579622400000corresponde ao tempo2020-01-22 00:00:00, e que quando o programa de estratégia é executado após este tempo, chamar oexchange.GetData()função para obter os dados antes do próximo carimbo de tempo de dados1579708800000, isto é, tempo2020-01-23 00:00:00O que ganhas é[1579622400000, 123]O conteúdo desses dados, como o programa continua a ser executado, o tempo muda, e assim por diante para obter o item de dados por item. no exemplo a seguir, no tempo de execução (backtesting ou negociação ao vivo), o momento atual atinge ou excede o timestamp1579795200000, oexchange.GetData()A função é chamada e o valor de retorno é:{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000corresponde a1579795200000em dados[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]corresponde aos dados["abc", 123, {"price": 123}]]em[1579795200000, ["abc", 123, {"price": 123}]].
Os dados carregados podem ser quaisquer indicadores económicos, dados do setor, indicadores relevantes, etc., utilizados para a avaliação quantitativa da estratégia de todas as informações quantificáveis.
Não, não, não, não.
Oexchange.GetData()função é usada para obter dados carregados peloexchange.SetData()função ou fornecida por uma ligação externa.
Registros na recolha de dados. Objeto
troca.GetData (chave) Troca.GetData (chave, tempo de espera)
Nome da recolha de dados. Chave verdade cordel Usado para definir o tempo de expiração do cache em milissegundos. tempo de espera Falso Número
/*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);
}
}
A chamada para obter os dados escritos diretamente.
/*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);
}
}
Suporte para solicitar dados através de ligações externas, o formato dos dados solicitados para:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Onde?schemaé o formato de dados para cada registo no corpo dos dados carregados, que é fixado em["time", "data"]correspondente ao formato dos dados de entrada por entrada nodataatributo.
O que é armazenado nodataO atributo é o corpo dos dados, com cada entrada constituída por uma marca de tempo de nível de milissegundos e o conteúdo dos dados (que pode ser qualquer dado codificável em JSON).
O programa de serviço para testes, escrito em 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)
}
Os dados de resposta do programa após a recepção da solicitação:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Código da estratégia de ensaio:
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"));
}
Método de chamada para obter os dados de um link externo.
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"));
}
Pedir dados para uma consulta criada na plataformadados, solicitando que o formato dos dados da resposta seja (deve conter tempo, campos de dados descritos no esquema):
{
"data": [],
"schema": ["time", "data"]
}
O campo exchange.GetData()função é chamada, um objeto JSON é devolvido, por exemplo:{"Time":1579795200000, "Data":"..."}.
Obter os dados de uma só vez para backtesting e cache um minuto de dados para negociação ao vivo.from(horário em segundos),to(timestamped em segundos) para o pedido, parâmetros tais comoperiod(período de linha K subjacente, marcado em milissegundos) são utilizados para determinar o período de tempo durante o qual os dados devem ser adquiridos.
{@fun/Market/exchange.SetData exchange.SetData}
Oexchange.GetMarkets()A função é utilizada para obter informações sobre o mercado de câmbio.
Dicionário que contém a estrutura {@struct/Market Market}. Objeto
troca.GetMarkets ((()
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]);
}
Exemplo de chamada para um objeto de câmbio de futuros:
/*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() + "`");
}
Use o objeto de troca de futuros para chamar oexchange.GetMarkets()Antes de chamar qualquer função de mercado, o GetMarkets retorna apenas os dados de mercado do par de negociação padrão atual. Depois de chamar a função de mercado, retorna os dados de mercado de todas as variedades solicitadas. Você pode se referir ao seguinte exemplo de teste:
Oexchange.GetMarkets()função retorna um dicionário com uma chave denominada o nome da variedade comercial e para as correções spot formatadas como um par comercial, por exemplo:
{
"BTC_USDT" : {...}, // The key value is the Market structure
"LTC_USDT" : {...},
...
}
Para as trocas de contratos futuros, uma vez que podem existir vários contratos para uma única variedade, por exemplo:BTC_USDTOs contratos perpétuos, os contratos trimestrais e assim por diante.exchange.GetMarkets()A função retorna um dicionário com o nome da chave do par combinado com o código do contrato, por exemplo:
{
"BTC_USDT.swap" : {...}, // The key value is the Market structure
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()Função suporta negociações ao vivo, sistema de backtesting.exchange.GetMarkets()A função devolve informações de mercado apenas para as variedades que são negociadas on-line na bolsa.exchange.GetMarkets()A função não suporta contratos de opções.As trocas que não suportam oexchange.GetMarkets()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetMarkets | Coincheck / Bithumb / BitFlyer | – |
{@struct/Mercado Mercado}
Oexchange.GetTickers()A função é utilizada para obter dados de ticker agregados de troca (a matriz da estrutura {@struct/Ticker Ticker}).exchangeRetorna dados de ticker para todos os pares de negociação quando se trata de um objeto de troca à vista;exchangeRetorna dados de ticker para todos os contratos quando se trata de um objeto de troca de futuros.
Oexchange.GetTickers()função retorna uma matriz de estruturas {@struct/Ticker Ticker} quando consegue solicitar dados, e nulo quando falha.
{@struct/Ticker Ticker} matrizes, valores nulos
troca.GetTickers ((()
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());
}
}
Ligue para oexchange.GetTickers()Função de obtenção de dados de mercado agregados.
/*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() + "`");
}
Utilize o objeto de troca spot e chame oexchange.GetTickers()Antes de chamar qualquer função de mercado, o GetTickers retorna apenas os dados do ticker do par de negociação padrão atual. Depois de chamar a função de mercado, retorna os dados do ticker de todas as variedades solicitadas. Você pode se referir ao exemplo de teste a seguir:
As trocas que não suportam oexchange.GetTickers()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetTickers | Zaif / WOO / Gemini / Coincheck / BitFlyer / Bibox | Futures_WOO / Futures_dYdX / Futures_Deribit / Futures_Bibox / Futures_Aevo |
Não, não, não, não, não.
Oexchange.Buy()A função é utilizada para colocar ordens de compra.Buy()função é uma função membro do objeto de troca {@var/EXCHANGE exchange}.Buy()função opera na conta de câmbio ligada ao objeto de câmbioexchangeO objectivo das funções (métodos) dos membros doexchangeObjeto está relacionado apenas comexchange, e não será repetido após a documentação.
Uma ordem bem-sucedida retorna o ID da ordem, uma ordem falhada retorna um valor nulo.
O atributoIdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato do par de negociação à vistaETH_USDTa ordem da troca OKX é:ETH-USDT,1547130415509278720- Não.
Ao ligar para oexchange.Buy()função para colocar uma ordem, a ordem de valor de retornoIdé consistente com oIdAtributo da estrutura da ordem {@struct/Order Order}.
string, valor nulo
troca.Comprar ((preço, montante) troca.Comprar ((preço, quantidade,...args)
OpriceO parâmetro é utilizado para definir o preço da ordem.
Preço
verdade
Número
OamountParâmetro utilizado para definir o montante da encomenda.
quantidade
verdade
Número
Parâmetros estendidos que podem fornecer informações de acompanhamento para este diário de encomendas,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
O número de ordem devolvido porexchange.Buy()Pode ser utilizado para consultar as informações da encomenda e cancelar a encomenda.
// 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);
}
Quando se faz uma encomenda para um contrato de futuros de criptomoedas, deve ser tomado cuidado para garantir que a direção do comércio seja definida corretamente, uma vez que uma incompatibilidade entre a direção do comércio e a função do comércio resultará em um erro:
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);
}
Ordem de mercado à vista.
Ao colocar uma ordem para um contrato de futuros, você deve prestar atenção se a direção do comércio está definida corretamente, pois um erro será relatado se a direção do comércio e a função do comércio não coincidirem.
O parâmetropriceestá definido em-1para a colocação de ordens de mercado, o que requer que a interface de colocação de ordens da exchange suporte ordens de mercado.amounté a quantidade de dinheiro na moeda da ordem. Ao colocar ordens de mercado para contratos futuros de criptomoeda, o parâmetro de quantidadeamounté o número de contratos. Há algumas casas de câmbio de criptomoedas que não suportam a interface de ordem de mercado durante a negociação ao vivo. A quantidade de ordem para ordens de compra de mercado em algumas casas de câmbio é o número de moedas de negociação.Instruções especiais para as trocasIddoexchange.Buy()função pode ser diferente do valor de retorno da ordemIdDescrito no documento actual.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Oexchange.Sell()Função utilizada para colocar ordens de venda.
Uma ordem bem-sucedida retorna o ID da ordem, uma ordem falhada retorna um valor nulo.IdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato do par de negociação à vistaETH_USDTa ordem da troca OKX é:ETH-USDT,1547130415509278720. Ao ligar para oexchange.Sell()função para colocar uma ordem, a ordem de valor de retornoIdé consistente com oIdAtributo da estrutura da ordem {@struct/Order Order}.
string, valor nulo
troca.Venda ((preço, montante) troca.Venda ((preço, montante,...args)
OpriceO parâmetro é utilizado para definir o preço da ordem.
Preço
verdade
Número
OamountParâmetro utilizado para definir o montante da encomenda.
quantidade
verdade
Número
Parâmetros estendidos que podem fornecer informações de acompanhamento para este diário de encomendas,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
O número de ordem devolvido porexchange.Sell()Pode ser utilizado para consultar informações de encomendas e cancelar encomendas.
// 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);
}
Quando se faz uma encomenda para um contrato de futuros de criptomoedas, deve ser tomado cuidado para garantir que a direção do comércio seja definida corretamente, uma vez que uma incompatibilidade entre a direção do comércio e a função do comércio resultará em um erro:
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);
}
Ordem de mercado à vista.
Ao colocar uma ordem para um contrato de futuros, você deve prestar atenção se a direção do comércio está definida corretamente, pois um erro será relatado se a direção do comércio e a função do comércio não coincidirem.
O parâmetropriceestá definido em-1para a colocação de ordens de mercado, o que exige que a interface de colocação de ordens da exchange suporte ordens de mercado.amounté o valor em moeda de negociação. Ao colocar ordens de mercado para contratos futuros de criptomoeda, o parâmetro de valoramountHá algumas exchanges de criptomoedas que não suportam a interface de ordem de mercado durante a negociação ao vivo.
Se você estiver usando uma versão mais antiga do docker, o valor de retorno da ordemIddoexchange.Sell()função pode ser diferente do valor de retorno da ordemIdDescrito no documento actual.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Oexchange.CreateOrder()A função é usada para fazer uma encomenda.
Se a ordem for efetuada com sucesso, o ID da ordem é devolvido; se a ordem falhar, um valor nulo é devolvido.IdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato da ordem do par de negociação à vistaETH_USDTda bolsa OKX é:ETH-USDT,1547130415509278720. Ao ligar para oexchange.CreateOrder(symbol, side, price, amount)Função para colocar uma ordem, o valor de retorno da ordemIdé consistente com oIdPropriedade da estrutura da ordem {@struct/Order Order}.
string, valor nulo
exchange.CreateOrder (símbolo, lado, preço, quantia) exchange.CreateOrder ((símbolo, lado, preço, quantidade,...args)
O parâmetrosymbolO código da ordem é utilizado para especificar o par de negociação específico e o código do contrato da ordem.exchange.CreateOrder(symbol, side, price, amount)função de encomenda,exchangeSe a moeda denominada da ordem for USDT e a moeda de transacção for BTC, o parâmetrosymbolé:"BTC_USDT", no formato do par de negociação definido pela plataforma FMZ.exchange.CreateOrder(symbol, side, price, amount)função de encomenda,exchangeé o objeto de troca de futuros. Se a ordem for uma ordem de contrato perpétuo padrão BTCsymbolé:"BTC_USDT.swap", e o formato é uma combinação dospar de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelo carácter exchange.CreateOrder(symbol, side, price, amount)função de encomenda,exchangeé o objeto de troca de futuros. Se a ordem for uma ordem de contrato de opção U-standard do BTCsymbolé:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo), e o formato é uma combinação dopar de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter sideO parâmetro é utilizado para especificar a direção de negociação da ordem.
Para os objectos de troca à vista, os valores facultativos dosideOs parâmetros são:buy, sell. buysignifica compra, esellsignifica vender.
Para os objectos de troca de futuros, os valores opcionais dosideOs parâmetros são:buy, closebuy, sell, closesell. buysignifica abrir uma posição longa,closebuysignifica fechar uma posição longa,sellsignifica abrir uma posição curta, eclosesellsignifica fechar uma posição curta.
lado
verdade
cordel
O parâmetropriceO preço de -1 indica que a ordem é de mercado.
Preço
verdade
Número
O parâmetroamountA quantidade de ordem é a quantidade da ordem de compra de mercado de algumas bolsas spot, que é o número de moedas de negociação.Instruções especiais para as trocasno argOs parâmetros podem ser transmitidos.
arg
Falso
Qualquer tipo suportado pelo sistema, como cadeia, número, bool, objeto, matriz, valor nulo, 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);
}
Os objectos de troca spot e os objetos de troca de futuros chamam-se deexchange.CreateOrder()Função para fazer uma encomenda.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
Oexchange.CancelOrder()A função é usada para cancelar a ordem.
O atributoIdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato da ordem do par de negociação à vistaETH_USDTda bolsa OKX é:ETH-USDT,1547130415509278720- Não.
O parâmetroorderIdPassado em quando chamar oexchange.CancelOrder()A função para cancelar uma ordem é consistente com oIdPropriedade da estrutura da ordem {@struct/Order Order}.
Oexchange.CancelOrder()função retorna um valor verdadeiro, por exemplotruesignifica que a solicitação de ordem de cancelamento foi enviada com sucesso.false, significa que o pedido de ordem de cancelamento não foi enviado. O valor devolvido representa apenas o sucesso ou fracasso do pedido enviado para determinar se a troca cancela a ordem.exchange.GetOrders()Para determinar se a ordem é cancelada.
Bool
troca.Cancelar encomenda ((identificação da encomenda) troca.Cancelar encomenda ((identificação da encomenda,... args)
OorderIdO parâmetro é utilizado para especificar a ordem a cancelar.
Ordenado
verdade
número, cadeia
Parâmetros estendidos, você pode exportar as informações anexadas a este registro de retirada,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
Cancele a ordem.
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);
}
}
Funções FMZ API que podem produzir funções de saída de log como:Log(), exchange.Buy(), exchange.CancelOrder()podem ser seguidos por alguns parâmetros de saída de acompanhamento após os parâmetros necessários.exchange.CancelOrder(orders[i].Id, orders[i]), de modo que, ao cancelar a encomenda cujo ID éorders[i].Id, a informação da ordem é produzida com ele.orders[i].
Se estiver a utilizar uma versão mais antiga do docker, o parâmetro orderId da função exchange.CancelOrder() pode ser diferente do orderId descrito no documento actual.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
Oexchange.GetOrder()A função é utilizada para obter as informações de encomenda.
Consultar os detalhes da ordem de acordo com o número da ordem e retornar a estrutura {@struct/Order Order} se a consulta for bem sucedida, ou retornar null se a consulta falhar. {@struct/Order Order}, valor nulo
troca.GetOrder (identificação de ordem)
OorderIdO parâmetro é utilizado para especificar a ordem a ser consultada.
O atributoIdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato da ordem do par de negociação à vistaETH_USDTda bolsa OKX é:ETH-USDT,1547130415509278720- Não.
O parâmetroorderIdPassado em quando chamar oexchange.GetOrder()função para consultar uma ordem é consistente com oIdPropriedade da estrutura da ordem {@struct/Order Order}.
Ordenado verdade cordel
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);
}
Oexchange.GetOrder()A função não é suportada por algumas trocas.AvgPriceO atributo na estrutura {@struct/Order Order} do valor de retorno é o preço médio da transação.
Se você estiver usando uma versão mais antiga do docker, oorderIdParâmetro doexchange.GetOrder()A sua função pode diferir daorderIddescrito na documentação actual.
As trocas que não suportam oexchange.GetOrder()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetOrder | Zaif / Coincheck / Bitstamp | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Oexchange.GetOrders()A função é usada para obter encomendas pendentes.
Oexchange.GetOrders()A função retorna uma matriz de estruturas {@struct/Order Order} se a solicitação de dados for bem-sucedida, e retorna valores nulos se a solicitação de dados falhar.
{@struct/Order Order} matriz, valor nulo
troca.GetOrders ((() Troca.GetOrders (símbolo)
O parâmetrosymbolé utilizado para definir osímbolo da transacçãoouIntervalo de símbolos de transacçãoPara ser interrogado.
Para os objectos de troca à vista, se osymbolSe o parâmetro não for transmitido, serão solicitados os dados de encomenda incompletos de todos os produtos spot.
Para os objectos de troca de futuros, se osymbolSe o parâmetro não for transmitido, o padrão é solicitar os dados de ordem incompletos de todas as variedades na faixa de dimensões do par de negociação atual e do código do contrato.
símbolo Falso cordel
/*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;
}
Utilize o objeto de troca à vista para colocar ordens de compra para vários pares de negociação diferentes à metade do preço atual e, em seguida, consultar as informações sobre ordens pendentes.
/*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;
}
Usar objetos de troca de futuros para colocar ordens para vários pares de negociação diferentes e códigos de contrato. Colocar ordens a preços longe do preço da contraparte, manter ordens em um estado não cumprido e consultar ordens de várias maneiras.
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);
}
Ao ligar para oexchange.GetOrders()função, passar noSymbolParâmetro para solicitar dados de ordem para um par de negociação específico e código de contrato.
EmGetOrdersfunção, os cenários de utilização do parâmetro símbolo são resumidos do seguinte modo:
| Classificação do objeto Exchange | símbolo Parâmetros | Alcance da consulta | Observação |
|---|---|---|---|
| Espetáculo | Não passe o parâmetro de símbolo | Consultar todos os pares de negociação spot | Para todos os cenários de chamada, se a interface de troca não o suportar, um erro será relatado e um valor nulo será devolvido. |
| Espetáculo | Especificar o tipo de negociação, o parâmetro do símbolo é: |
Consultar o par de negociação BTC_USDT especificado | Para os objetos de câmbio à vista, o formato do parâmetro do símbolo é: |
| Futuros | Não passe o parâmetro de símbolo | Consultar todos os produtos de negociação dentro do intervalo de dimensões do par de negociação e do código do contrato corrente | Se o par de negociação atual for BTC_USDT e o código do contrato for swap, todos os contratos perpétuos com margem USDT serão consultados.GetOrders("USDT.swap") |
| Futuros | Especificar o tipo de negociação, o parâmetro do símbolo é: |
Consultar o contrato perpétuo baseado em USDT para um determinado BTC | Para os objectos de troca de futuros, o formato do símbolo do parâmetro é:par de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelos caracteres".. |
| Futuros | Especificar a gama de produtos de negociação, o parâmetro do símbolo é: |
Consultar todos os contratos perpétuos baseados em USDT | - |
| Bolsas de futuros que suportam opções | Não passe o parâmetro de símbolo | Consultar todos os contratos de opção dentro do intervalo de dimensão do par de negociação corrente | Se o par de negociação atual for BTC_USDT, o contrato é definido como um contrato de opção, por exemplo, contrato de opção da Binance: BTC-240108-40000-C |
| Bolsas de futuros que suportam opções | Especificar produtos comerciais específicos | Consultar o contrato de opção especificado | Por exemplo, para a Binance Futures Exchange, o parâmetro do símbolo é: BTC_USDT.BTC-240108-40000-C |
| Bolsas de futuros que suportam opções | Especificar a gama de produtos de negociação, o parâmetro do símbolo é: |
Consultar todos os contratos de opções baseados em USDT | - |
EmGetOrdersfunção, a consulta do objeto de troca de futuros
A gama de dimensões é resumida do seguinte modo:
| símbolo Parâmetros | Definição do intervalo de solicitação | Observação |
|---|---|---|
| USDT.swap | Intervalo de contratos perpétuos baseados em USDT. | Para |
dimensões não suportadas pela interface de API de troca, um erro será relatado e um valor nulo será devolvido quando Está a chamar-me. ♫ USDT.futures ♫ ♫ uma gama de contratos de entrega baseados em USDT ♫ O USD.swap é uma variedade de moeda baseada em perpétuos Contratos. USD.futures. Variação de entrega baseada em moeda. Contratos. O opção baseada em opções de contrato baseado em USDT. O que é que é uma opção? Combo USDT.futures. Uma gama de combinações de CFD. Futures_Deribit Exchange USD.futures_ff Uma gama de contratos de entrega de margem mista. Futures_Kraken Exchange. USD.swap_pf Uma gama de contratos perpétuos de margem mista. Futuros_Kraken Exchange.
Quando a conta representada pelo objecto de trocaexchangeNão tem ordens pendentes nointervalo de consultaouInstrumentos de negociação especificados(ordens ativas em um estado não cumprido), chamando esta função retorna uma matriz vazia, ou seja:[]- Não.
As seguintes trocas exigem que o instrumento passe no parâmetro do instrumento ao consultar as ordens atualmente incompletas. Ao chamar a função GetOrders com essas trocas, se o parâmetro do instrumento não for passado, apenas as ordens incompletas do instrumento atual são solicitadas, não as ordens incompletas de todos os instrumentos (porque a interface de troca não suporta isso).
Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE.
As trocas que não suportam oexchange.GetOrders()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetOrders | – | Futures_Bibox |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Oexchange.GetHistoryOrders()A função é utilizada para obter o par de negociação actual, as ordens históricas para contratos; suporta a especificação de variedades de negociação específicas.
Oexchange.GetHistoryOrders()função retorna uma matriz de estruturas {@struct/Order Order} se a solicitação de dados for bem-sucedida, e nulo se a solicitação falhar.
{@struct/Order Order} matrizes, valores nulos
troca.GetHistoryOrders ((() troca.GetHistoryOrders (símbolo) exchange.GetHistoryOrders (símbolo, desde) exchange.GetHistoryOrders (símbolo, desde, limite) troca.GetHistoryOrders (desde) exchange.GetHistoryOrders (desde, limite)
OsymbolPara a definição do símbolo comercial, o parâmetro é utilizado para especificar o símbolo comercial.BTC_USDTOs dois tipos de transacções são os seguintes:exchangeé um objeto de troca spot, o formato do parâmetro parasymboléBTC_USDTSe se tratar de um objecto de troca de futuros, tendo por exemplo um contrato perpétuo, o formato do parâmetro parasymbolé:BTC_USDT.swap- Não.
Se você está consultando os dados de ordem de contratos de opção, definir o parâmetrosymbolpara"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo).par de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter
símbolo
Falso
cordel
OsinceO parâmetro é utilizado para especificar a data de início da consulta em milissegundos.
Desde
Falso
Número
OlimitO parâmetro é utilizado para especificar o número de ordens a consultar.
limite
Falso
Número
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, limitQuando os parâmetros não são especificados, a consulta padrão é o par de negociação atual, as ordens históricas de contrato.symbolSe o parâmetro for especificado, consultar o histórico de ordens para o tipo de negociação definido.sinceParâmetro é especificado, consulta na direção do tempo atual usando osinceMarcar a hora como a hora de início.limitSe o parâmetro for especificado, a consulta é devolvida após um número suficiente de entradas.As trocas que não suportam oexchange.GetHistoryOrders()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| Ordens do GetHistory | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | Futures_dYdX / Futures_Bibox / Futures_ApolloX |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
exchange.SetPrecision()A função é utilizada para definir a precisão doexchangeObjeto de trocaPreçoemontante da encomenda, após a definição, o sistema irá ignorar automaticamente os dados em excesso.
-Precisação (preço, quantidade)
OpricePrecisionO parâmetro é utilizado para controlar a precisão dos dados de preços.
PreçoPrecisione
verdade
Número
OamountPrecisionParâmetro utilizado para controlar a precisão da quantidade de dados a ordenar.
quantidadePrecisione
verdade
Número
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);
}
O sistema de backtesting não suporta esta função e a precisão numérica do sistema de backtesting é manipulada automaticamente.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
Definir a taxa de câmbio corrente do objeto de câmbio.
Taxa de câmbio.SetRate (Taxa)
OrateO parâmetro é utilizado para especificar a taxa de câmbio de conversão.
taxa
verdade
Número
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);
}
Se o valor da taxa de câmbio tiver sido fixado utilizando oexchange.SetRate()Em seguida, todas as informações de preço, tais como tickers, profundidades, preços de encomenda, etc para a troca representada pela correnteexchangeO objeto de câmbio será convertido multiplicando-o pela taxa de câmbio definida de 7.exchangeé uma troca com o dólar dos EUA como moeda nominal.exchange.SetRate(7), todos os preços no mercado em tempo real serão convertidos em preços próximos deCNYdenominatória multiplicada por 7.
Não, não, não, não.
Oexchange.IO()A função é utilizada para outras chamadas de interface relacionadas com o objeto de troca.
Oexchange.IO()função chama outras interfaces relacionadas com o objeto de troca, devolvendo os dados de resposta solicitados em uma chamada bem-sucedida e devolve nulo em uma chamada falhada.
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
exchange.IO(k,...args)
OkParâmetro utilizado para definir o tipo de chamada, com valores opcionais"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiede assim por diante.
k
verdade
cordel
Parâmetros estendidos, transmitidos de acordo com o cenário de chamada específico,argO mecanismo polimórfico do sistema permite que os parâmetros possam ser passados para mais de um.exchange.IO()O número e o tipo de parâmetros para oexchange.IO()Funções são indeterminadas.
arg
verdade
string, number, bool, object, array, null e quaisquer outros tipos suportados pelo sistema
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);
}
Utilizando oexchange.IO("api", httpMethod, resource, params, raw)Convocatóriaexchange.IO()Para que você possa usar a função, é necessário entender a interface API da troca e verificar a documentação relevante primeiro.POSTsolicitação não requer que você se preocupe com a criptografia, assinatura ou verificação dos parâmetros, que já são tratados pela FMZ na parte inferior, desde que você preencha os parâmetros correspondentes.Intercâmbio OKXcontratos futuros, e utilizar o parâmetrorawPara passar os parâmetros de ordem:
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);
}
Se o valor chave noparamsparameter (ou seja, Http requisit parameter) é uma cadeia, ele precisa ser escrito em aspas simples (ou seja, o símbolo ') em torno do valor do parâmetro para envolver o valor do parâmetro.
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);
}
Ele suporta passar em parâmetros de url completos, que podem omitir a operação de alternar o endereço de base (chamando oexchange.SetBase()função).
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);
}
Exemplo de chamada sem o parâmetroraw:
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());
}
Mudar o par de negociação da troca atual, de modo que ele irá mudar o par de negociação configurado por códigona criação de negociação ao vivoouem 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");
}
Para exchanges com diferentes endereços de base para a interface do ticker e a interface de negociação, por exemplo, o Bitfinex Futures tem dois endereços, um para a interface do ticker e o outro para a interface de negociação.exchange.SetBase("xxx")Os futuros da Bitfinex mudam de endereço de base de interface pública usandoexchange.IO("mbase", "xxx").
I. Para as trocas centradas em criptomoedas, outras chamadas de interface de API que não sejam uniformemente encapsuladas, com parâmetrokdefinido em"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, etc.URL.Oexchange.IO("api", httpMethod, resource, params, raw)a chamada de função acessará a interface de troca e retornará null se a chamada falhar e ocorrer um erro.
Só o mercado real suporta a chamadaexchange.IO("api", httpMethod, resource, params, raw) function.
II. Para trocas de pares de negociação, o parâmetrokestá definido em"currency":
exchange.IO("currency", currency)
moeda: O parâmetro é um tipo de cadeia de caracteres com um formato de maiúscula uniforme, utilizando um sublinhado para separarbaseCurrencydequoteCurrency, tais comoBTC_USDT.
ETH_BTCsó pode mudar paraLTC_BTC, não paraLTC_USDT.exchange.IO("currency", currency)para trocar pares de negociação.III. Utilizado para alternar o modo de conta alavancada do objecto de câmbio spot de criptomoedas:
kestá definido em"trade_margin"Para colocar ordens e obter ativos da conta, será acessada a interface de alavancagem spot da bolsa.
Se a bolsa distinguir entre margem total e margem isolada na alavancagem spot, utilizar:exchange.IO("trade_super_margin")A transição para a margem total para a conta alavancada, eexchange.IO("trade_margin")Para a transferência para a margem isolada para a conta alavancada.kestá definido em"trade_normal"para voltar ao modo normal de conta à vista.Bolsas à vista que suportam a troca entre modelos de contas alavancadas:
| Intercâmbio | Observações especiais |
|---|---|
| OKX | Os pares de negociação no modo de conta alavancada são diferentes dos normais, alguns pares de negociação podem não tê-los.exchange.IO("trade_super_margin")para mudar para a posição completa para as contas alavancadas e utilizarexchange.IO("trade_margin")para mudar de posição em posição.trade_normalpara mudar para o modo normal de localização.exchange.IO("tdMode", "cross")Para especificar directamente o modo de alavancagem. |
| Huobi | Os pares de negociação no modo de conta alavancada são diferentes dos normais, alguns pares de negociação podem não tê-los.trade_marginpara mudar para posição de conta de alavancagem por posição, utilizartrade_super_marginpara mudar para a posição total da conta de alavancagem.trade_normalpara mudar para o modo normal moeda-moeda. |
| Binance | O modo de conta alavancada é dividido em posição por posição e posição total, utilizaçãotrade_marginpara mudar para posição por posição, usartrade_super_marginpara mudar para a posição completa, utilizartrade_normalpara mudar para o modo normal moeda-moeda. |
| Portão | O modo de conta alavancada é dividido em posição por posição e posição total, utilizaçãotrade_marginpara mudar para posição por posição, usartrade_super_marginpara mudar para a posição completa, utilizartrade_normalpara mudar para o modo normal moeda-moeda. |
| AscendEx | Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta de alavancagem eexchange.IO("trade_normal")para voltar ao modo de conta normal. |
| O quê? | Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta de alavancagem eexchange.IO("trade_normal")para voltar ao modo de conta normal. |
| CoinEx | Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta alavancada eexchange.IO("trade_normal")para voltar ao modo de conta normal. |
Outras funções de comutação:Veja oexchange.IO()função paraOutras funções de comutaçãono Guia do Utilizador.
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
Oexchange.Log()A função é usada para extrair o log de colocação e retirada de ordens na área da coluna de log. Quando chamada, nenhuma ordem é colocada, apenas o log de transações é extraído e registrado.
troca.Log ((ordem) Tipo, preço, montante) troca.Log ((ordem) Tipo, preço, montante,... args)
OorderTypeO parâmetro é utilizado para definir o tipo de log de saída, os valores opcionais são {@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}.
ordem Tipo
verdade
Número
OpriceO parâmetro é utilizado para definir o preço exibido no log de saída.
Preço
verdade
Número
OamountO parâmetro é utilizado para definir a quantidade de encomendas realizadas exibidas no diário de saída.
quantidade
verdade
Número
Parâmetros estendidos que podem fornecer informações de acompanhamento a este registo,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
Utilizaçãoexchange.Log(orderType, price, amount)Um dos cenários mais comuns é usar o {@fun/Trade/exchange.IOexchange.IO} função para aceder à interface do exchange para criar ordens condicionais, mas utilizando oexchange.IO()A função não produz as informações do registro de transacções no registro de negociação ao vivo.exchange.Log()A função pode ser utilizada para complementar o diário de saída, a fim de registar as informações sobre a colocação de ordens, e o mesmo se aplica às operações de retirada de ordens.
Quando oorderTypeParâmetro éLOG_TYPE_CANCEL, opriceParâmetro é a ordem Id da ordem retirada, que é utilizada para imprimir o diário de retirada quando a ordem é retirada diretamente usando oexchange.IO()Aexchange.Log()função é uma função membro do objeto de troca {@var/EXCHANGE exchange}, em contraste com a função global {@fun/Log Log}.
O número de pessoas que participam no processo de aquisição é o número de pessoas que participam no processo de aquisição.
Oexchange.Encode()A função é utilizada para cálculos de encriptação de assinatura.
Oexchange.Encode()Função que retorna a codificação do valor hash calculado.
cordel
exchange.Encode ((algo, inputFormat, outputFormat, dados) exchange.Encode ((algo, inputFormat, outputFormat, dados, chaveFormat, chave)
O parâmetroalgoé o algoritmo usado para o cálculo de codificação. As configurações suportadas são: algotambém suporta: algotambém suporta: algopode ser escrito como ed25519.seedCalculo.
algo
verdade
cordel
Utilizado para especificar o formato de dados dodataParâmetro.inputFormatParâmetro pode ser definido para um dos seguintes: hexcodificado, base64codificado, e outputFormatO parâmetro suporta as seguintes configurações: hexcodificado, base64codificado, e datasão os dados a processar.
dados
verdade
cordel
Utilizado para especificar o formato de dados dokeyParâmetro.keyParâmetro pode ser definido para um dos seguintes: hexcodificado, base64codificado, e keyParâmetro é usado para especificar a chave usada no cálculo da assinatura, e pode ser usado como uma cadeia de texto simples."{{accesskey}}", "{{secretkey}}"referir-se aoaccessKeyesecretKeyConfigurado no objeto de troca {@var/EXCHANGE exchange}.
Chave
Falso
cordel
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"];
}
}
}
Exemplo de push de mudança de posição do BitMEX (protocolo wss):
Só o mercado real suporta chamadasexchange.Encode()A"{{accesskey}}", "{{secretkey}}"As referências só são válidas quando oexchange.Encode()função é utilizada.
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
As funções de suporte assíncrono multi-threaded podem transformar as operações de todas as funções suportadas em execução simultânea assíncrona.
Oexchange.Go()função retorna um objeto simultâneo imediatamente, e você pode usar owait()método desse objeto concorrente para obter o resultado da solicitação concorrente.
Objeto
Método de troca. troca.Go (método,...args)
OmethodO parâmetro é usado para especificar o nome da função concorrente.
Método
verdade
cordel
Parâmetros paraFunções executadas simultaneamente, pode haver mais de um parâmetroargTipo e número de parâmetrosargDepende dos parâmetros dofunção de execução simultânea- Não.
arg
Falso
string, number, bool, object, array, function, null e todos os outros tipos suportados pelo sistema
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()exemplo de utilização de funções, para determinarundefinedpara utilizartypeof(xx) === "undefined", porquenull == undefinedé válido em 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);
}
Chamando owait()método em um objeto simultâneo que foi liberado irá relatar um erro:
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);
}
}
Acesso simultâneo a múltiplos tickers de câmbio:
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");
}
Convocatórias paraexchange.IO("api", ...)Função:
Esta função só cria tarefas de execução multi-threaded quando executadas em negociação real, o backtesting não suporta a execução de tarefas simultâneas multi-threaded (o backtesting está disponível, mas ainda é executado sequencialmente).
Após oexchange.Go()função retorna um objeto, seuwait()A função é chamada através desse objeto para obter os dados retornados pelo thread.wait()A função deve ser chamada para obter os dados antes que o thread seja liberado automaticamente.wait()O resultado do thread deve ser obtido antes que ele seja liberado automaticamente (independentemente do sucesso ou fracasso da chamada de interface para acesso simultâneo).wait()função independentemente de a execução ser bem sucedida ou fracassada, e o recurso do thread solicitado peloexchange.Go()A função deve ser liberada automaticamente pelo docker.
Owait()O método suporta um parâmetro de timeout:
Sem um parâmetro de timeout, isto é,wait(), ou com um parâmetro de timeout de 0, ou seja,wait(0). Owait()blocos de função e espera até que o thread concorrente tenha terminado de executar, devolvendo o resultado da execução do thread concorrente.
Defina o parâmetro de timeout -1, ou seja,wait(-1). Owait()função retorna imediatamente, com diferentes valores de retorno para diferentes linguagens de programação, ver esta subseção para um exemplo de chamada.
Configure o parâmetro de tempo limite específico,wait(300), e owait()A função irá esperar no máximo 300 milissegundos antes de retornar.
Se o resultado de retorno do finalwait()Função não é obtida, os recursos do thread não serão liberados automaticamente, o que levará ao acúmulo de threads solicitados e mais de 2000 irá relatar um erro:"too many routine wait, max is 2000"- Não.
Funções suportadas:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Todas estas funções são executadas com base no objeto de troca {@var/EXCHANGE exchange} atual quando chamados simultaneamente.
A diferença entre a linguagem Python e a linguagem JavaScript é que owait()função de objetos concorrentes na linguagem Python retorna dois parâmetros. O primeiro parâmetro é o resultado retornado por uma chamada de API assíncrona, e o segundo parâmetro indica se a chamada assíncrona foi concluída.
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)
Não, não, não, não, não, não.
Oexchange.GetAccount()A função é utilizada para solicitar informações de conta de câmbio.GetAccount()A função é uma função membro do objeto de troca {@var/EXCHANGE exchange}.exchangeObjeto está relacionado apenas comexchange, e não será repetido após a documentação.
Consultar as informações do ativo da conta e retornar a estrutura {@struct/Account Account} se a consulta for bem-sucedida ou nula se falhar. {@struct/Account Account}, valor nulo
troca.GetAccount ((()
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"])
}
Configure pares de negociação, códigos de contrato e obtenha informações da conta corrente.
Se o objeto de troca for definido para uma troca de contratos futuros de criptomoeda e mudado para um contrato comUSDTcomo margem (ver {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} funções para como mudar).USDTA margem é registada noBalance, FrozenBalanceAtributos da estrutura {@struct/Account Account}.
Se o objeto de troca for definido para uma troca de contratos futuros de criptomoedas e mudado para um contrato baseado em moeda, o ativo está em moeda como margem e é registado noStocks, FrozenStocksAtributos da estrutura {@struct/Account Account}.
Ao usar a conta unificada do Binance Futures, ao ligar para oexchange.GetAccount()Função para solicitar informações de conta, os dados encapsulados são o montante de todos os activos convertidos emDolar americano. É exibido noBalancecampo da estrutura {@struct/Account Account}. Se precisar calcular o montante de conversão de outros ativos, pode utilizar o montante de conversão em USD dividido pelo preço do índice (do activo a converter) e depois dividido pela taxa de garantia (do activo a converter) para o calcular.
{@struct/Account Account}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
Oexchange.GetAssetsA função é utilizada para solicitar informações sobre os activos da conta de câmbio.
Oexchange.GetAssets()função retorna uma matriz de estruturas {@struct/Asset Asset} se a solicitação de dados for bem-sucedida, ou nula se a solicitação falhar.
Matriz {@struct/Asset Asset}, valor nulo
troca.GetAssets ((()
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);
}
Obter informações sobre os ativos de uma conta de câmbio,exchange.GetAssets()Retorna uma matriz com elementos da estrutura Asset.
OGetAssets()A função do objeto Futures Exchange retorna os activos de margem do par de negociação corrente (baseados em moeda, baseados em USDT, baseados em USDC, etc.).
{@struct/Asset Asset}
Oexchange.GetName()A função é usada para obter o nome da troca à qual o objeto de troca atual está vinculado.
Oexchange.GetName()A função devolve o nome da bolsa definida pela plataforma FMZ Quant Trading.
cordel
troca.GetName()
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");
}
Oexchange.GetName()A função é geralmente utilizada para identificar os objetos de troca, tais comoexchangeouexchanges[1], exchanges[2]Os nomes das bolsas de contratos futuros de criptomoedas têm o prefixo fixoFutures_.
Não, não, não, não.
Oexchange.GetLabel()função é usada para obter o rótulo personalizado que foi definido quando o objeto de troca foi configurado.
Oexchange.GetLabel()função retorna o rótulo personalizado que foi definido quando o objeto de troca foi configurado.
cordel
troca.GetLabel ((()
function main() {
Log("exchange label:", exchange.GetLabel())
}
def main():
Log("exchange label:", exchange.GetLabel())
void main() {
Log("exchange label:", exchange.GetLabel());
}
Objetos de troca comoexchangeouexchanges[1], exchanges[2]no código de estratégia são identificados pela etiqueta de conjunto.
{@var/EXCHANGE exchange}
Oexchange.GetCurrency()A função é utilizada para obter o par de negociação atualmente definido.
Oexchange.GetCurrency()A função retorna o par de negociação definido pelo objeto de troca corrente {@var/EXCHANGE exchange}.
cordel
troca.GetCurrency ((()
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());
}
O formato do par de negociação é em maiúsculas de forma uniforme, utilizando sublinhas para separarbaseCurrencyequoteCurrency, tais comoBTC_USDT.
{@fun/Account/exchange.SetCurrency exchange.SetCurrency}
Oexchange.SetCurrency()A função é utilizada para alternar o par de negociação atual do objeto de troca {@var/EXCHANGE exchange}.
Câmbio.ConfiguraçãoCurrency ((currency))
OcurrencyO formato do par de negociação é em maiúsculas uniformemente, usando um ponto abaixo para separarbaseCurrencydequoteCurrency, tais comoBTC_USDT- Não.
moeda
verdade
cordel
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étodo de mudança, por favor consulte {@funexcahnge.IO}.BTC_USDTpode ser mudado paraLTC_USDT, não paraLTC_BTC.BTC_USDT, o númeroBTCé 3, o número deUSDTNeste momento, mude paraLTC_USDTImediatamente, o número de moedas de negociação é 0 após a mudança, ou seja, o número de moedasLTC_USDTO valor da conta é 0, ou seja, o número deLTCna conta é 0, e o par de negociação trocado partilha o número deUSDT, que é 10 000.Não, não, não, não.
Oexchange.GetQuoteCurrency()A função é utilizada para obter o nome da moeda denominada do par de negociação corrente, ou seja,quoteCurrency.
Oexchange.GetQuoteCurrency()A função devolve o nome da moeda denominada do par de negociação corrente.
cordel
troca.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())
}
Por exemplo: {@var/EXCHANGE exchange} exchange objectBTC_USDT, oexchange.GetQuoteCurrency()função retornaUSDT. Se o par de negociação corrente forETH_BTC, oexchange.GetQuoteCurrency()função retornaBTC.
{@fun/Account/exchange.GetCurrency exchange.GetCurrency}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}
Oexchange.GetPositions()A função é utilizada para obter as informações de posição;GetPositions()função é uma função membro do objeto de troca {@var/EXCHANGE exchange}.GetPositions()função obtém as informações de posição da conta de câmbio ligada ao objeto de câmbioexchangeO objectivo das funções (métodos) dos membros doexchangeObjeto está relacionado apenas comexchangeE não se repetirá aqui.
Oexchange.GetPositions()A função retorna uma matriz de estruturas {@struct/Position Position} se a solicitação de dados for bem-sucedida, e retorna valor nulo se a solicitação de dados falhar.
Matrizes {@struct/Position Position}, valores nulos
troca.GetPositions ((() troca.GetPositions (símbolo)
O parâmetrosymbolé utilizado para definir osímbolo comercialouIntervalo de símbolos de negociaçãoPara ser interrogado.
Se osymbolSe o parâmetro não for transmitido, o padrão é solicitar os dados de posição de todos os símbolos na faixa de dimensões do par de negociação atual e do código do contrato.
símbolo Falso cordel
/*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;
}
Usar objetos de troca de futuros para colocar ordens de mercado para vários pares de negociação diferentes e códigos de contrato.
Os contratos futuros de criptomoedas são diferentes dos contratos spot de criptomoedas, que têm apenas o conceito lógico de uma posição.pares de negociação, Código do contratoPor favor, consulte {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} funções.
EmGetPositionsfunção, os cenários de utilização do parâmetro símbolo são resumidos do seguinte modo:
| Classificação do objeto Exchange | símbolo Parâmetros | Alcance da consulta | Observação |
|---|---|---|---|
| Futuros | Não passe o parâmetro de símbolo | Consultar todos os produtos de negociação dentro do intervalo de dimensões do par de negociação e do código do contrato corrente | Se o par de negociação atual for BTC_USDT e o código do contrato for swap, todos os contratos perpétuos baseados em USDT serão consultados.GetPositions("USDT.swap") |
| Futuros | Especificar o produto de negociação, o parâmetro do símbolo é: |
Consultar o contrato perpétuo baseado em USDT de um determinado BTC | Para os objectos de câmbio de futuros, o formato do símbolo do parâmetro é:par de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelos caracteres".. |
| Futuros | Especificar a gama de produtos de negociação, o parâmetro do símbolo é: |
Consultar todos os contratos perpétuos baseados em USDT | - |
| Bolsas de futuros que suportam opções | Não passe o parâmetro de símbolo | Consultar todos os contratos de opção dentro do intervalo de dimensão do par de negociação corrente | Se o par de negociação atual for BTC_USDT, o contrato é definido como um contrato de opção, por exemplo, contrato de opção da Binance: BTC-240108-40000-C |
| Bolsas de futuros que suportam opções | Especificar um produto comercial específico | Consultar o contrato de opção especificado | Por exemplo, para a Binance Futures Exchange, o parâmetro do símbolo é: BTC_USDT.BTC-240108-40000-C |
| Bolsas de futuros que suportam opções | Especificar a gama de produtos de negociação, o parâmetro do símbolo é: |
Consultar todos os contratos de opções baseados em USDT | - |
EmGetPositionsfunção, o objeto da troca de futuros
a gama de dimensões da consulta é resumida do seguinte modo:
| símbolo Parâmetros | Definição do âmbito de aplicação do pedido | Observação |
|---|---|---|
| USDT.swap | Intervalo de contratos perpétuos baseados em USDT. | Para |
dimensões não suportadas pela interface de API de troca, um erro será relatado e um valor nulo será devolvido quando Está a chamar-me.
♫ USDT.futures ♫ ♫ uma gama de contratos de entrega baseados em USDT ♫
O escopo do perpetual baseado em moeda Contratos.
USD.futures. Escala de entrega baseada em moeda Contratos.
O opção baseada em opções de contrato baseado em USDT.
O opção USD.opção baseada em moeda.
Combo USDT.futures. Uma gama de combinações de CFD. Futures_Deribit Exchange
USD.FUTURES_FF Escala dos contratos de entrega de margem mista. Futures_Kraken Exchange.
USD.swap_pf. Margem mista gama de contrato perpétuo. Futures_Kraken Exchange.
Compatível comexchange.GetPosition()ligação,GetPositioné exatamente o mesmo queGetPositions.
Quando a conta representada pelo objecto de trocaexchangenão tem posições nointervalo de consultaouInstrumentos de negociação especificados, oexchange.GetPositions()função retorna uma matriz vazia, por exemplo:[].
{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}
Oexchange.SetMarginLevel()A função é utilizada para definir o valor de alavancagem do par de negociação ou do contrato especificado pelosymbolParâmetro compatível com apenas passar no parâmetromarginLevelPara definir o valor de alavancagem do par ou contrato de negociação corrente do objeto de troca {@var/EXCHANGE exchange}.
A taxa de câmbio é a taxa de variação da taxa de variação da taxa de variação da taxa de variação da taxa de variação. Câmbio.SetMarginLevel ((marginLevel)
OsymbolO parâmetro é utilizado para especificar o par de negociação ou contrato para o qual o valor de alavancagem precisa de ser ajustado.symbolParâmetro doSetMarginLevel()A função é coerente com o formato dosymbolParâmetro doGetTicker()função.
símbolo
Falso
cordel
OmarginLevelO parâmetro é usado para definir o valor de alavancagem, que geralmente é um número inteiro para as bolsas e também suporta configurações de valor de alavancagem de ponto flutuante para algumas bolsas.
Margem Nível
verdade
Número
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);
}
Oexchange.SetMarginLevel()O sistema de backtesting suporta a chamada doexchange.SetMarginLevel()Função para definir o valor da alavancagem.
Para contratos futuros de criptomoedas, o mecanismo de alavancagem não é uniforme devido às exchanges de contratos futuros de criptomoedas.exchange.SetMarginLevel()A função não gera uma solicitação de rede, mas apenas define a variável de alavancagem no sistema FMZ subjacente (usado para passar parâmetros na interface de colocação de ordens).exchange.SetMarginLevel()A função gerará uma solicitação de rede e pode não definir alavancagem. Pode haver muitas razões para isso, por exemplo: há uma posição atual ou ordem pendente, o que torna impossível definir um novo valor de alavancagem para este par ou contrato de negociação.
As trocas que não suportam oexchange.SetMarginLevel()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| SetMarginLevel | – | Futuros_dYdX / Futuros_Deribit |
{@var/EXCHANGE exchange}
Oexchange.SetDirection()A função é utilizada para definir a direção da ordem da função {@fun/Trade/exchange.Buy exchange.Buy}, função {@fun/Trade/exchange.Sell exchange.Sell} quando se fazem ordens para contratos futuros.
troca.Estabelecer direcção (direcção)
OdirectionO parâmetro é utilizado para definir a direção do contrato de futuros quando a ordem é colocada."buy", "closesell", "sell", "closebuy"- Não.
direção
verdade
cordel
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);
}
Oexchange.SetDirection()A função define a correspondência entre a direção da transação do contrato de futuros e a função de colocação de ordens:
| Funções de colocação de pedidos | A direção definida pelos parâmetros da função SetDirection | Observações |
|---|---|---|
| exchange.Buy | Comprar e abrir posições longas | |
| exchange.Buy | Comprar e fechar posições curtas | |
| exchange.Sell | Vender e abrir posições curtas | |
| exchange.Sell | Vender e fechar posições longas |
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
Oexchange.SetContractType()A função é utilizada para definir o código do contrato atual do objeto de troca {@var/EXCHANGE exchange}.
Oexchange.SetContractType()A função retorna uma estrutura que contém o código do contrato de troca correspondente ao código do contrato atual.quarter, e a estrutura de valor de retorno desta função é:{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}- Não.
Objeto
troca.SetContractType (símbolo)
OsymbolO parâmetro é utilizado para definir o código do contrato, os valores opcionais são:"this_week", "next_week", "quarter", "next_quarter", "swap", etc.
Contratos futuros de criptomoedascontrato de entregaOs códigos, se não especificados, têm geralmente:
this_weekO contrato da semana em curso.next_weekO contrato da próxima semana.quarter: contrato trimestral.next_quarter: o próximo contrato trimestral.Contratos permanentesOs códigos em contratos futuros de criptomoedas, se não especificados, têm, em geral:swapContrato perpétuo.símbolo verdade cordel
function main() {
// Set to this week contract
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
Configure o contrato atual como o contrato da semana atual:
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());
}
Ao estabelecer um contrato comUSDTcomo margem, é necessário trocar o par de negociação no código (também é possível definir o par de negociação diretamente ao adicionar o objeto de troca):
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);
}
Imprimir o valor de retorno doexchange.SetContractType()Função:
Na estratégia de contrato de futuros de criptomoeda, tome um exemplo de mudar para oBTC_USDTPares de negociação: Quando se trocam pares de negociação utilizando oexchange.SetCurrency("BTC_USDT")ouexchange.IO("currency", "BTC_USDT")funções, depois de trocar, você precisa usar oexchange.SetContractType()O sistema determina se é um par de negociação ou um par de negociação.contrato padrão de moedaou umContrato padrão USDTPor exemplo, se um par de negociação estiver definido paraBTC_USDT, utilizar oexchange.SetContractType("swap")função para definir o código do contrato paraswapNeste ponto, está definido paraBTCpara oPadrão USDTSe o par de negociação forBTC_USD, utilizar oexchange.SetContractType("swap")função para definir o código do contrato paraswapNeste ponto, está definido paraBTCÉ...padrão de moedacontrato perpétuo.
Detalhes das bolsas de contratos futuros de criptomoedas compatíveis, com os nomes dos contratos de cada uma delas:
Futuros_OKCoin (OKX)
Contrato perpétuo:exchange.SetContractType("swap")Conforme o contrato desta semana:exchange.SetContractType("this_week")Marcado para a próxima semana:exchange.SetContractType("next_week")Contrato mensal:exchange.SetContractType("month")Contrato para o próximo mês:exchange.SetContractType("next_month")Consolidado em contratos trimestrais:exchange.SetContractType("quarter")Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")
A OKX tem contratos de negociação pré-mercado: a data de entrega do contrato é um horário fixo.HMSTR-USDT-250207. Configure o par de negociação paraHMSTR_USDTna plataforma FMZ, e depois utilizarexchange.SetContractType("HMSTR-USDT-250207")para estabelecer o contrato.
Para funções que suportam osymbolParâmetros, tais como:exchange.GetTicker(), exchange.CreateOrder(), etc. Pode especificar osymbolParâmetro como:HMSTR_USDT.HMSTR-USDT-250207Para obter os dados de mercado do presente contrato ou realizar uma encomenda.
Futuros_HuobiDM (futuros de Huobi)
Conforme o contrato desta semana:exchange.SetContractType("this_week")- Não.
Marcado para a próxima semana:exchange.SetContractType("next_week")- Não.
Consolidado em contratos trimestrais:exchange.SetContractType("quarter")- Não.
Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")- Não.
Contrato perpétuo:exchange.SetContractType("swap")- Não.
Apoia contratos comUSDTcomo margem, tomarBTCContrato como exemplo: utilizaçãoexchange.IO("currency", "BTC_USDT")para mudar para um contrato que utilizaUSDTcomo margem.
Ou definir o par de negociação actual paraBTC_USDTDepois de trocar pares de negociação, você precisa chamarexchange.SetContractType()A função de novo para definir o contrato.
Ativos de dívida líquidos e passivos
Contrato perpétuo:exchange.SetContractType("swap")- Não.
Os contratos de entrega de câmbio Futures_BitMEX são contratos mensais com os seguintes códigos de contrato (de janeiro a dezembro):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Estabelecimento de contratos de entrega:exchange.SetContractType("December")Por exemplo, quando o par de negociação está definido paraXBT_USDT, oexchange.SetContractType("December")A função é chamada para definir o contrato para a entrega de Dezembro em USDT baseado em BTC (correspondente ao código do contrato real deXBTUSDTZ23).
Resumo das informações sobre contratos Futures_BitMEX
| Código de contrato definido por Futures_BitMEX | O par de negociação correspondente no FMZ | Código do contrato correspondente na FMZ | Observação |
|---|---|---|---|
| DOGEUSD | DOGE_USD | troca | denominado em USD, XBT liquidado. |
| DOGEUSDT | DOGE_USDT | troca | denominados em USDT, liquidados em USDT. |
| XBTETH | XBT_ETH | troca | ETH denominado, XBT liquidado. |
| XBTEUR | XBT_EUR | troca | denominados em euros, liquidados em XBT. |
| USDTUSDC | USDT_USDC | troca | denominado em USDC, liquidado em XBT. |
| ETHUSD_ETH | ETH_USD_ETH | troca | denominado em USD, ETH liquidado. |
| XBTH24 | XBT_USD | Março | Data de expiração: 24 de março, código do mês é: H; denominado em USD, liquidado em XBT. |
| ETHUSDZ23 | ETH_USD | Outubro | Data de expiração: 23 de dezembro, código do mês é: Z; denominado em USD, liquidado em XBT. |
| XBTUSDTZ23 | XBT_USDT | Outubro | Data de validade: 23 de Dezembro, código do mês é: Z ; denominado em USDT, liquidado em USDT. |
| ADAZ23 | ADA_XBT | Outubro | Data de expiração: 23 de dezembro, código do mês é: Z ; faturamento em XBT, liquidação em XBT. |
| P_XBTETFX23 | USDT_XXX | P_XBTETFX23 | Data de vencimento: 23/11/23; denominada em percentagem e liquidada em USDT. |
Futures_GateIO
Conforme o contrato desta semana:exchange.SetContractType("this_week")- Não.
Marcado para a próxima semana:exchange.SetContractType("next_week")- Não.
Consolidado em contratos trimestrais:exchange.SetContractType("quarter")- Não.
Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")- Não.
Contrato perpétuo:exchange.SetContractType("swap")- Não.
Apoia contratos comUSDTcomo margem, tomarBTCContrato como exemplo: utilizaçãoexchange.IO("currency", "BTC_USDT")para mudar para um contrato que utilizaUSDTcomo margem.
Ou definir o par de negociação actual paraBTC_USDTDepois de trocar pares de negociação, você precisa chamarexchange.SetContractType()A função de novo para definir o contrato.
Futuros_Deribit
Contrato perpétuo:exchange.SetContractType("swap")- Não.
Suporta DeribitUSDCContrato.
Os contratos de entrega são:"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"- Não.
CFD (future_combo):"this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", há muitas combinações.
Para os contratos de opção, é necessário inserir o código específico do contrato de opção definido pela bolsa, consulte o site da Deribit para obter mais informações.
Futures_KuCoin
Por exemplo, se o par de negociação estiver definido paraBTC_USDe o código do contrato é definido, trata-se de um contrato baseado em moeda:
Contrato perpétuo:exchange.SetContractType("swap")- Não.
Consolidado em contratos trimestrais:exchange.SetContractType("quarter")- Não.
Contrato para o próximo trimestre:exchange.SetContractType("next_quarter").
USDT como contrato de margem:
Por exemplo, se o par de negociação estiver definido paraBTC_USDT, e, em seguida, definir o código do contrato, é um contrato com USDT como margem.
Contrato perpétuo:exchange.SetContractType("swap").
Futures_Binance
Binance Futures Exchange predefinições para o contrato perpétuo do par de negociação atual, código do contrato:swap- Não.
Contrato perpétuo:exchange.SetContractType("swap"), os contratos perpétuos da Binance têm contratos que usamUSDTComo margem.USDTContrato perpétuo deBTCO par de negociação pode ser utilizado como um contrato de margem, e o par de negociação está definido paraBTC_USDTA Binance também suporta contratos perpétuos que usam moedas como margem, por exemplo,BTCÉ o contrato perpétuo padrão da Binance, com o par de negociação definido paraBTC_USD- Não.
Consolidado em contratos trimestrais:exchange.SetContractType("quarter"), o contrato de entrega tem um contrato padrão de moeda (ou seja, utilizando moedas como margem), por exemplo,BTCNo contrato trimestral, o par de negociação está definido para:BTC_USDe depois estabelecer o contratoexchange.SetContractType("quarter"), está definido emBTCcontrato trimestral com um contrato padrão de moeda.
Contrato para o próximo trimestre:exchange.SetContractType("next_quarter"), por exemplo,BTCdo contrato trimestral padrão de moeda, o par de negociação definido para:BTC_USD, e depois definir o contratoexchange.SetContractType("next_quarter")- Não.
Binance suporta parcialmenteUSDTcomo contrato de entrega de margem, tomarBTCcomo exemplo, definir o par de negociação paraBTC_USDT, depois define o código do contrato.
Suporte para contratos de opções Binance:
O formato do código do contrato de opção baseia-se no código do contrato de opção definido pela bolsa:BTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-PPegue o código do contrato de opção da BinanceBTC-241227-15000-PPor exemplo: BTC é o código da moeda da opção, 241227 é a data de exercício, 15000 é o preço de exercício, P representa uma opção de venda e C representa uma opção de compra.
Para mais informações sobre o tipo de opção, quer se trate de opção europeia ou de opção americana, consulte as informações pertinentes do contrato de opção da bolsa.
A troca pode restringir os vendedores de opções e exigir que eles solicitem qualificações separadamente.
Futures_Bibox
Código do contrato para contratos perpétuos Bibox:swap- Não.
Contrato perpétuo:exchange.SetContractType("swap").
Futures_Bybit
O contrato de partilha é o contrato perpétuo para o par de negociação em curso, código do contrato:swap- Não.
Código do contrato desta semana:this_week- Não.
Código do contrato da próxima semana:next_week- Não.
Código do contrato da terceira semana:third_week- Não.
Código de contrato mensal:month- Não.
Código do contrato do próximo mês:next_month- Não.
Código do contrato trimestral:quarter- Não.
Código do contrato do próximo trimestre:next_quarter- Não.
Código do contrato do terceiro trimestre:third_quarter.
Futures_Kraken
O contrato de partilha é o contrato perpétuo do par de negociação em curso, código do contrato:swap.
swapContrato perpétuo.month: contrato do mês em curso.quarter: contrato trimestral.next_quarterContrato para o próximo trimestre.swap_pf: Contrato perpétuo de margem mista.quarter_ff: Contrato trimestral de margem mista.month_ff: Contrato de margem mista do mês em curso.next_quarter_ffContrato de margem mista para o próximo trimestre.
Futuros_Bitfinex
O valor da posição em risco é o valor da posição em risco.swap.
Futures_Bitget
O valor da posição em risco é o valor da posição em risco.swap- Não.
O par de negociação está definido emBTC_USDpara os contratos padrão de moeda, e o par de negociação está definido emBTC_USDTpara contratos liquidados porUSDTOs contratos demo podem ser estabelecidos com pares de negociação comoSBTC_USD, BTC_SUSDT.
Futuros_dYdX
Código do contrato para contratos perpétuos dYdX:swap- Não.
Contrato perpétuo:exchange.SetContractType("swap"), a dYdX dispõe apenas de contratos normalizados em USDT.
Futures_MEXC
Código do contrato para contratos perpétuos do MEXC:swap- Não.
Contrato perpétuo:exchange.SetContractType("swap"). Configurar o par de negociação paraBTC_USD, que é um contrato padrão de moeda, e estabelecer o par de negociação paraBTC_USDT, que éUSDT- Contrato resolvido.
Futures_Crypto
Tokens numa conta nocrypto.comOs valores mobiliários podem ser convertidos em créditos denominados em USD para serem utilizados como margem para negociação de contratos.
Contrato perpétuo:exchange.SetContractType("swap")Exemplo de chamadaexchange.SetContractType("swap")função para definir um contrato perpétuo para BTC quando o par de negociação está definido paraBTC_USD- Não.
Ocrypto.comOs contratos de entrega de câmbio são contratos mensais com os seguintes códigos de contrato (de janeiro a dezembro):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Definir o contrato de entrega:exchange.SetContractType("October")Por exemplo, quando o par de negociação está definido paraBTC_USD, chamar a funçãoexchange.SetContractType("October")para estabelecer o contrato de entrega de outubro para BTC.
O código do contrato correspondente é:BTCUSD-231027.
Futures_WOO
Futuros_WOOUSDTbaseados em contratos com um código de contrato perpétuo deswapPor exemplo, quando o par de negociação está definido paraBTC_USDT, a funçãoexchange.SetContractType("swap")é chamado a definir o contrato atual para ser um contrato perpétuo baseado em USDT para BTC.
{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}
Oexchange.GetContractType()A função é utilizada para obter o código do contrato para a configuração atual do objeto de troca {@var/EXCHANGE exchange}.
Oexchange.GetContractType()A função devolve o código do contrato definido pela plataforma FMZ, por exemplo:this_week, swap, etc.
cordel
exchange.GetContractType (()
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}
Oexchange.GetFundings()A função é utilizada para obter os dados da taxa de financiamento para o período em curso.
Oexchange.GetFundings()A função retorna uma matriz de estruturas {@struct/Funding Funding} quando a solicitação de dados é bem-sucedida e retorna um valor nulo quando a solicitação de dados falha.
Matriz {@struct/Funding Funding}, valor nulo
Troca.GetFundings ((() Troca.GetFundings (símbolo)
O parâmetrosymbolé utilizado para definir osímbolo da transacçãoouIntervalo de símbolos de transacçãoO que é que a Comissão está a fazer?symbolSe o parâmetro não for transmitido, os dados da taxa de financiamento atual de todos os instrumentos serão solicitados por defeito na faixa de dimensões do par de negociação atual e do código do contrato.
símbolo Falso cordel
/*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() + "`");
}
Use o objeto de troca de futuros para chamar oexchange.GetFundings()Antes de chamar qualquer função de mercado, o GetFundings retorna apenas os dados de financiamento do par de negociação padrão atual. Depois de chamar a função de mercado, retorna os dados de financiamento de todas as variedades solicitadas.
Para as bolsas de futuros que não suportam consulta por lotes de dados de taxa de financiamento, se osymbolO parâmetro é especificado como a faixa de consulta, por exemplo:USDT.swapou osymbolQuando o parâmetro não é passado, a interface irá relatar um erro.GetFundings()função usando este tipo de objeto de troca de futuros, você deve especificar osymbolParâmetro como um tipo específico de contrato perpétuo, a fim de consultar os dados atuais da taxa de financiamento do tipo.
Oexchange.GetFundings()A função suporta sistemas reais de negociação e backtesting.
Bolsas que não suportam aquisição por lotes de dados de taxa de financiamento: Futures_Bitget, Futures_OKX, Futures_MEXC, Futures_Deribit, Futures_Crypto.symbolParâmetro com o código de símbolo específico, por exemplo:ETH_USDT.swap.
As trocas que não suportam oexchange.GetFundings()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetFundings | – | Futures_DigiFinex |
{@struct/Funding Funding}
Oexchange.SetBase()A função é utilizada para definir o endereço de base da interface de API de troca configurada no objeto de troca {@var/EXCHANGE exchange}.
Intercâmbio.SetBase (s)
OsO parâmetro é utilizado para especificar o endereço de base da interface API de troca.
s
verdade
cordel
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());
}
Mudar o endereço de base da API de troca não é suportado no sistema de backtesting, porque o sistema de backtesting é um ambiente de simulação de sandbox e não acessa realmente a interface da API de troca.
{@fun/Trade/exchange.IO exchange.IO}
Oexchange.GetBase()função é usada para obter o endereço de base da interface API de troca atual.
O endereço de base da interface API de troca atual. cordel
troca.GetBase ((()
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
Não, não, não, não.
Oexchange.SetProxy()A função é utilizada para definir a configuração do proxy do objeto de troca {@var/EXCHANGE exchange}.
Intercâmbio.SetProxy (proxy)
OproxyO parâmetro é utilizado para especificar a configuração do proxy.
Proxy
verdade
cordel
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());
}
Configurar o objeto de troca {@var/EXCHANGE exchange}socks5Proxy:
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();
}
Além deespecificação globaldo endereço IP da solicitação do objeto de troca {@var/EXCHANGE exchange}, há também suporte para especificar um endereço IP baseado em {@var/EXCHANGE exchange}:
Se a configuração do proxy falhar, oexchange.SetProxy()A função retornará null quando chamada.exchange.SetProxy()função define o proxy para orestUm proxy pode ser definido para cada objeto de troca {@var/EXCHANGE exchange} e o acesso à interface de troca vinculada ao objeto de troca {@var/EXCHANGE exchange} após a configuração do proxy será acessado através do proxy.
Apoio à configuraçãosocks5proxy, tomando o primeiro objeto de troca adicionado {@var/EXCHANGE exchange} ou seja:exchanges[0]Por exemplo:
exchange.SetProxy("socks5://127.0.0.1:8889").exchange.SetProxy("socks5://username:password@127.0.0.1:8889"). usernameé o nome do utilizador epasswordé a senha.exchange.SetProxy("").Suporta a definição do endereço IP da solicitação a partir do objeto de troca {@var/EXCHANGE exchange}especificado globalmente.
{@var/EXCHANGE exchange}
Oexchange.SetTimeout()A função é utilizada para definir o timeout dorestsolicitação para o objeto de troca {@var/EXCHANGE exchange}.
Troca. SetTimeout (Timeout)
OtimeoutO parâmetro é utilizado para especificar o número de milissegundos para a definição do timeout.
tempo de espera
verdade
Número
function main() {
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
}
def main():
exchange.SetTimeout(3000)
Log(exchange.GetTicker())
void main() {
exchange.SetTimeout(3000);
Log(exchange.GetTicker());
}
O parâmetrotimeouté um valor de milissegundos, 1000 milissegundos é igual a 1 segundo.restapenas protocolo, usado para definir o timeoutrestA aplicação do princípio da proporcionalidade, que é aplicado a todos os pedidos, entra em vigor se for definida uma única vez.exchange.SetTimeout(3000), define oresttempo de espera para oexchangechamadas de funções com solicitações de rede comoexchange.GetTicker()que não recebem uma resposta por mais de 3 segundos vai expirar, e as chamadas de função que fazem expirar retornarão valores nulos.SetTimeout()não é uma função global, é um método do objeto de troca {@var/EXCHANGE exchange}.
{@var/EXCHANGE exchange}
A plataforma de negociação de quantidade FMZ realmente suporta a função multi-threaded doJavaScriptA estratégia linguística é desenvolvida a partir da base do sistema e tem por objectivo:
| Objetos | Orientações | Observações |
|---|---|---|
| Filamentos | Objeto global multithreaded | Funções dos membros:Thread, getThread, mainThread, etc. |
| Fios | Objeto de linha | Funções dos membros:peekMessage, postMessage, join, etc. |
| ThreadLock | Objeto de bloqueio de fio | Funções dos membros:acquire, release. Eles podem ser passados para o ambiente do thread como parâmetros da função de execução do thread. |
| ThreadEvent | Objeto evento | Funções dos membros:set, clear, wait, isSet. Eles podem ser passados para o ambiente do thread como um parâmetro da função de execução do thread. |
| ThreadCondição | Objeto de condição | Funções dos membros:notify, notifyAll, wait, acquire, release. Eles podem ser passados para o ambiente do thread como um parâmetro da função de execução do thread. |
| ThreadDict | Objeto do dicionário | Funções dos membros:get, set. Eles podem ser passados para o ambiente do thread como parâmetros da função de execução do thread. |
Othreadingobject é uma ferramenta global de gerenciamento de multithreading que fornece funções como criar threads concorrentes, bloqueios de thread e objetos de condição.threadingEste objeto só é suportado peloJavaScriptEstratégia linguística.
OThread()função é usada para criar tópicos simultâneos.
OThread()função retorna aThreadobjeto, que é utilizado para gerir threads criados em simultâneo, comunicação de threads, etc.
ThreadObjeto
Thread ((func,...args) Apresentação (s)
O parâmetrofuncé uma função para execução simultânea (passada por referência), e suporta a passagem de funções anônimas.funcpode aceitar múltiplos parâmetros, que serão transmitidos através de...argsPortanto, a lista de parâmetros defuncdeve ser coerente com...args.
Função
verdade
função
O parâmetroargé o parâmetro real passado parafunc(ou seja, a função de execução de thread simultânea) quando a chamada de retorno é executada; pode haver vários parâmetrosarg, e a lista de parâmetros defuncdeve ser coerente com...args.
arg
Falso
cadeia, número, bool, objeto, matriz, função, valor nulo e outros tipos suportados pelo sistema
O parâmetroitemé uma matriz contendo as referências de função e seus parâmetros a serem executados simultaneamente.itemOs parâmetros podem ser transmitidos ao chamar oThread function.
item verdade matriz
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()
}
Crie tópicos simultâneos para uma função personalizada e uma função anônima.
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()
}
Utilize oThread(...items)forma para criar threads simultâneos e executar múltiplas funções sequencialmente.
function testFunc1(p) {
Log("testFunc1 p:", p)
}
function main() {
threading.Thread(function(pfn) {
var threadName = threading.currentThread().name()
var threadId = threading.currentThread().id()
pfn(`in thread threadName: ${threadName}, threadId: ${threadId}`)
}, testFunc1).join()
}
Suporta a passagem de parâmetros para funções executadas simultaneamente.
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)
}
Ele suporta a passagem de cadeias de funções e pode importar bibliotecas externas dinamicamente para computação simultânea.
A função do fiofuncpassaram para oThread()A função para execução simultânea é executada em um ambiente isolado, de modo que as variáveis fora do thread não podem ser diretamente referenciadas, e a compilação falhará quando referenciada. Ao mesmo tempo, as referências a outras funções de fechamento não são suportadas dentro do thread. Todas as APIs fornecidas pela plataforma podem ser chamadas dentro do thread, mas outras funções definidas pelo usuário não podem ser chamadas.
Ele suporta sistema de backtesting e ambiente de negociação ao vivo. Todas as funções relacionadas ao thread simultâneo são apenas suportadas como compatibilidade de código no sistema de backtesting e não serão executadas por threads simultâneos, por isso não serão repetidas neste capítulo.
{@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/pending pending}, {@fun/Threads/threading/eventLoop event}
OgetThread()função é usada para obter o objeto de thread com base no ID de thread especificado.
OgetThread()função retorna oThreadObjeto com o threadId especificado pelo parâmetro
ThreadObjeto
getThread ((ThreadId)
O parâmetrothreadIdé o ID do objeto do thread. Obtenha o objeto do thread correspondente especificando o parâmetro.
threadId verdade Número
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())
}
Obtenha o objeto de thread especificado atravésthreadId.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
Se o thread que você quer obter foi executado e liberado, você não pode usarthreading.getThread(threadId)para obter o objeto do fio do fio.
{@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/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop eventLoop}
OmainThread()A função é utilizada para obter o objeto do fio do fio principal, ou seja, o fio onde omain()A função na estratégia está localizada.
OmainThread()função retorna o objeto thread do thread principal.
ThreadObjeto
mainThread ((()
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
Apanha oThreadObjeto do fio principal e saída dothreadIdda linha principal.
function test() {
Log("Output the main thread ID in the test function:", threading.mainThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
O objeto do fio do fio principal também pode ser obtido em fios concorrentes.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/Thread Thread}, {@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 Loop}
OcurrentThread()função é usada para obter o objeto thread do thread atual.
OcurrentThread()função retorna o objeto thread do thread atual.
ThreadObjeto
CurrentThread ((()
function test() {
Log("Id of the current thread:", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Apanha oThreadobjeto do fio de corrente e saída dothreadIddo fio corrente.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
{@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/threading/threading/Dict Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop eventLoop}
OLock()A função é usada para criar um objeto de bloqueio de thread.
OLock()A função retorna um objeto de bloqueio de thread.
ThreadLockObjeto
Bloqueio
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()
}
Dois tópicos simultâneos acessam um recurso comum.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
{@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 event}
OCondition()função é usada para criar um objeto de variável de condição, que é usado para alcançar a sincronização e comunicação entre threads em um ambiente simultâneo multi-threaded.Condition(), um thread pode esperar quando certas condições não são cumpridas até que outro thread notifique que a condição foi cumprida.
OCondition()função retorna aThreadCondition object.
ThreadConditionObjeto
Condição
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()
}
Dois tópicos simultâneos acessam um recurso comum.
O sistema de backtesting não implementa esta funcionalidade, ele apenas a define.
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}
OEvent()função é usada para criar umevento de threadobjeto, que é usado para a sincronização entre os tópicos, permitindo que um tópico espere por notificação ou sinal de outro tópico.
OEvent()função retorna aThreadEvent object.
ThreadEventObjeto
Eventos
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()
}
Dois tópicos simultâneos acessam um recurso comum.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
{@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}
ODict()função é usada para criar um objeto de dicionário para passar para tópicos concorrentes.
ODict()função retorna aThreadDict object.
ThreadDictObjeto
Dicionário
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()
}
Passar um objeto normal para a função de execução de thread simultâneo para testar se modificar o valor da chave do objeto causará alterações no valor da chave do objeto em outros 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()
}
Passa oThreadDictObjeto criado peloDict()função para a função de execução de thread simultânea, e testar se a modificação do valor da chave do objeto fará com que o valor da chave do objeto em outros threads mude.
Quando um objeto comum é passado para uma função de thread concorrente, ele é passado como uma cópia profunda.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
{@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}, {@fun/Threads/threading/threading/thread}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}
Opendingfunção é usada para obter o número de tópicos concorrentes em execução no programa de estratégia atual.
Opending()função retorna o número de tópicos simultâneos que o programa de estratégia atual está executando.
Número
pendente
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())
}
Crie dois tópicos em execução simultânea e chame opending()função em diferentes pontos de tempo.
Quando a estratégiamain()função começa a executar, chamando a funçãopending()diretamente irá retornar 1, porque o fio principal onde a estratégiamain()função está localizado é também um fio pendente.
Suporta sistema de backtesting e ambiente de negociação ao vivo.
{@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}
Threadobjetos podem ser criados ou devolvidos porthreading.Thread(), threading.getThread(), threading.mainThread(), ethreading.currentThread().
OpeekMessage()função é usada para obter uma mensagem de um thread.
OpeekMessage()função retorna a mensagem recebida pelo thread associado ao objeto do thread atual.
string, number, bool, object, array, null value e outros tipos suportados pelo sistema
PeekMessagem() PeekMessage ((timeout)
O parâmetrotimeouté a definição de timeout. Ele irá bloquear e esperar o número de milissegundos definidos pelo parâmetro e retornar dados. Se não houver dados e o timeout exceder o limite, um valor nulo será devolvido. Setimeouté definido como 0 ou otimeoutParâmetro não é passado, significa que o processo irá bloquear e esperar até que os dados sejam recebidos do canal.timeoutse for definido em -1, significa que o processo não bloqueará e retornará dados imediatamente.
tempo de espera Falso Número
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()
}
Enviar mensagens para o tópico principal de um tópico concorrente.
Quando escrevemos programas, precisamos prestar atenção aos problemas de thread deadlock.
{@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/Thread/name}, {@Threads/Threads/eventLoop eventLoop}
OpostMessage()função é usada para enviar uma mensagem para um tópico.
PostMessage ((msg)
O parâmetromsgé a mensagem a ser enviada.
msg verdade Qualquer tipo suportado pelo sistema, como string, número, bool, objeto, matriz, função, valor nulo, 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()
}
Enviar mensagens em tópicos simultâneos e usareventLoop()para receber notificações de mensagens.
function main() {
threading.mainThread().postMessage(function(msg) {
Log("func from mainThread, msg:", msg)
})
threading.Thread(function() {
var func = threading.mainThread().peekMessage()
func("in " + threading.currentThread().name())
}).join()
}
Suporta enviar uma função.
Quando uma função de execução de threadpostMessage()A função para enviar um sinal ou dados, um evento de mensagem também é gerado.eventLoop()Função para receber notificações de mensagens.
{@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}
Ojoin()A função é usada para esperar que o thread saia e recupere os recursos do sistema.
OThreadRetObjetocontém dados sobre o resultado da execução. As propriedades incluem:
ThreadRetObjeto
Junte-se. Participação (timeout)
OtimeoutO parâmetro é usado para definir o timeout em milissegundos para esperar que o fio termine.timeoutParâmetro é definido em 0 ou otimeoutParâmetro não definido, ojoin()função irá bloquear e esperar até que o tópico terminar de executar.timeoutParâmetro definido em -1, ojoin()A função irá voltar imediatamente.
tempo de espera Falso Número
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}
}
Teste ojoin()Função de timeout e saída do valor de retorno.
Ojoin()Função out times e returnsundefined.
{@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/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}
Oterminate()A função é usada para encerrar forçosamente um thread e liberar os recursos de hardware utilizados pelo thread criado.
Terminar (((
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)
}
}
Terminar a execução de um thread com força.
Para fios que são forçosamente terminados peloterminate()A função, já não podemos usar ojoin()Função para esperar que eles terminem.
{@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/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
OgetData()A função é usada para acessar variáveis registradas no ambiente do thread.join()função (em espera de saída bem sucedida) e não executou oterminate()Função (terminar o fio à força).
OgetData()função retorna o valor da chave correspondente aokeyParâmetro no par chave-valor armazenado no contexto do thread atual.
string, number, bool, object, array, null value e outros tipos suportados pelo sistema
GetData (em inglês) GetData (chave)
OkeyParâmetro é o nome da chave do par chave-valor armazenado.
Chave verdade cordel
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()
}
Gravar o valor da chavecountno ambiente de thread simultâneo, e depois ler o valor chave decountno assunto 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}
OsetData()função é usada para armazenar variáveis no contexto do thread.
setData ((chave, valor)
OkeyO parâmetro é utilizado para especificar o nome da chave do par chave-valor armazenado.
Chave
verdade
cordel
OvalueO parâmetro é utilizado para especificar o valor da chave do par chave-valor armazenado.
Valor verdade Qualquer tipo suportado pelo sistema, como string, número, bool, objeto, matriz, função, valor nulo, etc.
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Sleep(1000)
Log(`t1.getData("data"):`, t1.getData("data"))
t1.join()
}
Configure o par chave-valor no thread concorrente e leia o par chave-valor no thread principal.
function main() {
threading.mainThread().setData("func2", function(p) {
Log("func2 p:", p)
})
var t1 = threading.Thread(function() {
threading.currentThread().setData("func1", function(p) {
Log("func1 p:", p)
})
var func2 = threading.mainThread().getData("func2")
func2("test2")
})
Sleep(1000)
var func1 = t1.getData("func1")
func1("test1")
t1.join()
}
Suporta a passagem de valores-chave em funções.
Os dados são válidos quando o tópico não executou ojoin()função (em espera de saída bem sucedida) e não executou oterminate()Função (terminando o fio forçosamente).valuedeve ser uma variável serializável.
{@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/Thread/eventLoop eventLoop}
Oid()função é usada para retornar othreadIdda instância de objeto multithread atual.
O valor de retorno doid()função éthreadId.
Número
id()
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.id():`, t1.id())
t1.join()
}
Crie um thread em execução simultânea e faça a saídathreadIddeste fio concorrente no fio 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}
Oname()função é usada para retornar o nome da instância atual de objeto multithreaded.
Oname()função retorna o nome do thread concorrente.
cordel
Nome (s)
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.name():`, t1.name()) // t1.name(): Thread-1
t1.join()
}
Crie um tópico concorrente e produza o nome do tópico concorrente no tópico 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/eventLoop eventLoop}
OeventLoop()função é usada para ouvir eventos recebidos pelo thread.
OeventLoop()função retorna a informação do evento recebida pelo thread atual.Estrutura de informação de eventos.
Objeto, valor nulo
EventLoop (em inglês) EventLoop (tempo de espera)
O parâmetrotimeouté a definição de timeout em milissegundos.timeoutSe for definido como 0, ele vai esperar que um evento ocorra antes de retornar. Se for maior que 0, ele irá definir o evento de espera de tempo. Se for menor que 0, ele retornará o último evento imediatamente.
tempo de espera Falso Número
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()
}
Se o timeout ocorrer ou a função retornar imediatamente, o valor de saída é nulo.
O mecanismo de tratamento doeventLoop()função é o mesmo que a função globalEventLoop().
{@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 setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}
Objeto de bloqueio de thread, utilizado para processamento de sincronização multi-thread.
Oacquire()A função é utilizada para solicitar um bloqueio (bloqueio) do fio.
Adquirir (((
Por favor, consulte othreading.Lock()secção para exemplos.
Oacquire()A função é usada para solicitar um bloqueio de thread.acquire()Função de um objeto de bloqueio de thread, ele tenta adquirir o bloqueio. Se o bloqueio não está atualmente mantido por outro thread, o thread chamador adquire o bloqueio com sucesso e continua a execução. Se o bloqueio já está mantido por outro thread, o thread chamadoracquire()será bloqueado até que a fechadura seja liberada.
Não, não, não, não, não.
Orelease()A função é utilizada para liberar um bloqueio de fio (desbloqueio).
libertação
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()
}
Teste de cenários de impasse
Deve notar-se que a utilização inadequada de fechaduras de fios pode conduzir a um impasse.
Não, não, não, não, não.
Objeto de evento, utilizado para notificação e sinal de evento multi-threaded.
Oset()A função é utilizada para notificar eventos (sinais definidos).
Conjunto
Por favor, consulte othreading.Event()secção para exemplos.
Se o sinal tiver sido definido usandoset()Temos de limpar o sinal e voltar a colocá-lo.
{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Oclear()A função é utilizada para eliminar o sinal.
Está tudo limpo.
Por favor, consulte othreading.Event()secção para exemplos.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Owait()A função é utilizada para definir um evento (sinal) de espera, e bloqueará antes do evento (sinal) ser definido; suporta a definição de um parâmetro de timeout.
Owait()A função retorna se o timeout ocorreu. Se sim, retorna um valor verdadeiro.
Bool
Espere. Espere (Timeout)
OtimeoutO parâmetro é utilizado para definir o tempo de espera em milissegundos.
tempo de espera Falso Número
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()
}
Teste o valor de retorno dowait() function.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
OisSet()Função utilizada para determinar se um evento (sinal) foi definido.
OisSet()A função retorna se o evento (sinal) foi definido; se o evento (sinal) foi definido, retorna um valor verdadeiro.
Bool
isSet()
Por favor, consulte othreading.Event()secção para exemplos.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}
Objeto de condição, utilizado para sincronização multi-thread.
Onotify()A função é usada para acordar um tópico em espera (se houver).wait()O método vai despertar.
Notificar
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)
}
}
Utilize onotify()Função para acordar o fio de espera.
Onotify()Função acorda um fio na fila de espera.
Quando onotify()Função acorda um fio, o fio vai recuperar o bloqueio do fio.
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
OnotifyAll()A função acorda todos os fios em espera.
Avise a todos
Por favor, consulte oThreadCondition.notify()secção para exemplos.
OnotifyAll()A função acorda todos os fios em espera um por um, e os fios despertados recuperam o bloqueio do fio.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
Owait()A função é usada para fazer um fio esperar sob certas condições projetadas.
Espere.
Por favor, consulte oThreadCondition.notify()secção para exemplos.
Owait()A função liberta o bloqueio do fio e recupera o bloqueio do fio quando acordado.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
Oacquire()A função é utilizada para solicitar um bloqueio (bloqueio) do fio.
Adquirir (((
Por favor, consulte oThreadCondition.notify()secção para exemplos.
Antes de utilizarwait(), você precisa solicitar o bloqueio de thread (bloqueio) do objeto de condição atual.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}
Orelease()A função é utilizada para liberar um bloqueio de fio (desbloqueio).
libertação
Por favor, consulte oThreadCondition.notify()secção para exemplos.
Após utilizaçãowait(), precisamos liberar o thread lock (desbloquear) do objeto de condição atual.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}
Objeto de dicionário, usado para partilha de dados.
Oget()função é usada para obter o valor chave registrado no objeto do dicionário.
Oget()função retorna o valor da chave especificada pelokey parameter.
string, number, bool, object, array, null value e outros tipos suportados pelo sistema
Get (chave)
OkeyO parâmetro é utilizado para especificar o nome da chave correspondente à chave a obter.
Chave verdade cordel
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"))
}
Usar objetos de evento para notificar threads para ler e modificar dados.
Não, não, não, não.
Oset()A função é utilizada para definir um par chave-valor.
Set (chave, valor)
O parâmetrokeyé utilizado para definir o nome da chave a modificar.
Chave
verdade
cordel
O parâmetrovalueÉ utilizada para definir o valor chave a modificar.
Valor verdade cadeia, número, bool, objeto, matriz, função, valor nulo e outros tipos suportados pelo sistema
function main() {
var dict1 = threading.Dict()
dict1.set("func1", function(p) {
Log("func1 p:", p)
})
threading.Thread(function(dict1) {
var func1 = dict1.get("func1")
func1("test")
}, dict1).join()
}
Suporta a passagem de valores-chave em funções.
Não, não, não, não.
Na plataforma de negociação FMZ Quant, implementa principalmente várias funções, chamadas relacionadas ao blockchain através deexchange.IO()O seguinte documento descreve a funçãoexchange.IO()O método de chamada do sistema deexchange.IO("abi", ...)A função é utilizada para registar um ABI.
exchange.IO(k, endereço, abiContent)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"abi"significa que a função é utilizada para registarABI- Não.
k
verdade
cordel
OaddressO parâmetro é utilizado para especificar o endereço do contrato inteligente.
Endereço
verdade
cordel
OabiContentParâmetro utilizado para especificar oABIdo contrato inteligente.
AbiContent
verdade
cordel
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)
}
Os métodos de chamada de contratos inteligentes não precisam de ser registados se forem métodos ERC20 padrão.
Apanha oABIO conteúdo do contrato pode ser obtido através do seguinte endereço URL:resultapenas campo, por exemplo:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
O método de chamada deexchange.IO("api", "eth", ...)função é usada para chamar o método Ethereum RPC.
Oexchange.IO("api", "eth", ...)A função retorna o valor de retorno do método RPC chamado.
string, number, bool, object, array, null e todos os outros tipos suportados pelo sistema
exchange.IO(k, blockChain, rpcMétodo)exchange.IO(k, blockChain, rpcMethod,...args)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"api"indica que a função é utilizada para estender a solicitação de chamada.
k
verdade
cordel
OblockChainParâmetro utilizado para definir a função doexchange.IO()função, definida em"eth"indica que a função é utilizada para chamadas de métodos RPC na Rede Ethereum.
BlockChain
verdade
cordel
OrpcMethodParâmetro é usado para definir o método RPC a ser chamado peloexchange.IO()função.
Método rpc
verdade
cordel
OargO parâmetro é usado para especificar os parâmetros do método RPC a ser chamado.argO tipo e o número deargOs parâmetros dependem do método RPC especificado pelorpcMethodParâmetro.
arg
Falso
string, number, bool, object, array, function, null e todos os outros tipos suportados pelo sistema
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()))
}
Verifique o saldo de ETH na sua carteira:
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)
}
Para transferências de ETH, pode definir o{gasPrice: 11, gasLimit: 111, nonce: 111}Parâmetro, que é definido no último parâmetro doexchange.IO()A sua função, de acordo com as suas necessidades específicas.noncee usar o sistema padrão, ou deixargasLimit/gasPrice/nonceDesativar e usar o valor padrão do sistema para todos.
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)
}
PerguntagasPrice:
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)
}
Perguntaeth_estimateGas:
O segundo parâmetro doexchange.IO()função com"eth"pode chamar diretamente os métodos RPC disponíveis para o servidor de nó Ethereum.
- O que é que queres?
Oexchange.IO("encode", ...)A função é chamada para codificação de dados.
Oexchange.IO("encode", ...)função retorna os dados codificados.
cordel
exchange.IO(k, dataFormat,...args)exchange.IO(k, endereço, dataFormat)exchange.IO(k, endereço, dataFormat,...args)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"encode"significa que a função é utilizada para codificação de dados.
k
verdade
cordel
OaddressO parâmetro é usado para definir o endereço do contrato inteligente.exchange.IO("encode", ...)função, passando noaddressO parâmetro indica a codificação da chamada do método no contrato inteligente.exchange.IO("encode", ...)Função, se oaddressse o parâmetro não for transmitido, a função é utilizada para codificar a ordem de tipo especificada e é funcionalmente equivalente aabi.encodeemSolidity- Não.
Endereço
Falso
cordel
OdataFormatO parâmetro é utilizado para especificar o método, tipo e ordem dos dados codificados.
DataFormat
verdade
cordel
OargParâmetro é usado para especificar o valor de dados específico que corresponde aodataFormatPode haver mais de umargParâmetro, tipo e número deargOs parâmetros dependem dadataFormatConfiguração de parâmetros.
arg
Falso
string, number, tuple, array, e todos os outros tipos suportados pelo sistema
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)
}
Por exemplo, chamando o método de codificaçãounwrapWETH9:
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
*/
}
É equivalente ao exemplo de codificação deabi.encodeemSolidity:
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)
}
Suporta a codificação de uma tupla ou uma ordem de tipo contendo uma tupla.
Esta ordem de tipo consiste em:tuple, bytes, então quando ligarexchange.IO()para codificação, você precisa continuar passando dois parâmetros:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Os parâmetros transmitidos devem igualmente ser coerentes com a estrutura e o tipo detuple, tal como definido notypesParâmetro do formulário: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)
}
Suporta a codificação sequencial de matrizes ou tipos contendo matrizes:
Oexchange.IO()A função encapsula oencodemétodo, que pode retornar o código de chamada de função parahexPara utilização específica, pode consultar as plataformas disponíveis publicamente
Oexchange.IO("encodePacked", ...)função é chamado de uma forma que é usado paraencodePacked encoding.
Oexchange.IO("encodePacked", ...)função retorna oencodePackeddados codificados.
cordel
exchange.IO(k, dataFormat,...args)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"encodePacked"significa que a função é utilizada para dadosencodePackedcodificação.
k
verdade
cordel
OdataFormatParâmetro utilizado para especificar o tipo e a ordem doencodePackeddados codificados.
DataFormat
verdade
cordel
OargParâmetro é usado para especificar o valor de dados específico que corresponde aodataFormatPode haver mais de umargParâmetro, tipo e número deargOs parâmetros dependem dadataFormatConfiguração de parâmetros.
arg
verdade
string, number, tuple, array, e todos os outros tipos suportados pelo sistema
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)
}
Quando utilizadoUniswap V3, você precisa passar em parâmetros como o caminho de troca, você precisa usar oencodePackedOperação de codificação:
Oexchange.IO("decode", ...)A função é chamada de uma forma que é usada para decodificação.
Oexchange.IO("decode", ...)Retorna uma cadeia quando há apenas um dado especificado pelodataFormatRetorna uma matriz quando há mais de um dado especificado pelodataFormatParâmetro.
matriz, string
exchange.IO(k, dadosFormato, dados)
OkParâmetro utilizado para definir a função doexchange.IO()função, e configurá-lo para"decode"significa que a função é utilizada para decodificação de dados.
k
verdade
cordel
OdataFormatO parâmetro é utilizado para especificar o tipo e a ordem dos dados decodificados.
DataFormat
verdade
cordel
OdataParâmetro utilizado para definir os dados a decodificar.
dados
verdade
cordel
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)
}
Função inversa doexchange.IO("encode", ...)Função:
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)
}
O seguinte exemplo realiza primeiro umencodePackedoperação nopathProcessamento de parâmetros, porque oexactOutputchamada de método que precisa ser codificada mais tarde requerpathcomo um parâmetro.encodeOexactOutputmétodo do contrato de roteamento, que tem apenas um parâmetro de tipotuple. Nome do métodoexactOutputé codificado como:0x09b81346, e utilizando oexchange.IO("decode", ...)método para decodificar o resultadodecodeRaw, consistente com a variáveldataTuple.
Para o processamento de dados, oexchange.IO()Função suporta não só codificação, mas também decodificação.
Oexchange.IO("key", ...)A função é chamada de uma forma para trocar chaves privadas.
exchange.IO(K, tecla)
O parâmetroké utilizado para definir a função doexchange.IO()função, definida em"key"significa que a função é utilizada para trocar a chave privada.
k
verdade
cordel
OkeyO parâmetro é usado para definir a chave privada.
Chave
verdade
cordel
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Oexchange.IO()A função suporta a troca de chaves privadas e pode manipular vários endereços de carteira.
Oexchange.IO("api", ...)A função é chamada de uma forma que é usada para chamar os métodos do contrato inteligente.
Oexchange.IO("api", ...)A função retorna o valor de retorno do método chamado contrato inteligente.
string, number, bool, object, array, null e todos os outros tipos suportados pelo sistema
exchange.IO(k, endereço, método)exchange.IO(k, endereço, método,...args)exchange.IO(k, endereço, método, valor,...args)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"api"indica que a função é utilizada para estender a solicitação de chamada.
k
verdade
cordel
OaddressO parâmetro é utilizado para especificar o endereço do contrato inteligente.
Endereço
verdade
cordel
OmethodO parâmetro é utilizado para especificar o método do contrato inteligente a ser chamado.
Método
verdade
cordel
OvalueO parâmetro é usado para definir a quantidade de ETH a ser enviada.stateMutabilityAtributo do método de contrato inteligente a executar épayable, em seguida, ovalueO parâmetro precisa ser passado."stateMutability": "payable"O atributo pode ser visualizado a partir do ABI.exchange.IO()A função determinará o parâmetro requerido com base nostateMutabilityO atributo no ABI que foi registrado.stateMutabilityatributo énonpayable, em seguida, ovalueParâmetro não precisa ser transmitido.
Valor
Falso
número, string
OargO parâmetro é usado para especificar os parâmetros do método do contrato inteligente a ser chamado.argParâmetro, tipo e número deargOs parâmetros dependem do método do contrato inteligente a ser chamado.
arg
Falso
string, number, bool e todos os outros tipos suportados pelo sistema
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
}
OdecimalsO método éconstantO método ERC20 que não incorre no consumo de gás e que pode consultar os dados de precisão de um token.decimalsO método não possui parâmetros. Valor de retorno: dados de precisão do token.
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"))
}
OallowanceO método éconstantO ERC20 é um método de ERC20 que não gera consumo de gás e pode consultar a quantidade autorizada de um token para um determinado endereço de contrato.allowanceO método leva 2 parâmetros, o primeiro é o endereço da carteira e o segundo é o endereço autorizado.
owner: o endereço da carteira, o exemplo é substituído pela cadeia spender: o endereço do contrato autorizado, o exemplo é substituído pela cadeia 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 || {})
}
OmulticallO método é um não-constantmétodo deUniswap V3que gera consumo de gás e é usado para resgatar tokens de várias maneiras.
Omulticallmétodo pode ter várias maneiras de passar parâmetros, você pode verificar o ABI que contém o método especificamente, você precisa registrar o ABI antes de chamar o método.
Para exemplos específicos demulticallOs métodos de chamadas podem ser consultados nas plataformas disponíveis publicamente.
Alguns detalhes são descritos aqui usando pseudo-código:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: endereço do roteador v2 do Uniswap V3.value: o montante de ETH a transferir, definido em 0 se o tokenIn da operação de troca não for o ETH.deadline: deadlineé o parâmetro domulticallmétodo, que pode ser definido como (new Date().getTime() / 1000) + 3600, indicando que é válido por uma hora.data: dataé o parâmetro domulticallmétodo, os dados da operação de embalagem a realizar.
Semelhante aexchange.IO("api", "eth", "send", "toAddress", toAmount), ogasLimit/gasPrice/nonceconfiguração do método chamada pode ser especificado ao chamar omulticallmétodo.
Novamente, usamos pseudo-código para descrever:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
O parâmetro{gasPrice: 11, gasLimit: 111, nonce: 111}O sistema pode ser definido de acordo com as necessidades específicas, que é definido para o último parâmetro doexchange.IO()função.
Pode omitir ononcee usar o valor padrão do sistema, ou deixargasLimit/gasPrice/nonceDesativar e usar o valor padrão do sistema para todos.
Oexchange.IO("address")A função é chamada de forma a obter o endereço da carteira configurada pelo objeto de troca {@var/EXCHANGE exchange}.
Oexchange.IO("address")A função devolve o endereço de carteira configurado.
cordel
exchange.IO(k)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"address"significa que a função é utilizada para obter o endereço de carteira configurado.
k
verdade
cordel
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Oexchange.IO("base", ...)A função é chamada de forma a definir o endereço do nó RPC.
exchange.IO(k, endereço)
OkParâmetro utilizado para definir a função doexchange.IO()função, definida em"base"significa que a função é utilizada para alternar os nós RPC.
k
verdade
cordel
OaddressParâmetro utilizado para definir o endereço do nó RPC.
Endereço
verdade
cordel
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}
OTA.MACD()função é utilizada para calcular oIndicador MACD de dissimilaridade e similaridade suavizada exponencial.
O valor de retorno doTA.MACD()função é uma matriz bidimensional com a estrutura:[DIF, DEA, MACD]- Não.
matriz
TA.MACD ((inReal) TA.MACD ((inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInFastPeriodO parâmetro é utilizado para definir o período rápido.
optInFastPeriod
Falso
Número
OoptInSlowPeriodO parâmetro é utilizado para definir o período lento.
optInSlowPeriod
Falso
Número
OoptInSignalPeriodO parâmetro é utilizado para definir o período do sinal.
OptInSignalPeriodo
Falso
Número
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]);
}
OTAA biblioteca de indicadores do FMZ Quant, otimizada para algoritmos de indicadores comuns.JavaScript, Python, C++chamadas de estratégia linguística,código de biblioteca TA de código aberto- Não.
Os valores por defeito dooptInFastPeriod, optInSlowPeriod, eoptInSignalPeriodParâmetros doTA.MACD()função são:12, 26, e9.
Não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.KDJ()função é usada para calcularIndicadores estocásticos.
O valor de retorno doTA.KDJ()função é uma matriz bidimensional com a estrutura:[K, D, J]- Não.
matriz
TA.KDJ ((inReal) TA.KDJ ((inReal, período, kPeriodo, dPeriodo)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OperiodO parâmetro é utilizado para definir o período 1.
período
Falso
Número
OkPeriodO parâmetro é utilizado para definir o período 2.
Período
Falso
Número
OdPeriodO parâmetro é utilizado para definir o período 3.
dPeriodo
Falso
Número
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]);
}
Os valores por defeito para operiod, kPeriod, edPeriodParâmetros doTA.KDJ()função são:9, 3, e3.
Não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.RSI()função é utilizada para calcular oIndicador de Força.
O valor de retorno doTA.RSI()Função é: uma matriz unidimensional.
matriz
TA.RSI ((inReal) TA.RSI ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é utilizado para definir o período.
optInTimePeriodo
Falso
Número
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);
}
O valor por defeito dooptInTimePeriodParâmetro doTA.RSI()função é:14.
Não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.ATR()função é utilizada para calcular oIndicador médio de volatilidade verdadeira.
O valor de retorno doTA.ATR()Função é: uma matriz unidimensional.
matriz
TA.ATR ((inPriceHLC) TA.ATR ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodO parâmetro é utilizado para definir o período.
optInTimePeriodo
Falso
Número
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);
}
O valor por defeito dooptInTimePeriodParâmetro doTA.ATR()função é:14.
Não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.OBV()função é utilizada para calcular oIndicador de maré energética.
O valor de retorno doTA.OBV()Função é: uma matriz unidimensional.
matriz
TA.OBV ((inReal) TA.OBV ((inReal, inPriceV)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OinPriceVO parâmetro é utilizado para especificar os dados do montante da transacção.
InPriceV
Falso
{@struct/Record Record} matriz de estrutura
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);
}
Não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.MA()função é utilizada para calcular oIndicador MACD.
O valor de retorno doTA.MA()Função é: uma matriz unidimensional.
matriz
TA.MA(inReal)TA.MA(inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é utilizado para definir o período.
optInTimePeriodo
Falso
Número
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);
}
O valor por defeito dooptInTimePeriodParâmetro doTA.MA()função é:9.
A partir de 1 de janeiro de 2016, a Comissão Europeia publicou um relatório sobre a aplicação da legislação em matéria de proteção dos dados pessoais, que inclui uma análise dos dados pessoais e dos dados pessoais, bem como uma análise dos dados pessoais.
OTA.EMA()função é utilizada para calcular oindicador médio exponencial.
O valor de retorno doTA.EMA()Função é: uma matriz unidimensional.
matriz
TA.EMA ((inReal) TA.EMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é utilizado para definir o período.
optInTimePeriodo
Falso
Número
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);
}
}
O valor por defeito dooptInTimePeriodParâmetro doTA.EMA()função é:9.
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.BOLL()função é utilizada para calcular oIndicador da banda de Bollinger.
O valor de retorno doTA.BOLL()função é uma matriz bidimensional com a estrutura:[upLine, midLine, downLine]- Não.
matriz
O que é isso? TA.BOLL ((inReal, ponto, multiplicador)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OperiodO parâmetro é utilizado para definir o período.
período
Falso
Número
OmultiplierO parâmetro é utilizado para definir o multiplicador.
Multiplicador
Falso
Número
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);
}
}
Os valores por defeito para operiodemultiplierParâmetros doTA.BOLL()função são:20e2.
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.Alligator()função é utilizada para calcular oIndicador do jacaré.
O valor de retorno doTA.Alligator()função é uma matriz bidimensional com a estrutura:[jawLine, teethLine, lipsLine]- Não.
matriz
TA. Alligator ((inReal) TA.Alligator ((inReal, mandíbulaLength, dentesLength, lábiosLength)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OjawLengthO parâmetro é utilizado para definir o período da mandíbula.
MaxilarDuração
Falso
Número
OteethLengthParâmetro utilizado para definir o período dos dentes.
DentesLongo
Falso
Número
OlipsLengthO parâmetro é utilizado para definir o período do lábio superior.
Lábios comprimento
Falso
Número
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]);
}
Os valores por defeito dojawLength, teethLength, elipsLengthParâmetros doTA.Alligator()função são:13, 8, e5.
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não.
OTA.CMF()função é utilizada para calcular oIndicador de fluxo de caixa Chaikin.
O valor de retorno doTA.CMF()Função é: uma matriz unidimensional.
matriz
TA.CMF ((inReal) TA.CMF ((inReal, inPriceV)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OinPriceVO parâmetro é utilizado para especificar os dados de volume.
InPriceV
Falso
{@struct/Record Record} matriz de estrutura
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);
}
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.Highest()função é utilizada para calcular oPreço mais elevado do período.
OTA.Highest()função retorna o valor máximo de um atributo no último período determinado, excluindo o Bar atual.
Número
TA.Mais elevado (inReal) TA.Mais elevado ((inReal, período, attr)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OperiodO parâmetro é utilizado para definir o período.
período
Falso
Número
OattrParâmetro é utilizado para definir os atributos, opcionalmente:Open, Close, Low, High, Volume, OpenInterest- Não.
atr
Falso
cordel
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);
}
Por exemplo, se oTA.Highest(records, 30, "High")função é chamada, se o parâmetro períodoperiodestá definido em0, significa calcular todos osBarsdos dados da linha K transmitidos peloinRealParâmetro; se o parâmetro do atributoattrSe não for especificado, os dados da linha K transmitidos peloinRealO parâmetro é considerado uma matriz ordinária.
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
OTA.Lowest()função é utilizada para calcular oPreço mais baixo do período.
OTA.Lowest()função retorna o valor mínimo de um atributo no último período determinado, excluindo o Bar atual.
Número
TA.Lowest ((inReal) TA.Mais baixo ((inReal, período, attr)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OperiodO parâmetro é utilizado para definir o período.
período
Falso
Número
OattrParâmetro é utilizado para definir os atributos, opcionalmente:Open, Close, Low, High, Volume, OpenInterest- Não.
atr
Falso
cordel
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);
}
Por exemplo, se oTA.Lowest(records, 30, "Low")função é chamada, se o parâmetro períodoperiodestá definido em0, significa calcular todos osBarsdos dados da linha K transmitidos peloinRealParâmetro; se o parâmetro do atributoattrSe não for especificado, os dados da linha K transmitidos peloinRealO parâmetro é considerado uma matriz ordinária.
A utilização doTA.Highest()eTA.Lowest()funções noC++A estratégia deve observar que oHighest()eLowest()Funções cada um tem apenas 2 parâmetros.
E o primeiro parâmetro passado não é o K-linha de dadosrObtido quando a funçãoauto r = exchange.GetRecords()Foi chamado.
Precisas de ligar para orMétodo e passar nos dados do atributo específico.r.Close()dados relativos ao preço de fechamento.Close, High, Low, Open, Volumecomo nor.Close()Método de chamada.
Exemplo de ensaio deC++Estratégia linguística:
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);
}
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não.
OTA.SMA()função é utilizada para calcular oIndicador de média móvel simples.
O valor de retorno doTA.SMA()Função é: uma matriz unidimensional.
matriz
TA.SMA ((inReal) TA.SMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é utilizado para definir o período.
optInTimePeriodo
Falso
Número
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);
}
O valor por defeito dooptInTimePeriodParâmetro doTA.SMA()função é:9.
Não, não, não, não, não, não, não, não.TA.MANão, não, não, não, não, não, não, não.
Otalib.CDL2CROWS()função é usada para calcularDois Corvos (gráfico de linhas K - Dois Corvos).
O valor de retorno dotalib.CDL2CROWS()Função é uma matriz unidimensional.
matriz
Talib.CDL2CROWS ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL2CROWS()A função é descrita na documentação da biblioteca talib como:CDL2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)Para chamadas noPythonlinguagem, os parâmetros de passagem são diferentes e devem basear-se na descrição acima:Records[Open,High,Low,Close].
Exemplo de divisão de uma variávelrecords(ou seja, parâmetroinPriceOHLC, digite {@struct/Record Record} matriz de estruturas) em:Openlista: escrito em Python comorecords.Open.
Highlista: escrito comorecords.Highem Python.Lowlista: escrito em Python comorecords.Low.
Closelista: escrito em Python comorecords.Close.
Chamado em código de estratégia Python:
talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
O outro.talibOs indicadores são descritos da mesma forma e não serão repetidos.
Otalib.CDL3BLACKCROWS()função é usada para calcularTrês Corvos Negros (quadro de linhas K - Três Corvos Negros).
O valor de retorno dotalib.CDL3BLACKCROWS()Função é: uma matriz unidimensional.
matriz
Talib.CDL3BLACKCROWS ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL3BLACKCROWS()A função é descrita na documentação da biblioteca talib como:CDL3BLACKCROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDL3INSIDE()função é usada para calcularTrês dentro para cima/abaixo (gráfico de linha K: Três dentro para cima/abaixo).
O valor de retorno dotalib.CDL3INSIDE()Função é: uma matriz unidimensional.
matriz
Talib.CDL3INSIDE ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL3INSIDE()A função é descrita na documentação da biblioteca talib como:CDL3INSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDL3LINESTRIKE()função é utilizada para calcular oGreve de três linhas (gráfico de linhas K: Greve de três linhas).
O valor de retorno dotalib.CDL3LINESTRIKE()Função é: uma matriz unidimensional.
matriz
Talib.CDL3LINESTRIKE ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL3LINESTRIKE()A função é descrita na documentação da biblioteca talib como:CDL3LINESTRIKE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDL3OUTSIDE()função é usada para calcularTrês fora para cima/abaixo (gráfico de linha K: Três fora para cima/abaixo).
O valor de retorno dotalib.CDL3OUTSIDE()Função é: uma matriz unidimensional.
matriz
Talib.CDL3OUTSIDE ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL3OUTSIDE()A função é descrita na documentação da biblioteca talib como:CDL3OUTSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDL3STARSINSOUTH()função é usada para calcularTrês estrelas no sul (quadro de linhas K: Três estrelas no sul).
O valor de retorno dotalib.CDL3STARSINSOUTH()Função é: uma matriz unidimensional.
matriz
Talib.CDL3STARSINSOUTH ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL3STARSINSOUTH()A função é descrita na documentação da biblioteca talib como:CDL3STARSINSOUTH(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDL3WHITESOLDIERS()função é usada para calcularTrês soldados brancos avançando (gráfico de linha K: Três soldados brancos avançando).
O valor de retorno dotalib.CDL3WHITESOLDIERS()Função é: uma matriz unidimensional.
matriz
Talib.CDL3BLANCOSOLDADORES (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDL3WHITESOLDIERS()A função é descrita na documentação da biblioteca talib como:CDL3WHITESOLDIERS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLABANDONEDBABY()função é usada para calcularBebê abandonado (gráfico de linhas K: Bebê abandonado).
O valor de retorno dotalib.CDLABANDONEDBABY()Função é: uma matriz unidimensional.
matriz
Talib.CDLABANDONEDBABY (em inglês) Talib.CDLABANDONEDBABY ((inPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é usado para definir a penetração, o valor padrão é 0,3.
OptInPenetration
Falso
Número
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);
}
OCDLABANDONEDBABY()A função é descrita na documentação da biblioteca talib como:CDLABANDONEDBABY(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Otalib.CDLADVANCEBLOCK()função é utilizada para calcular oBloco de avanço (gráfico de linhas K: Avanço).
O valor de retorno dotalib.CDLADVANCEBLOCK()Função é uma matriz unidimensional.
matriz
Talib.CDLADVANCEBLOCK ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLADVANCEBLOCK()A função é descrita na documentação da biblioteca talib como:CDLADVANCEBLOCK(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLBELTHOLD()função é utilizada para calcular oSegurança do cinto (gráfico de linha K: Segurança do cinto).
O valor de retorno dotalib.CDLBELTHOLD()Função é: uma matriz unidimensional.
matriz
Talib.CDLBELTHOLD ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLBELTHOLD()A função é descrita na documentação da biblioteca talib como:CDLBELTHOLD(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLBREAKAWAY()função é utilizada para calcular oBreakaway (gráfico de linhas K: Breakaway).
O valor de retorno dotalib.CDLBREAKAWAY()Função é: uma matriz unidimensional.
matriz
Talib.CDLBREAKAWAY ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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()A função é descrita na documentação da biblioteca talib como:CDLBREAKAWAY(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLCLOSINGMARUBOZU()função é usada para calcularFechamento de Marubozu (gráfico de linha K: fechamento descalço e descalço).
O valor de retorno dotalib.CDLCLOSINGMARUBOZU()Função é: uma matriz unidimensional.
matriz
Talib.CDLCLOSINGMARUBOZU ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLCLOSINGMARUBOZU()A função é descrita na documentação da biblioteca talib como:CDLCLOSINGMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLCONCEALBABYSWALL()função é utilizada para calcular oOcultando Baby Swallow (gráfico de linha K: Ocultando Baby Swallow padrão).
O valor de retorno dotalib.CDLCONCEALBABYSWALL()Função é: uma matriz unidimensional.
matriz
Talib.CDLCONCEALBABYSWALL (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLCONCEALBABYSWALL()A função é descrita na documentação da biblioteca talib como:CDLCONCEALBABYSWALL(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLCOUNTERATTACK()função é usada para calcularContra-ataque (quadro de linhas K: Contra-ataque).
O valor de retorno dotalib.CDLCOUNTERATTACK()Função é uma matriz unidimensional.
matriz
Talib.CDLContra-ataque ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLCOUNTERATTACK()A função é descrita na documentação da biblioteca talib como:CDLCOUNTERATTACK(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLDARKCLOUDCOVER()função é usada para calcularCobertura de nuvens escuras (gráfico de linha K: cobertura de nuvens escuras).
O valor de retorno dotalib.CDLDARKCLOUDCOVER()Função é uma matriz unidimensional.
matriz
Talib.CDDARKCLOUDCOVER ((inPriceOHLC) Talib.CDLDARKCLOUDCOVER ((inPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é usado para definir a penetração, o valor padrão é 0,5.
OptInPenetration
Falso
Número
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);
}
OCDLDARKCLOUDCOVER()A função é descrita na documentação da biblioteca talib como:CDLDARKCLOUDCOVER(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Otalib.CDLDOJI()função é usada para calcularDoji (gráfico de linhas K: Doji).
O valor de retorno dotalib.CDLDOJI()Função é: uma matriz unidimensional.
matriz
Talib.CDLDOJI ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLDOJI()A função é descrita na documentação da biblioteca talib como:CDLDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLDOJISTAR()função é utilizada para calcular oDoji Star (quadro de linhas K: Doji Star).
O valor de retorno dotalib.CDLDOJISTAR()Função é: uma matriz unidimensional.
matriz
Talib.CDLDOJISTAR ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLDOJISTAR()A função é descrita na documentação da biblioteca talib como:CDLDOJISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLDRAGONFLYDOJI()função é usada para calcularDragonfly Doji (quadro de linhas K: Dragonfly Doji).
O valor de retorno dotalib.CDLDRAGONFLYDOJI()Função é: uma matriz unidimensional.
matriz
Talib.CDLDRAGONFLYDOJI (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLDRAGONFLYDOJI()A função é descrita na documentação da biblioteca talib como:CDLDRAGONFLYDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLENGULFING()função é utilizada para calcular oPadrão de engulfamento (gráfico de linha K: engulfamento).
O valor de retorno dotalib.CDLENGULFING()Função é uma matriz unidimensional.
matriz
Talib.CDLENGULFING ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLENGULFING()A função é descrita na documentação da biblioteca talib como:CDLENGULFING(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLEVENINGDOJISTAR()função é utilizada para calcular oEstrela Doji da Noite (gráfico de linha K: Estrela Doji da Noite).
O valor de retorno dotalib.CDLEVENINGDOJISTAR()Função é: uma matriz unidimensional.
matriz
Talib.CDLEVENINGDOJISTAR (em inglês) Talib.CDLEVENINGDOJISTAR ((inPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é usado para definir a penetração, o valor padrão é 0,3.
OptInPenetration
Falso
Número
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);
}
OCDLEVENINGDOJISTAR()A função é descrita na documentação da biblioteca talib como:CDLEVENINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Otalib.CDLEVENINGSTAR()função é utilizada para calcular oEstrela da Noite (gráfico de linha K: Estrela da Noite).
O valor de retorno dotalib.CDLEVENINGSTAR()Função é: uma matriz unidimensional.
matriz
Talib.CDLEVENINGSTAR (em inglês) Talib.CDLEVENINGSTAR ((inPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é usado para definir a penetração, o valor padrão é 0,3.
OptInPenetration
Falso
Número
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);
}
OCDLEVENINGSTAR()A função é descrita na documentação da biblioteca talib como:CDLEVENINGSTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Otalib.CDLGAPSIDESIDEWHITE()função é usada para calcularLinhas brancas laterais de abertura para cima/para baixo (gráfico de linhas K: linhas brancas laterais de abertura para cima/para baixo).
O valor de retorno dotalib.CDLGAPSIDESIDEWHITE()Função é: uma matriz unidimensional.
matriz
Talib.CDLGAPSIDESIDEWHITE ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLGAPSIDESIDEWHITE()A função é descrita na documentação da biblioteca talib como:CDLGAPSIDESIDEWHITE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLGRAVESTONEDOJI()função é utilizada para calcular oGravestone Doji (quadro de linhas K: Gravestone Doji).
O valor de retorno dotalib.CDLGRAVESTONEDOJI()Função é: uma matriz unidimensional.
matriz
Talib.CDLGRAVESTONEDOJI (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLGRAVESTONEDOJI()A função é descrita na documentação da biblioteca talib como:CDLGRAVESTONEDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHAMMER()função é usada para calcularMartelo (quadro de linhas K: Martelo).
O valor de retorno dotalib.CDLHAMMER()Função é: uma matriz unidimensional.
matriz
Talib.CDLHAMMER ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHAMMER()A função é descrita na documentação da biblioteca talib como:CDLHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHANGINGMAN()função é usada para calcularHanging Man (quadro de linhas K: Hanging Man).
O valor de retorno dotalib.CDLHANGINGMAN()Função é uma matriz unidimensional.
matriz
Talib.CDLHANGINGMAN (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHANGINGMAN()A função é descrita na documentação da biblioteca talib como:CDLHANGINGMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHARAMI()função é utilizada para calcular oPadrão Harami (gráfico de linhas K: linhas negativas e positivas).
O valor de retorno dotalib.CDLHARAMI()Função é uma matriz unidimensional.
matriz
Talib.CDLHARAMI ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHARAMI()A função é descrita na documentação da biblioteca talib como:CDLHARAMI(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHARAMICROSS()função é utilizada para calcular oPadrão cruzado de Harami (gráfico de linhas K: linhas negativas e positivas cruzadas).
O valor de retorno dotalib.CDLHARAMICROSS()Função é: uma matriz unidimensional.
matriz
Talib.CDLHARAMICROSS ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHARAMICROSS()A função é descrita na documentação da biblioteca talib como:CDLHARAMICROSS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHIGHWAVE()função é utilizada para calcular oCandela de onda alta (gráfico de linha K: Long Leg Cross).
O valor de retorno dotalib.CDLHIGHWAVE()Função é uma matriz unidimensional.
matriz
Talib.CDLHIGHWAVE ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHIGHWAVE()A função é descrita na documentação da biblioteca talib como:CDLHIGHWAVE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHIKKAKE()função é utilizada para calcular oPadrão Hikkake (gráfico de linha K: armadilha).
O valor de retorno dotalib.CDLHIKKAKE()Função é uma matriz unidimensional.
matriz
Talib.CDLHIKKAKE ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHIKKAKE()A função é descrita na documentação da biblioteca talib como:CDLHIKKAKE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHIKKAKEMOD()função é utilizada para calcular oPadrão de Hikkake modificado (gráfico de linha K: armadilha modificada).
O valor de retorno dotalib.CDLHIKKAKEMOD()Função é: uma matriz unidimensional.
matriz
Talib.CDLHIKKAKEMOD ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHIKKAKEMOD()A função é descrita na documentação da biblioteca talib como:CDLHIKKAKEMOD(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLHOMINGPIGEON()função é utilizada para calcular oPomba-de-caminho (gráfico de linhas K: Pomba).
O valor de retorno dotalib.CDLHOMINGPIGEON()Função é: uma matriz unidimensional.
matriz
Talib.CDLHOMINGPIGEON ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLHOMINGPIGEON()A função é descrita na documentação da biblioteca talib como:CDLHOMINGPIGEON(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLIDENTICAL3CROWS()função é usada para calcularTrês corvos idênticos (quadro de linhas K: os mesmos três corvos).
O valor de retorno dotalib.CDLIDENTICAL3CROWS()Função é: uma matriz unidimensional.
matriz
Talib.CDLIDENTICAL3CROWS (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLIDENTICAL3CROWS()A função é descrita na documentação da biblioteca talib como:CDLIDENTICAL3CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLINNECK()função é utilizada para calcular oPadrão no pescoço (gráfico de linhas K: decote).
O valor de retorno dotalib.CDLINNECK()Função é: uma matriz unidimensional.
matriz
Talib.CDLINNECK ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLINNECK()A função é descrita na documentação da biblioteca talib como:CDLINNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLINVERTEDHAMMER()função é utilizada para calcular oMartelo invertido (gráfico de linhas K: Martelo invertido).
O valor de retorno dotalib.CDLINVERTEDHAMMER()Função é: uma matriz unidimensional.
matriz
Talib.CDLINVERTEDHAMMER ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLINVERTEDHAMMER()A função é descrita na documentação da biblioteca talib como:CDLINVERTEDHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLKICKING()função é usada para calcularChute (quadro de linhas K: chute).
O valor de retorno dotalib.CDLKICKING()Função é uma matriz unidimensional.
matriz
Talib.CDLKICKING ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLKICKING()A função é descrita na documentação da biblioteca talib como:CDLKICKING(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLKICKINGBYLENGTH()função é utilizada para calcular okick - touro/urso determinado pelo Marubozu mais longo (gráfico de linha K: kick bull/kick bear).
O valor de retorno dotalib.CDLKICKINGBYLENGTH()Função é: uma matriz unidimensional.
matriz
Talib.CDLKICKINGGBYLENGTH ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLKICKINGBYLENGTH()A função é descrita na documentação da biblioteca talib como:CDLKICKINGBYLENGTH(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLLADDERBOTTOM()função é utilizada para calcular oBase da escada (gráfico de linhas K: Base da escada).
O valor de retorno dotalib.CDLLADDERBOTTOM()Função é: uma matriz unidimensional.
matriz
Talib.CDLLADDERBOTTOM (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLLADDERBOTTOM()A função é descrita na documentação da biblioteca talib como:CDLLADDERBOTTOM(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLLONGLEGGEDDOJI()função é utilizada para calcular oDoji de pernas longas (gráfico de linha K: Doji de pernas longas).
O valor de retorno dotalib.CDLLONGLEGGEDDOJI()Função é: uma matriz unidimensional.
matriz
Talib.CDLLONGLEGGEDDOJI ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLLONGLEGGEDDOJI()A função é descrita na documentação da biblioteca talib como:CDLLONGLEGGEDDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLLONGLINE()função é utilizada para calcular oLâmpada de linha longa (gráfico de linha K: linha longa).
O valor de retorno dotalib.CDLLONGLINE()Função é: uma matriz unidimensional.
matriz
Talib.CDLLONGLINE ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLLONGLINE()A função é descrita na documentação da biblioteca talib como:CDLLONGLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLMARUBOZU()função é utilizada para calcular oMarubozu (gráfico de linhas K: cabeça nua e pé nu).
O valor de retorno dotalib.CDLMARUBOZU()Função é uma matriz unidimensional.
matriz
Talib.CDLMARUBOZU ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLMARUBOZU()A função é descrita na documentação da biblioteca talib como:CDLMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLMATCHINGLOW()função é usada para calcularBaixo de correspondência (gráfico de linhas K: Baixo de correspondência).
O valor de retorno dotalib.CDLMATCHINGLOW()Função é: uma matriz unidimensional.
matriz
Talib.CDLMATCHINGLOW ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLMATCHINGLOW()A função é descrita na documentação da biblioteca talib como:CDLMATCHINGLOW(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLMATHOLD()função é usada para calcularManutenção do tapete (gráfico de linha K: Manutenção do tapete).
O valor de retorno dotalib.CDLMATHOLD()Função é: uma matriz unidimensional.
matriz
Talib.CDLMATHOLD ((emPriceOHLC) Talib.CDLMATHOLD ((inPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é opcional e é utilizado para especificar a percentagem da largura da linha de tendência ascendente/descensiva, o valor por defeito é 0,5.
OptInPenetration
Falso
Número
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);
}
OCDLMATHOLD()A função é descrita na documentação da biblioteca talib como:CDLMATHOLD(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Otalib.CDLMORNINGDOJISTAR()função é utilizada para calcular oEstrela do Doji da manhã (gráfico de linha K: Estrela do Doji da manhã).
O valor de retorno dotalib.CDLMORNINGDOJISTAR()Função é: uma matriz unidimensional.
matriz
Talib.CDLMORNINGDOJISTAR (em inglês) Talib.CDLMORNINGDOJISTAR ((emPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é utilizado para especificar o grau de sobreposição entre o preço de abertura da validação e a parte sólida, o valor por defeito é 0,3.
OptInPenetration
Falso
Número
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);
}
OCDLMORNINGDOJISTAR()A função é descrita na documentação da biblioteca talib como:CDLMORNINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Otalib.CDLMORNINGSTAR()função é usada para calcularEstrela da Manhã (gráfico de linha K: Estrela da Manhã).
O valor de retorno dotalib.CDLMORNINGSTAR()Função é: uma matriz unidimensional.
matriz
Talib.CDLMORNINGSTAR ((emPriceOHLC) Talib.CDLMORNINGSTAR ((inPriceOHLC, optInPenetration)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInPenetrationO parâmetro é o limiar de percentagem de flutuação de preços exigido para a confirmação da tendência e assume um valor no intervalo [0,1], com um valor por defeito de 0,3.
OptInPenetration
Falso
Número
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);
}
OCDLMORNINGSTAR()A função é descrita na documentação da biblioteca talib como:CDLMORNINGSTAR(Records[Open,High,Low,Close],Penetration=0.3) = Array(outInteger)
Otalib.CDLONNECK()função é utilizada para calcular oPadrão no pescoço (gráfico de linha K: Padrão no pescoço).
O valor de retorno dotalib.CDLONNECK()Função é uma matriz unidimensional.
matriz
Talib.CDLONNECK ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLONNECK()A função é descrita na documentação da biblioteca talib como:CDLONNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLPIERCING()função é utilizada para calcular oPadrão de piercing (gráfico de linha K: Padrão de piercing).
O valor de retorno dotalib.CDLPIERCING()Função é uma matriz unidimensional.
matriz
Talib.CDLPIERCING ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLPIERCING()A função é descrita na documentação da biblioteca talib como:CDLPIERCING(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLRICKSHAWMAN()função é usada para calcularRickshaw Man (quadro de linhas K: Rickshaw Man).
O valor de retorno dotalib.CDLRICKSHAWMAN()Função é: uma matriz unidimensional.
matriz
Talib.CDLRICKSHAWMAN (em inglês)
OinPriceOHLCParâmetro utilizado para especificar dados de linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLRICKSHAWMAN()A função é descrita na documentação da biblioteca talib como:CDLRICKSHAWMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLRISEFALL3METHODS()função é usada para calcularTrês métodos ascendentes/descendentes (gráfico de linhas K: Três métodos ascendentes/descendentes).
O valor de retorno dotalib.CDLRISEFALL3METHODS()Função é: uma matriz unidimensional.
matriz
Talib.CDLRISEFALL3METHODS ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLRISEFALL3METHODS()A função é descrita na documentação da biblioteca talib como:CDLRISEFALL3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLSEPARATINGLINES()função é usada para calcularLinhas de separação (gráfico de linhas K: Linhas de separação).
O valor de retorno dotalib.CDLSEPARATINGLINES()Função é uma matriz unidimensional.
matriz
Talib.CDLSEPARATINGLINES ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLSEPARATINGLINES()A função é descrita na documentação da biblioteca talib como:CDLSEPARATINGLINES(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLSHOOTINGSTAR()função é utilizada para calcular oShooting Star (quadro de linhas K: Shooting Star).
O valor de retorno dotalib.CDLSHOOTINGSTAR()Função é uma matriz unidimensional.
matriz
Talib.CDLSHOOTINGSTAR (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLSHOOTINGSTAR()A função é descrita na documentação da biblioteca talib como:CDLSHOOTINGSTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLSHORTLINE()função é utilizada para calcular oLâmpada de linha curta (gráfico de linha K: linha curta).
O valor de retorno dotalib.CDLSHORTLINE()Função é: uma matriz unidimensional.
matriz
Talib.CDLS SHORTLINE ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLSHORTLINE()A função é descrita na documentação da biblioteca talib como:CDLSHORTLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLSPINNINGTOP()função é usada para calcularSpinning Top (gráfico de linhas K: Spinning Top).
O valor de retorno dotalib.CDLSPINNINGTOP()Função é: uma matriz unidimensional.
matriz
Talib.CDLSPINNINGTOP ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLSPINNINGTOP()A função é descrita na documentação da biblioteca talib como:CDLSPINNINGTOP(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLSTALLEDPATTERN()função é usada para calcularPadrão paralisado (gráfico de linha K: Padrão paralisado).
O valor de retorno dotalib.CDLSTALLEDPATTERN()Função é: uma matriz unidimensional.
matriz
Talib.CDLSTALLEDPATTERN ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLSTALLEDPATTERN()A função é descrita na documentação da biblioteca talib como:CDLSTALLEDPATTERN(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLSTICKSANDWICH()função é utilizada para calcular oStick Sandwich (gráfico de linhas K: Stick Sandwich).
O valor de retorno dotalib.CDLSTICKSANDWICH()Função é uma matriz unidimensional.
matriz
Talib.CDLSTICKSANDWICH (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLSTICKSANDWICH()A função é descrita na documentação da biblioteca talib como:CDLSTICKSANDWICH(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLTAKURI()função é usada para calcularTakuri (doji da mosca-dragão com uma longa linha de sombra inferior) (gráfico de linhas K: Takuri).
O valor de retorno dotalib.CDLTAKURI()Função é uma matriz unidimensional.
matriz
Talib.CDLTAKURI ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLTAKURI()A função é descrita na documentação da biblioteca talib como:CDLTAKURI(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLTASUKIGAP()função é utilizada para calcular oTasuki Gap (gráfico de linha K: Tasuki Gap).
O valor de retorno dotalib.CDLTASUKIGAP()Função é uma matriz unidimensional.
matriz
Talib.CDLTASUKIGAP ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLTASUKIGAP()A função é descrita na documentação da biblioteca talib como:CDLTASUKIGAP(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLTHRUSTING()função é utilizada para calcular oPadrão de empurrão (gráfico de linha K: Padrão de empurrão).
O valor de retorno dotalib.CDLTHRUSTING()Função é: uma matriz unidimensional.
matriz
Talib.CDLTHRUSTING (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLTHRUSTING()A função é descrita na documentação da biblioteca talib como:CDLTHRUSTING(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLTRISTAR()função é utilizada para calcular oPadrão Tristar (gráfico de linha K: Padrão Tristar).
O valor de retorno dotalib.CDLTRISTAR()Função é: uma matriz unidimensional.
matriz
Talib.CDLTRISTAR ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLTRISTAR()A função é descrita na documentação da biblioteca talib como:CDLTRISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLUNIQUE3RIVER()função é utilizada para calcular oUnique 3 River (gráfico de linhas K: Unique 3 River).
O valor de retorno dotalib.CDLUNIQUE3RIVER()Função é: uma matriz unidimensional.
matriz
Talib.CDLUNIQUE3RIVER ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLUNIQUE3RIVER()A função é descrita na documentação da biblioteca talib como:CDLUNIQUE3RIVER(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLUPSIDEGAP2CROWS()função é usada para calcularGato de dois corvos (gráfico de linha K: Gato de dois corvos).
O valor de retorno dotalib.CDLUPSIDEGAP2CROWS()Função é: uma matriz unidimensional.
matriz
Talib.CDLUPSIDEGAP2CROWS (em inglês)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLUPSIDEGAP2CROWS()A função é descrita na documentação da biblioteca talib como:CDLUPSIDEGAP2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.CDLXSIDEGAP3METHODS()função é usada para calcularTrês métodos de diferenciação de preços (gráfico de linhas K: Três métodos de diferenciação de preços).
O valor de retorno dotalib.CDLXSIDEGAP3METHODS()Função é: uma matriz unidimensional.
matriz
Talib.CDLXSIDEGAP3METHODS ((emPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OCDLXSIDEGAP3METHODS()A função é descrita na documentação da biblioteca talib como:CDLXSIDEGAP3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Otalib.AD()função é utilizada para calcular oChaikin A/D Line (indicador estocástico de linha).
O valor de retorno dotalib.AD()Função é: uma matriz unidimensional.
matriz
talib.AD(inPriceHLCV)
OinPriceHLCVO parâmetro é utilizado para especificar os dados da linha K.
InPriceHLCV
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OAD()A função é descrita na documentação da biblioteca talib como:AD(Records[High,Low,Close,Volume]) = Array(outReal)
Otalib.ADOSC()função é utilizada para calcular oOscilador Chaikin A/D (Oscilador Chaikin).
O valor de retorno dotalib.ADOSC()Função é uma matriz unidimensional.
matriz
Talib.ADOSC ((inPriceHLCV) Talib.ADOSC ((inPriceHLCV, optInFastPeriod, optInSlowPeriod)
OinPriceHLCVO parâmetro é utilizado para especificar os dados da linha K.
InPriceHLCV
verdade
{@struct/Record Record} matriz de estrutura
OoptInFastPeriodO parâmetro é utilizado para definir o período rápido.
optInFastPeriod
Falso
Número
OoptInSlowPeriodO parâmetro é utilizado para definir o período lento.
optInSlowPeriod
Falso
Número
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);
}
OADOSC()A função é descrita na documentação da biblioteca talib como:ADOSC(Records[High,Low,Close,Volume],Fast Period = 3,Slow Period = 10) = Array(outReal)
Otalib.OBV()função é usada para calcularNo volume do balanço (maré de energia).
O valor de retorno dotalib.OBV()Função é uma matriz unidimensional.
matriz
Talib.OBV ((inReal) Talib.OBV ((inReal, inPriceV)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OinPriceVO parâmetro é utilizado para especificar os dados da linha K.
InPriceV
Falso
{@struct/Record Record} matriz de estrutura
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);
}
OOBV()A função é descrita na documentação da biblioteca talib como:OBV(Records[Close],Records[Volume]) = Array(outReal)
Otalib.ACOS()função é usada para calcularVector trigonométrico ACos (função inversa do cosseno).
O valor de retorno dotalib.ACOS()Função é uma matriz unidimensional.
matriz
Talib.ACOS ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OACOS()A função é descrita na documentação da biblioteca talib como:ACOS(Records[Close]) = Array(outReal)
Otalib.ASIN()função é utilizada para calcular oASin trigonométrico vetorial (função seno inversa).
O valor de retorno dotalib.ASIN()Função é uma matriz unidimensional.
matriz
Talib.ASIN ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OASIN()A função é descrita na documentação da biblioteca talib como:ASIN(Records[Close]) = Array(outReal)
Otalib.ATAN()função é utilizada para calcular oVector trigonométrico ATan (função de tangente inversa).
O valor de retorno dotalib.ATAN()Função é: uma matriz unidimensional.
matriz
Talib.ATAN ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OATAN()A função é descrita na documentação da biblioteca talib como:ATAN(Records[Close]) = Array(outReal)
Otalib.CEIL()função é usada para calcularTecto vetorial (função de arredondamento).
O valor de retorno dotalib.CEIL()Função é uma matriz unidimensional.
matriz
Talib.CEIL ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OCEIL()A função é descrita na documentação da biblioteca talib como:CEIL(Records[Close]) = Array(outReal)
Otalib.COS()função é utilizada para calcular oVector trigonométrico Cos (função cosseno).
O valor de retorno dotalib.COS()Função é: uma matriz unidimensional.
matriz
Talib.COS ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OCOS()A função é descrita na documentação da biblioteca talib como:COS(Records[Close]) = Array(outReal)
Otalib.COSH()função é usada para calcularCosh trigonométrico vetorial (valor de cosseno hiperbólico).
O valor de retorno dotalib.COSH()Função é uma matriz unidimensional.
matriz
Talib.COSH ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OCOSH()A função é descrita na documentação da biblioteca talib como:COSH(Records[Close]) = Array(outReal)
Otalib.EXP()função é utilizada para calcular oAritmética vetorial Exp (função exponencial).
O valor de retorno dotalib.EXP()Função é: uma matriz unidimensional.
matriz
Talib.EXP ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OEXP()A função é descrita na documentação da biblioteca talib como:EXP(Records[Close]) = Array(outReal)
Otalib.FLOOR()função é utilizada para calcular oPiso do vetor (arredondado para baixo).
O valor de retorno dotalib.FLOOR()Função é uma matriz unidimensional.
matriz
Talib.FLOOR ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OFLOOR()A função é descrita na documentação da biblioteca talib como:FLOOR(Records[Close]) = Array(outReal)
Otalib.LN()função é utilizada para calcular oVector Log Natural (logaritmo natural).
O valor de retorno dotalib.LN()Função é uma matriz unidimensional.
matriz
Talib.LN ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OLN()A função é descrita na documentação da biblioteca talib como:LN(Records[Close]) = Array(outReal)
Otalib.LOG10()função é usada para calcularVector Log10 (função logarítmica).
O valor de retorno dotalib.LOG10()Função é uma matriz unidimensional.
matriz
Talib.LOG10 ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OLOG10()A função é descrita na documentação da biblioteca talib como:LOG10(Records[Close]) = Array(outReal)
Otalib.SIN()função é usada para calcularVector trigonométrico Sin (valor seno).
O valor de retorno dotalib.SIN()Função é uma matriz unidimensional.
matriz
Talib.SIN ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OSIN()A função é descrita na documentação da biblioteca talib como:SIN(Records[Close]) = Array(outReal)
Otalib.SINH()função é utilizada para calcular oVector Trigonometric Sinh (função de seno hiperbólico).
O valor de retorno dotalib.SINH()Função é: uma matriz unidimensional.
matriz
Talib.SINH ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OSINH()A função é descrita na documentação da biblioteca talib como:SINH(Records[Close]) = Array(outReal)
Otalib.SQRT()função é utilizada para calcular oRaiz quadrada do vetor (raiz quadrada).
O valor de retorno dotalib.SQRT()Função é: uma matriz unidimensional.
matriz
Talib.SQRT ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OSQRT()A função é descrita na documentação da biblioteca talib como:SQRT(Records[Close]) = Array(outReal)
Otalib.TAN()função é utilizada para calcular oTrigonometria vetorial Tan (tangente).
O valor de retorno dotalib.TAN()Função é uma matriz unidimensional.
matriz
Talib.TAN (InReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OTAN()A função é descrita na documentação da biblioteca talib como:TAN(Records[Close]) = Array(outReal)
Otalib.TANH()função é utilizada para calcular oVector Trigonometric Tanh (função de tangente hiperbólica).
O valor de retorno dotalib.TANH()Função é: uma matriz unidimensional.
matriz
Talib.TANH ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OTANH()A função é descrita na documentação da biblioteca talib como:TANH(Records[Close]) = Array(outReal)
Otalib.MAX()A função é utilizada para calcular o valor máximo (máximo) para umperíodo específico.
O valor de retorno dotalib.MAX()Função é: uma matriz unidimensional.
matriz
Talib.MAX ((inReal) Talib.MAX ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OMAX()A função é descrita na documentação da biblioteca talib como:MAX(Records[Close],Time Period = 30) = Array(outReal)
Otalib.MAXINDEX()função é usada para calcularo índice do valor mais elevado no período especificado (índice máximo).
O valor de retorno dotalib.MAXINDEX()Função é: uma matriz unidimensional.
matriz
Talib.MAXINDEX ((inReal) Talib.MAXINDEX ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OMAXINDEX()A função é descrita na documentação da biblioteca talib como:MAXINDEX(Records[Close],Time Period = 30) = Array(outInteger)
Otalib.MIN()Função utilizada para calcular o valor mais baixo (valor mínimo)** para o período especificado.
O valor de retorno dotalib.MIN()Função é: uma matriz unidimensional.
matriz
Talib.MIN ((inReal) talib.MIN ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OMIN()A função é descrita na documentação da biblioteca talib como:MIN(Records[Close],Time Period = 30) = Array(outReal)
Otalib.MININDEX()função é usada para calcularo índice de valor mais baixo (índice de valor mínimo)para o período especificado.
O valor de retorno dotalib.MININDEX()Função é: uma matriz unidimensional.
matriz
Talib.MININDEX ((inReal) Talib.MININDEX ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OMININDEX()A função é descrita na documentação da biblioteca talib como:MININDEX(Records[Close],Time Period = 30) = Array(outInteger)
Otalib.MINMAX()função é usada para calcularOs valores mais baixos e mais elevados (mínimo e máximo) para o período especificado.
O valor de retorno dotalib.MINMAX()O primeiro elemento desta matriz bidimensional é a matriz de valores mínimos, e o segundo elemento é a matriz de valores máximos.
matriz
Talib.MINMAX ((inReal) Talib.MINMAX ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OMINMAX()A função é descrita na documentação da biblioteca talib como:MINMAX(Records[Close],Time Period = 30) = [Array(outMin),Array(outMax)]
Otalib.MINMAXINDEX()função é usada para calcularo índice dos valores mais baixos e mais altos (índice mínimo e máximo) no período especificado.
O valor de retorno dotalib.MINMAXINDEX()O primeiro elemento desta matriz bidimensional é a matriz indexada mínima, e o segundo elemento é a matriz indexada máxima.
matriz
Talib.MINMAXINDEX ((inReal) Talib.MINMAXINDEX ((em real, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OMINMAXINDEX()A função é descrita na documentação da biblioteca talib como:MINMAXINDEX(Records[Close],Time Period = 30) = [Array(outMinIdx),Array(outMaxIdx)]
Otalib.SUM()função é usada para calcularResumo.
O valor de retorno dotalib.SUM()Função é: uma matriz unidimensional.
matriz
talib.SUM ((inReal) talib.SUM ((emReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OSUM()A função é descrita na documentação da biblioteca talib como:SUM(Records[Close],Time Period = 30) = Array(outReal)
Otalib.HT_DCPERIOD()função é utilizada para calcular oTransformação de Hilbert - período do ciclo dominante (Transformação de Hilbert, período dominante).
O valor de retorno dotalib.HT_DCPERIOD()Função é: uma matriz unidimensional.
matriz
Talib.HT_DCPERIOD ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OHT_DCPERIOD()A função é descrita na documentação da biblioteca talib como:HT_DCPERIOD(Records[Close]) = Array(outReal)
Otalib.HT_DCPHASE()função é utilizada para calcular oTransformação de Hilbert - Fase do ciclo dominante.
O valor de retorno dotalib.HT_DCPHASE()Função é: uma matriz unidimensional.
matriz
Talib.HT_DCPHASE ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OHT_DCPHASE()A função é descrita na documentação da biblioteca talib como:HT_DCPHASE(Records[Close]) = Array(outReal)
Otalib.HT_PHASOR()função é utilizada para calcular oTransformação de Hilbert - Componentes de Fasor (Transformação de Hilbert, Componentes de Fase).
O valor de retorno dotalib.HT_PHASOR()Função é uma matriz bidimensional.
matriz
Talib.HT_PHASOR ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OHT_PHASOR()A função é descrita na documentação da biblioteca talib como:HT_PHASOR(Records[Close]) = [Array(outInPhase),Array(outQuadrature)]
Otalib.HT_SINE()função é utilizada para calcular oTransformação de Hilbert - onda senoidal.
O valor de retorno dotalib.HT_SINE()A função é: uma matriz bidimensional.
matriz
Talib.HT_SINE ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OHT_SINE()A função é descrita na documentação da biblioteca talib como:HT_SINE(Records[Close]) = [Array(outSine),Array(outLeadSine)]
Otalib.HT_TRENDMODE()função é utilizada para calcular oTransformação de Hilbert - Tendência e modo de ciclo.
O valor de retorno dotalib.HT_TRENDMODE()Função é: uma matriz unidimensional.
matriz
Talib.HT_TRENDMODE ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OHT_TRENDMODE()A função é descrita na documentação da biblioteca talib como:HT_TRENDMODE(Records[Close]) = Array(outInteger)
Otalib.ATR()função é utilizada para calcular oIntervalo verdadeiro médio.
O valor de retorno dotalib.ATR()Função é uma matriz unidimensional.
matriz
Talib.ATR ((inPriceHLC) Talib.ATR ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OATR()A função é descrita na documentação da biblioteca talib como:ATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.NATR()função é utilizada para calcular oIntervalo verdadeiro médio normalizado.
O valor de retorno dotalib.NATR()Função é uma matriz unidimensional.
matriz
Talib.NATR ((inPriceHLC) Talib.NATR ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
ONATR()A função é descrita na documentação da biblioteca talib como:NATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.TRANGE()função é utilizada para calcular oDistância real.
O valor de retorno dotalib.TRANGE()Função é: uma matriz unidimensional.
matriz
Talib.TRANGE (em preço)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OTRANGE()A função é descrita na documentação da biblioteca talib como:TRANGE(Records[High,Low,Close]) = Array(outReal)
Otalib.BBANDS()função é usada para calcularBandeiras de Bollinger.
O valor de retorno dotalib.BBANDS()A função é: uma matriz bidimensional. A matriz contém três elementos que são: a matriz de linha superior, a matriz de linha média e a matriz de linha inferior.
matriz
Talib.BBANDS ((inReal) Talib.BBANDS ((em real, optInTimePeriod) Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp) Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn) talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 5.
optInTimePeriodo
Falso
Número
OoptInNbDevUpO parâmetro é usado para definir o multiplicador de linha ascendente, o valor padrão é 2.
OptInNbDevUp
Falso
Número
OoptInNbDevDnO parâmetro é usado para definir o multiplicador da linha inferior, o valor padrão é 2.
OpInNbDevN
Falso
Número
OoptInMATypeO parâmetro é utilizado para definir o tipo médio, o valor por defeito é 0.
OptionInMAType
Falso
Número
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);
}
OBBANDS()A função é descrita na documentação da biblioteca talib como:BBANDS(Records[Close],Time Period = 5,Deviations up = 2,Deviations down = 2,MA Type = 0) = [Array(outRealUpperBand),Array(outRealMiddleBand),Array(outRealLowerBand)]
Otalib.DEMA()função é utilizada para calcular oMédia móvel exponencial dupla.
O valor de retorno dotalib.DEMA()Função é uma matriz unidimensional.
matriz
Talib.DEMA ((inReal) talib.DEMA ((em Real, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
ODEMA()A função é descrita na documentação da biblioteca talib como:DEMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.EMA()função é utilizada para calcular oMédia móvel exponencial.
O valor de retorno dotalib.EMA()Função é uma matriz unidimensional.
matriz
Talib.EMA ((inReal) talib.EMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OEMA()A função é descrita na documentação da biblioteca talib como:EMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.HT_TRENDLINE()função é utilizada para calcular oTransformação de Hilbert - Linha de tendência instantânea.
O valor de retorno dotalib.HT_TRENDLINE()Função é: uma matriz unidimensional.
matriz
Talib.HT_TRENDLINE ((inReal)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
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);
}
OHT_TRENDLINE()A função é descrita na documentação da biblioteca talib como:HT_TRENDLINE(Records[Close]) = Array(outReal)
Otalib.KAMA()função é utilizada para calcular oMédia Móvel Adaptativa de Kaufman.
O valor de retorno dotalib.KAMA()Função é: uma matriz unidimensional.
matriz
Talib.KAMA (InReal) Talib.KAMA (em Real, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OKAMA()A função é descrita na documentação da biblioteca talib como:KAMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.MA()função é utilizada para calcular oMédia móvel.
O valor de retorno dotalib.MA()Função é: uma matriz unidimensional.
matriz
talib.MA(inReal)talib.MA(inReal, optInTimePeriod)talib.MA(inReal, optInTimePeriod, optInMAType)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
OoptInMATypeO parâmetro é utilizado para definir o tipo médio, o valor por defeito é 0.
OptionInMAType
Falso
Número
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);
}
OMA()A função é descrita na documentação da biblioteca talib como:MA(Records[Close],Time Period = 30,MA Type = 0) = Array(outReal)
Otalib.MAMA()função é utilizada para calcular oMédia móvel adaptativa MESA.
O valor de retorno dotalib.MAMA()A função é: uma matriz bidimensional.
matriz
Talib.MAMA ((inReal) Talib.MAMA ((inReal, optInFastLimit) talib.MAMA ((inReal, optInFastLimit, optInSlowLimit)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInFastLimitO parâmetro é usado para definir o limite rápido, o valor padrão é 0,5.
OptInFastLimit
Falso
Número
OoptInSlowLimitO parâmetro é usado para definir o limite lento, o valor padrão é 0,05.
OptInSlowLimit
Falso
Número
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);
}
OMAMA()A função é descrita na documentação da biblioteca talib como:MAMA(Records[Close],Fast Limit = 0.5,Slow Limit = 0.05) = [Array(outMAMA),Array(outFAMA)]
Otalib.MIDPOINT()função é utilizada para calcular oPonto médio do período (ponto médio).
O valor de retorno dotalib.MIDPOINT()Função é uma matriz unidimensional.
matriz
Talib.MIDPOINT ((inReal)) talib.MIDPOINT ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OMIDPOINT()A função é descrita na documentação da biblioteca talib como:MIDPOINT(Records[Close],Time Period = 14) = Array(outReal)
Otalib.MIDPRICE()função é utilizada para calcular oPreço do ponto médio ao longo do período (preço do ponto médio).
O valor de retorno dotalib.MIDPRICE()Função é uma matriz unidimensional.
matriz
talib.MIDPRICE ((emPriceHL) talib.MIDPRICE ((inPriceHL, optInTimePeriod)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OMIDPRICE()A função é descrita na documentação da biblioteca talib como:MIDPRICE(Records[High,Low],Time Period = 14) = Array(outReal)
Otalib.SAR()função é utilizada para calcular oSAR parabólico.
O valor de retorno dotalib.SAR()Função é: uma matriz unidimensional.
matriz
Talib.SAR ((inPriceHL) Talib.SAR ((inPriceHL, optInAcceleration) Talib.SAR ((inPriceHL, optInAcceleration, optInMaximum)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInAccelerationO parâmetro é utilizado para definir o factor de aceleração, o valor por defeito é 0,02.
OptInAceleração
Falso
Número
OoptInMaximumO parâmetro é usado para definir o AF Maximum, o valor por defeito é 0,2.
OptInMaximum
Falso
Número
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);
}
OSAR()A função é descrita na documentação da biblioteca talib como:SAR(Records[High,Low],Acceleration Factor = 0.02,AF Maximum = 0.2) = Array(outReal)
Otalib.SAREXT()função é utilizada para calcular oSAR parabólica - Extensão (direção parabólica reforçada).
O valor de retorno dotalib.SAREXT()Função é uma matriz unidimensional.
matriz
Talib.SAREXT ((inPriceHL) talib.SAREXT ((inPriceHL, optInStartValue) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort) talib.SAREXT ((inPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort, optInAccelerationMaxShort)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInStartValueParâmetro é usado para definir o valor de início, o valor padrão é 0.
OptionInStartValue
Falso
Número
OoptInOffsetOnReverseO parâmetro é usado para definir Offset em Reverso, o valor padrão é 0.
OptInOffsetOnReverse
Falso
Número
OoptInAccelerationInitLongO parâmetro é usado para definir o AF Init Long, o valor padrão é 0,02.
OptInAccelerationInitLong
Falso
Número
OoptInAccelerationLongO parâmetro é usado para definir o AF Long, o valor padrão é 0,02.
OptInAccelerationLong
Falso
Número
OoptInAccelerationMaxLongO parâmetro é usado para definir o AF Max Long, o valor padrão é 0,2.
OptInAccelerationMaxLong
Falso
Número
OoptInAccelerationInitShortO parâmetro é usado para definir AF Init Short, o valor padrão é 0,02.
OpçãoInaceleraçãoInitShort
Falso
Número
OoptInAccelerationShortO parâmetro é usado para definir AF Short, o valor padrão é 0,02.
OptInAccelerationShort
Falso
Número
OoptInAccelerationMaxShortO parâmetro é usado para definir AF Max Short, o valor padrão é 0,2.
OptInAccelerationMaxShort
Falso
Número
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);
}
OSAREXT()A função é descrita na documentação da biblioteca talib como: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)
Otalib.SMA()função é usada para calcularMédia móvel simples.
O valor de retorno dotalib.SMA()Função é: uma matriz unidimensional.
matriz
Talib.SMA ((inReal) Talib.SMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OSMA()A função é descrita na documentação da biblioteca talib como:SMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.T3()função é utilizada para calcular oMédia móvel exponencial tripla (T3) (média móvel exponencial tripla).
O valor de retorno dotalib.T3()Função é uma matriz unidimensional.
matriz
Talib.T3 ((inReal) Talib.T3 ((inReal, optInTimePeriod) talib.T3 ((inReal, optInTimePeriod, optInVFactor)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 5.
optInTimePeriodo
Falso
Número
OoptInVFactorO parâmetro é usado para definir o Fator de Volume, o valor padrão é 0,7.
OptInVFactor
Falso
Número
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);
}
OT3()A função é descrita na documentação da biblioteca talib como:T3(Records[Close],Time Period = 5,Volume Factor = 0.7) = Array(outReal)
Otalib.TEMA()função é usada para calcularMédia móvel exponencial tripla.
O valor de retorno dotalib.TEMA()Função é uma matriz unidimensional.
matriz
Talib.TEMA ((inReal) talib.TEMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OTEMA()A função é descrita na documentação da biblioteca talib como:TEMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.TRIMA()função é utilizada para calcular oMédia móvel triangular (média móvel tri-exponencial).
O valor de retorno dotalib.TRIMA()Função é uma matriz unidimensional.
matriz
Talib.TRIMA ((inReal) Talib.TRIMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OTRIMA()A função é descrita na documentação da biblioteca talib como:TRIMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.WMA()função é utilizada para calcular oMédia móvel ponderada (WMA).
O valor de retorno dotalib.WMA()Função é uma matriz unidimensional.
matriz
Talib.WMA ((inReal) talib.WMA ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OWMA()A função é descrita na documentação da biblioteca talib como:WMA(Records[Close],Time Period = 30) = Array(outReal)
Otalib.LINEARREG()função é usada para calcularRegressão linear.
O valor de retorno dotalib.LINEARREG()Função é uma matriz unidimensional.
matriz
Talib.LINEARREG ((inReal) Talib.LINEARREG ((em real, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OLINEARREG()A função é descrita na documentação da biblioteca talib como:LINEARREG(Records[Close],Time Period = 14) = Array(outReal)
Otalib.LINEARREG_ANGLE()função é utilizada para calcular oÂngulo de regressão linear.
O valor de retorno dotalib.LINEARREG_ANGLE()Função é: uma matriz unidimensional.
matriz
Talib.LINEARREG_ANGLE ((inReal) talib.LINEARREG_ANGLE ((em real, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OLINEARREG_ANGLE()A função é descrita na documentação da biblioteca talib como:LINEARREG_ANGLE(Records[Close],Time Period = 14) = Array(outReal)
Otalib.LINEARREG_INTERCEPT()função é utilizada para calcular oInterceptação de regressão linear.
O valor de retorno dotalib.LINEARREG_INTERCEPT()Função é: uma matriz unidimensional.
matriz
Talib.LINEARREG_INTERCEPT (em real) talib.LINEARREG_INTERCEPT ((em real, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OLINEARREG_INTERCEPT()A função é descrita na documentação da biblioteca talib como:LINEARREG_INTERCEPT(Records[Close],Time Period = 14) = Array(outReal)
Otalib.LINEARREG_SLOPE()função é utilizada para calcular oInclinação de regressão linear.
O valor de retorno dotalib.LINEARREG_SLOPE()Função é: uma matriz unidimensional.
matriz
Talib.LINEARREG_SLOPE ((inReal) talib.LINEARREG_SLOPE ((em real, opInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OLINEARREG_SLOPE()A função é descrita na documentação da biblioteca talib como:LINEARREG_SLOPE(Records[Close],Time Period = 14) = Array(outReal)
Otalib.STDDEV()função é usada para calcularDesvio padrão.
O valor de retorno dotalib.STDDEV()Função é: uma matriz unidimensional.
matriz
Talib.STDDEV ((inReal) Talib.STDDEV ((inReal, optInTimePeriod) Talib.STDDEV ((inReal, optInTimePeriod, optInNbDev)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 5.
optInTimePeriodo
Falso
Número
OoptInNbDevO parâmetro é usado para definir os Desvios, o valor padrão é 1.
OpInNbDev
Falso
Número
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);
}
OSTDDEV()A função é descrita na documentação da biblioteca talib como:STDDEV(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Otalib.TSF()função é usada para calcularPrevisão de séries temporais.
O valor de retorno dotalib.TSF()Função é uma matriz unidimensional.
matriz
Talib.TSF ((inReal) Talib.TSF ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OTSF()A função é descrita na documentação da biblioteca talib como:TSF(Records[Close],Time Period = 14) = Array(outReal)
Otalib.VAR()função é usada para calcularVariância.
O valor de retorno dotalib.VAR()Função é: uma matriz unidimensional.
matriz
Talib.VAR ((inReal) talib.VAR ((inReal, optInTimePeriod) talib.VAR ((inReal, optInTimePeriod, optInNbDev)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 5.
optInTimePeriodo
Falso
Número
OoptInNbDevO parâmetro é usado para definir os Desvios, o valor padrão é 1.
OpInNbDev
Falso
Número
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);
}
OVAR()A função é descrita na documentação da biblioteca talib como:VAR(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Otalib.ADX()função é utilizada para calcular oÍndice médio de movimento direcional.
O valor de retorno dotalib.ADX()Função é uma matriz unidimensional.
matriz
Talib.ADX (em preço) Talib.ADX ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OADX()A função é descrita na documentação da biblioteca talib como:ADX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.ADXR()função é utilizada para calcular oClassificação do índice médio de movimento direccional (índice de avaliação).
O valor de retorno dotalib.ADXR()Função é uma matriz unidimensional.
matriz
Talib.ADXR (em preço) Talib.ADXR ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OADXR()A função é descrita na documentação da biblioteca talib como:ADXR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.APO()função é utilizada para calcular oOscilador de preços absoluto.
O valor de retorno dotalib.APO()Função é: uma matriz unidimensional.
matriz
Talib.APO ((inReal) talib.APO ((inReal, optInFastPeriod) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod) talib.APO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInFastPeriodParâmetro é usado para definir o período rápido, o valor padrão é 12.
optInFastPeriod
Falso
Número
OoptInSlowPeriodParâmetro é usado para definir o período lento, o valor padrão é 26.
optInSlowPeriod
Falso
Número
OoptInMATypeO parâmetro é utilizado para definir o tipo médio, o valor por defeito é 0.
OptionInMAType
Falso
Número
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);
}
OAPO()A função é descrita na documentação da biblioteca talib como:APO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Otalib.AROON()função é utilizada para calcular oAroon (indicador Aroon).
O valor de retorno dotalib.AROON()Função é uma matriz bidimensional.
matriz
Talib.AROON (em inglês) talib.AROON ((emPriceHL, optInTimePeriod)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OAROON()A função é descrita na documentação da biblioteca talib como:AROON(Records[High,Low],Time Period = 14) = [Array(outAroonDown),Array(outAroonUp)]
Otalib.AROONOSC()função é utilizada para calcular oOscilador Aroon.
O valor de retorno dotalib.AROONOSC()Função é: uma matriz unidimensional.
matriz
Talib.AROONOSC ((inPriceHL) talib.AROONOSC ((emPriceHL, optInTimePeriod)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OAROONOSC()A função é descrita na documentação da biblioteca talib como:AROONOSC(Records[High,Low],Time Period = 14) = Array(outReal)
Otalib.BOP()função é utilizada para calcular oEquilíbrio de Poder.
O valor de retorno dotalib.BOP()Função é uma matriz unidimensional.
matriz
Talib.BOP ((inPriceOHLC)
OinPriceOHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceOHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OBOP()A função é descrita na documentação da biblioteca talib como:BOP(Records[Open,High,Low,Close]) = Array(outReal)
Otalib.CCI()função é utilizada para calcular oÍndice do canal de commodities (indicador homeopático).
O valor de retorno dotalib.CCI()Função é uma matriz unidimensional.
matriz
Talib.CCI ((inPriceHLC) talib.CCI ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OCCI()A função é descrita na documentação da biblioteca talib como:CCI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.CMO()função é utilizada para calcular oOscilador de Momento de Chande (CMO).
O valor de retorno dotalib.CMO()Função é: uma matriz unidimensional.
matriz
talib.CMO ((inReal) talib.CMO ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OCMO()A função é descrita na documentação da biblioteca talib como:CMO(Records[Close],Time Period = 14) = Array(outReal)
Otalib.DX()função é utilizada para calcular oÍndice de movimento direcional.
O valor de retorno dotalib.DX()Função é: uma matriz unidimensional.
matriz
Talib.DX ((inPriceHLC) Talib.DX ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
ODX()A função é descrita na documentação da biblioteca talib como:DX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.MACD()função é usada para calcularMédia móvel convergência/divergência (média móvel suavizada exponencialmente).
O valor de retorno dotalib.MACD()A função é: uma matriz bidimensional.
matriz
Talib.MACD ((inReal) talib.MACD ((inReal, optInFastPeriod) talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod) talib.MACD ((inReal, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInFastPeriodParâmetro é usado para definir o período rápido, o valor padrão é 12.
optInFastPeriod
Falso
Número
OoptInSlowPeriodParâmetro é usado para definir o período lento, o valor padrão é 26.
optInSlowPeriod
Falso
Número
OoptInSignalPeriodO parâmetro é usado para definir o período de sinal, o valor padrão é 9.
OptInSignalPeriodo
Falso
Número
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);
}
OMACD()A função é descrita na documentação da biblioteca talib como:MACD(Records[Close],Fast Period = 12,Slow Period = 26,Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Otalib.MACDEXT()função é usada para calcularMACD com tipo de MA controlável.
O valor de retorno dotalib.MACDEXT()Função é uma matriz bidimensional.
matriz
Talib.MACDEXT ((inReal) Talib.MACDEXT ((InReal, optInFastPeriod) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod) talib.MACDEXT ((inReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod, optInSignalMAType)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInFastPeriodParâmetro é usado para definir o período rápido, o valor padrão é 12.
optInFastPeriod
Falso
Número
OoptInFastMATypeO parâmetro é usado para definir o tipo de média rápida, o valor padrão é 0.
OptionInFastMAType
Falso
Número
OoptInSlowPeriodParâmetro é usado para definir o período lento, o valor padrão é 26.
optInSlowPeriod
Falso
Número
OoptInSlowMATypeO parâmetro é utilizado para definir o tipo de média lenta, o valor por defeito é 0.
OptionInSlowMAType
Falso
Número
OoptInSignalPeriodO parâmetro é usado para definir o período de sinal, o valor padrão é 9.
OptInSignalPeriodo
Falso
Número
OoptInSignalMATypeO parâmetro é utilizado para definir o tipo de média do sinal, o valor por defeito é 0.
OptionInSignalMAType
Falso
Número
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);
}
OMACDEXT()A função é descrita na documentação da biblioteca talib como: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)]
Otalib.MACDFIX()função é usada para calcularMédia móvel de convergência/divergência 12/26.
O valor de retorno dotalib.MACDFIX()Função é uma matriz bidimensional.
matriz
Talib.MACDFIX ((inReal) Talib.MACDFIX ((inReal, optInSignalPeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInSignalPeriodO parâmetro é usado para definir o período de sinal, o valor padrão é 9.
OptInSignalPeriodo
Falso
Número
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);
}
OMACDFIX()A função é descrita na documentação da biblioteca talib como:MACDFIX(Records[Close],Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Otalib.MFI()função é utilizada para calcular oÍndice de fluxo de caixa.
O valor de retorno dotalib.MFI()Função é uma matriz unidimensional.
matriz
Talib.MFI ((inPriceHLCV) talib.MFI ((inPriceHLCV, optInTimePeriod)
OinPriceHLCVO parâmetro é utilizado para especificar os dados da linha K.
InPriceHLCV
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OMFI()A função é descrita na documentação da biblioteca talib como:MFI(Records[High,Low,Close,Volume],Time Period = 14) = Array(outReal)
Otalib.MINUS_DI()função é utilizada para calcular oIndicador de direcção negativo.
O valor de retorno dotalib.MINUS_DI()Função é uma matriz unidimensional.
matriz
Talib.MINUS_DI ((inPriceHLC) talib.MINUS_DI ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OMINUS_DI()A função é descrita na documentação da biblioteca talib como:MINUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.MINUS_DM()função é utilizada para calcular oMovimento direccional menos (movimento negativo).
O valor de retorno dotalib.MINUS_DM()Função é uma matriz unidimensional.
matriz
talib.MINUS_DM ((inPriceHL) talib.MINUS_DM ((inPriceHL, optInTimePeriod)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OMINUS_DM()A função é descrita na documentação da biblioteca talib como:MINUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Otalib.MOM()função é usada para calcularImpulso.
O valor de retorno dotalib.MOM()Função é uma matriz unidimensional.
matriz
Talib.MOM ((inReal) Talib.MOM ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 10.
optInTimePeriodo
Falso
Número
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);
}
OMOM()A função é descrita na documentação da biblioteca talib como:MOM(Records[Close],Time Period = 10) = Array(outReal)
Otalib.PLUS_DI()função é utilizada para calcular oIndicador de direcção.
O valor de retorno dotalib.PLUS_DI()Função é: uma matriz unidimensional.
matriz
Talib.PLUS_DI (em preço) talib.PLUS_DI ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OPLUS_DI()A função é descrita na documentação da biblioteca talib como:PLUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Otalib.PLUS_DM()função é usada para calcularMais movimento direcional.
O valor de retorno dotalib.PLUS_DM()Função é uma matriz unidimensional.
matriz
Talib.PLUS_DM ((inPriceHL) talib.PLUS_DM ((inPriceHL, optInTimePeriod)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OPLUS_DM()A função é descrita na documentação da biblioteca talib como:PLUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Otalib.PPO()função é utilizada para calcular oOscilador de preços percentual.
O valor de retorno dotalib.PPO()Função é uma matriz unidimensional.
matriz
Talib.PPO ((inReal) talib.PPO ((inReal, optInFastPeriod) Talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod) talib.PPO ((inReal, optInFastPeriod, optInSlowPeriod, optInMAType)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInFastPeriodParâmetro é usado para definir o período rápido, o valor padrão é 12.
optInFastPeriod
Falso
Número
OoptInSlowPeriodParâmetro é usado para definir o período lento, o valor padrão é 26.
optInSlowPeriod
Falso
Número
OoptInMATypeO parâmetro é utilizado para definir o tipo médio, o valor por defeito é 0.
OptionInMAType
Falso
Número
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);
}
OPPO()A função é descrita na documentação da biblioteca talib como:PPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Otalib.ROC()função é usada para calcularTaxa de variação: ((preço/preço anterior) -1) * 100 (indicador de taxa de variação).
O valor de retorno dotalib.ROC()Função é uma matriz unidimensional.
matriz
Talib.ROC ((inReal) talib.ROC ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 10.
optInTimePeriodo
Falso
Número
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);
}
OROC()A função é descrita na documentação da biblioteca talib como:ROC(Records[Close],Time Period = 10) = Array(outReal)
Otalib.ROCP()função é usada para calcularTaxa de variação Percentagem: (preço-prevPrice) /prevPrice (taxa de variação de preços).
O valor de retorno dotalib.ROCP()Função é: uma matriz unidimensional.
matriz
Talib.ROCP ((inReal) Talib.ROCP ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 10.
optInTimePeriodo
Falso
Número
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);
}
OROCP()A função é descrita na documentação da biblioteca talib como:ROCP(Records[Close],Time Period = 10) = Array(outReal)
Otalib.ROCR()função é utilizada para calcular oTaxa de variação do rácio: (preço/preço anterior) (rácio de variação de preços).
O valor de retorno dotalib.ROCR()Função é uma matriz unidimensional.
matriz
Talib.ROCR ((inReal) Talib.ROCR ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 10.
optInTimePeriodo
Falso
Número
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);
}
OROCR()A função é descrita na documentação da biblioteca talib como:ROCR(Records[Close],Time Period = 10) = Array(outReal)
Otalib.ROCR100()função é usada para calcularTaxa de variação do rácio 100 escala: (preço/prevPrice) *100 (rácio de variação de preços).
O valor de retorno dotalib.ROCR100()Função é: uma matriz unidimensional.
matriz
Talib.ROCR100 ((inReal) Talib.ROCR100 ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 10.
optInTimePeriodo
Falso
Número
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);
}
OROCR100()A função é descrita na documentação da biblioteca talib como:ROCR100(Records[Close],Time Period = 10) = Array(outReal)
Otalib.RSI()função é utilizada para calcular oÍndice de força relativa.
O valor de retorno dotalib.RSI()Função é uma matriz unidimensional.
matriz
Talib.RSI (InReal) talib.RSI ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
ORSI()A função é descrita na documentação da biblioteca talib como:RSI(Records[Close],Time Period = 14) = Array(outReal)
Otalib.STOCH()função é utilizada para calcular oStochastic (indicador STOCH).
O valor de retorno dotalib.STOCH()Função é uma matriz bidimensional.
matriz
Talib.STOCH ((inPriceHLC) Talib.STOCH ((inPriceHLC, optInFastK_Period) Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period) talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType) talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period) talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period, optInSlowD_MAType)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInFastK_PeriodO parâmetro é usado para definir o período Fast-K, o valor padrão é 5.
OptionInFastK
Falso
Número
OoptInSlowK_PeriodO parâmetro é usado para definir o período Slow-K, o valor padrão é 3.
SelecionarInSlowK_Periodo
Falso
Número
OoptInSlowK_MATypeO parâmetro é utilizado para definir o tipo médio Slow-K, o valor por defeito é 0.
OptionInSlowK_MAType
Falso
Número
OoptInSlowD_PeriodO parâmetro é utilizado para definir o período Slow-D, o valor por defeito é 3.
OptionInSlowD_Period
Falso
Número
OoptInSlowD_MATypeO parâmetro é utilizado para definir o tipo médio Slow-D, o valor por defeito é 0.
OptionInSlowD_MAType
Falso
Número
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);
}
OSTOCH()A função é descrita na documentação da biblioteca talib como: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)]
Otalib.STOCHF()função é utilizada para calcular oIndicador Stochastic Fast (indicador STOCH rápido).
O valor de retorno dotalib.STOCHF()Função é uma matriz bidimensional.
matriz
Talib.STOCHF ((inPriceHLC) Talib.STOCHF ((inPriceHLC, optInFastK_Period) Talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period) talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInFastK_PeriodO parâmetro é usado para definir o período Fast-K, o valor padrão é 5.
OptionInFastK
Falso
Número
OoptInFastD_PeriodO parâmetro é usado para definir o período Fast-D, o valor padrão é 3.
OptionInFastD_Periodo
Falso
Número
OoptInFastD_MATypeO parâmetro é utilizado para definir o tipo médio Fast-D, o valor por defeito é 0.
OptionInFastD_MAType
Falso
Número
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);
}
OSTOCHF()A função é descrita na documentação da biblioteca talib como:STOCHF(Records[High,Low,Close],Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Otalib.STOCHRSI()função é utilizada para calcular oÍndice de Força Relativa Estocástico.
O valor de retorno dotalib.STOCHRSI()A função é: uma matriz bidimensional.
matriz
Talib.STOCHRSI ((inReal) Talib.STOCHRSI (em tempo real, opcional) Talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period) talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
OoptInFastK_PeriodO parâmetro é usado para definir o período Fast-K, o valor padrão é 5.
OptionInFastK
Falso
Número
OoptInFastD_PeriodO parâmetro é usado para definir o período Fast-D, o valor padrão é 3.
OptionInFastD_Periodo
Falso
Número
OoptInFastD_MATypeO parâmetro é utilizado para definir o tipo médio Fast-D, o valor por defeito é 0.
OptionInFastD_MAType
Falso
Número
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);
}
OSTOCHRSI()A função é descrita na documentação da biblioteca talib como:STOCHRSI(Records[Close],Time Period = 14,Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Otalib.TRIX()função é utilizada para calcular oRate-of-Change (ROC) de 1 dia de uma EMA tripla suave.
O valor de retorno dotalib.TRIX()Função é: uma matriz unidimensional.
matriz
Talib.TRIX ((inReal) Talib.TRIX ((inReal, optInTimePeriod)
OinRealO parâmetro é utilizado para especificar os dados da linha K.
InReal
verdade
{@struct/Record Record} matrizes de estrutura, matrizes numéricas
OoptInTimePeriodO parâmetro é usado para definir o período, o valor padrão é 30.
optInTimePeriodo
Falso
Número
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);
}
OTRIX()A função é descrita na documentação da biblioteca talib como:TRIX(Records[Close],Time Period = 30) = Array(outReal)
Otalib.ULTOSC()função é utilizada para calcular oOscilador Último.
O valor de retorno dotalib.ULTOSC()Função é uma matriz unidimensional.
matriz
Talib.ULTOSC ((inPriceHLC) Talib.ULTOSC ((inPriceHLC, optInTimePeriod1) Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2) Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriod1O parâmetro é usado para definir o primeiro período, o valor padrão é 7.
optInTimePeriod1
Falso
Número
OoptInTimePeriod2O parâmetro é usado para definir o segundo período, o valor padrão é 14.
optInTimePeriod2
Falso
Número
OoptInTimePeriod3Parâmetro é usado para definir o terceiro período, o valor padrão é 28.
optInTimePeriod3
Falso
Número
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);
}
OULTOSC()A função é descrita na documentação da biblioteca talib como:ULTOSC(Records[High,Low,Close],First Period = 7,Second Period = 14,Third Period = 28) = Array(outReal)
Otalib.WILLR()função é usada para calcularWilliams
O valor de retorno dotalib.WILLR()Função é: uma matriz unidimensional.
matriz
Talib.WILLR ((inPriceHLC) Talib.WILLR ((inPriceHLC, optInTimePeriod)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
OoptInTimePeriodParâmetro é usado para definir o período, o valor padrão é 14.
optInTimePeriodo
Falso
Número
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);
}
OAVGPRICE()A função é descrita na documentação da biblioteca talib como:AVGPRICE(Records[Open,High,Low,Close]) = Array(outReal)
Otalib.MEDPRICE()função é utilizada para calcular oPreço médio.
O valor de retorno dotalib.MEDPRICE()Função é uma matriz unidimensional.
matriz
talib.MEDPRICE ((emPriceHL)
OinPriceHLO parâmetro é utilizado para especificar os dados da linha K.
inPriceHL
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OMEDPRICE()A função é descrita na documentação da biblioteca talib como:MEDPRICE(Records[High,Low]) = Array(outReal)
Otalib.TYPPRICE()função é usada para calcularPreço típico.
O valor de retorno dotalib.TYPPRICE()Função é uma matriz unidimensional.
matriz
Talib.TYPPRICE ((emPriceHLC)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OTYPPRICE()A função é descrita na documentação da biblioteca talib como:TYPPRICE(Records[High,Low,Close]) = Array(outReal)
Otalib.WCLPRICE()função é utilizada para calcular oPreço de fechamento ponderado.
O valor de retorno dotalib.WCLPRICE()Função é uma matriz unidimensional.
matriz
Talib.WCLPRICE ((inPriceHLC)
OinPriceHLCO parâmetro é utilizado para especificar os dados da linha K.
inPriceHLC
verdade
{@struct/Record Record} matriz de estrutura
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);
}
OWCLPRICE()A função é descrita na documentação da biblioteca talib como:WCLPRICE(Records[High,Low,Close]) = Array(outReal)