Devuelve el número de versión actual del sistema.
Número de versión del sistema actual, por ejemplo:3.6- ¿ Por qué?
la cuerda
Versión
function main() {
Log("version:", Version())
}
def main():
Log("version:", Version())
void main() {
Log("version:", Version());
}
El número de versión del sistema es el número de versión del programa docker.
La función de sueño, haciendo que el programa se detenga por un período de tiempo.
El sueño (millisegundo)
ElmillisecondParámetro utilizado para establecer la duración del sueño y el número de milisegundos.
milisegundos
verdadero
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 ejemplo, al ejecutar elSleep(1000)Función, el programa permanecerá en reposo durante 1 segundo.Sleep(0.1)Apoya un parámetro mínimo de0.000001, es decir, hibernación de nanosegundos, donde 1 nanosegundo es igual a1e-6milisegundos.
Cuando se escriben estrategias en elPythonLa lenguaSleep(millisecond)No se recomienda el uso de la función de intervalo de votación, las operaciones de tiempo de espera.time.sleep(second)Función dePython¿ Qué?timeEsto se debe a que el uso de latime.sleep(second)función en una estrategia hace que el programa de estrategia espere por un período de tiempo en realidad cuando backtesting (no saltando en la serie de tiempo del sistema de backtesting), por lo que hace que la estrategia para backtesting muy lentamente.
Determinar si el entorno de ejecución de la estrategia es un sistema de backtesting.
La estrategia devuelve un valor verdadero, por ejemplo:trueLa estrategia devuelve un valor falso, por ejemplo:falsecuando se ejecuta en un entorno de negociación en vivo.
- ¿ Qué?
¿Es 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 si el entorno de funcionamiento actual es un sistema de backtesting, que se utiliza para ser compatible con la diferencia entre backtesting y trading en vivo.
Envía un correo electrónico.
Una entrega de correo electrónico exitosa devuelve un valor verdadero, por ejemplo,true, y una entrega fallida devuelve un valor falso, por ejemplo,false- ¿ Por qué?
- ¿ Qué?
Correo ((smtpServidor, smtpNombre de usuario, smtpPalabra de seguridad, mailTo, título, cuerpo)
Se utiliza para especificar elSMTPdirección de servicio del remitente del correo electrónico.
Es un servidor.
verdadero
la cuerda
Se utiliza para especificar la dirección de correo electrónico del remitente.
Nombre de usuario
verdadero
la cuerda
ElSMTPcontraseña para el buzón del remitente.
¿ Qué pasa?
verdadero
la cuerda
Se utiliza para especificar la dirección de correo electrónico del destinatario.
Envío de correo
verdadero
la cuerda
Título de correo electrónico.
Título
verdadero
la cuerda
El cuerpo del correo electrónico.
cuerpo
verdadero
la cuerda
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");
}
ElsmtpPasswordParámetro establece la contraseña para elSMTPservicio, no la contraseña del buzón.
Al ajustar elsmtpServerParámetro, si necesita cambiar el puerto, puede añadir el número de puerto directamente en el parámetrosmtpServerPor ejemplo: correo QQsmtp.qq.com:587, que está disponible para su ensayo.
En caso de error:unencryped connection, usted necesita para modificar elsmtpServerde lasMailEl formato del parámetro es:ssl://xxx.com:xxx, por ejemplo, elsslmétodo deSMTPpara el correo QQ:ssl://smtp.qq.com:465o biensmtp://xxx.com:xxx- ¿ Por qué?
No funciona en el sistema de backtesting.
¿Por qué no lo haces?
Versión asíncrona delMail function.
ElMail_Gofunción devuelve un objeto concurrente inmediatamente, y se puede utilizar elwaitUn correo entregado con éxito devuelve un valor verdadero, por ejemplo,true, y una entrega fallida devuelve un valor falso, por ejemplo,false- ¿ Por qué?
Objeto
Mail_Go ((smtpServer, smtpUsername, smtpPassword, mailTo, título, cuerpo)
Se utiliza para especificar elSMTPdirección de servicio del remitente del correo electrónico.
Es un servidor
verdadero
la cuerda
Se utiliza para especificar la dirección de correo electrónico del remitente.
Nombre de usuario
verdadero
la cuerda
ElSMTPcontraseña para el buzón del remitente.
- ¿ Qué pasa?
verdadero
la cuerda
Se utiliza para especificar la dirección de correo electrónico del destinatario del correo electrónico.
Envío de correo
verdadero
la cuerda
Título de correo electrónico.
Título
verdadero
la cuerda
Corpo del correo electrónico.
cuerpo
verdadero
la cuerda
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.
No funciona en el sistema de backtesting.
¿Por qué no lo haces?
Registros de errores de filtro.
ConfigurarErrorFilter (filtros)
Una cadena de expresiones regulares. filtros verdadero la cuerda
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");
}
Filtración de errores comunes.
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 un mensaje de error de interfaz.
Los registros de errores que coincidan con esta expresión regular no se cargarán en el sistema de registros. Puede llamarlo varias veces (sin límite en el número de veces) para establecer varias condiciones de filtro. Las expresiones regulares establecidas varias veces se acumularán y entrarán en vigencia al mismo tiempo. Puede establecer una cadena vacía para restablecer la expresión regular utilizada para filtrar los registros de errores:SetErrorFilter(""). Los registros filtrados ya no se escriben en el archivo de base de datos correspondiente a la ID de comercio en vivo en el directorio docker para evitar que los informes de errores frecuentes se hinchen en el archivo de base de datos.
Obtener el proceso de comercio en vivo ID.
Retorno de la identificación del proceso de negociación en vivo. la cuerda
¿ Qué te parece?
function main(){
var id = GetPid()
Log(id)
}
def main():
id = GetPid()
Log(id)
void main() {
auto id = GetPid();
Log(id);
}
Recibe el último mensaje de error.
Último mensaje de error. la cuerda
Obtenga el último error
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);
}
No funciona en el sistema de backtesting.
Obtiene el comando de interacción estratégica.
El formato del comando devuelto esControlName:Data. ControlNamees el nombre del control, yDataSi el control interactivo no tiene cajas de entrada, cajas desplegables y otros componentes (por ejemplo, un control de botón sin cajas de entrada), entonces el formato de comando devuelto esControlName, que devuelve sólo el nombre del control.
la cuerda
Obtener el 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 el comando de interacción y utiliza elLogFunción para emitir el comando de interacción cuando se detecta.
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 ejemplo, el control interactivo de estrategia agrega un control sin un cuadro de entrada, el control interactivo se llama:buy, la información de descripción del control es:buy, que es un control de botón. Continúe añadiendo un control con un cuadro de entrada. El control interactivo se llama:selly el mensaje de descripción del control es:sell, que es un control interactivo que es una combinación de un botón y un cuadro de entrada.
No funciona en el sistema de backtesting.
Obtener el valor de Meta escrito al generar el código de registro de la estrategia.
Metalos datos.
la cuerda
Obtener Meta()
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);
}
}
Ejemplo de escenario de aplicación: usoMetalimitar el importe de los activos gestionados por la estrategia.
Escenario de aplicación: necesidad de hacer límites de capital para los diferentes arrendatarios de estrategia.Metael valor fijado al generar el código de registro no podrá exceder de 190 caracteres, yGetMeta()Si no hay metadatos (Meta) se establece al generar un código de registro de la estrategia, el código de registro de la estrategiaGetMeta()No funciona en el sistema de backtesting.
Para el primitivoSocketacceso, apoyotcp, udp, tls, unixSoporte para 4 protocolos de comunicación populares:mqtt, nats, amqp, kafkaApoyo para conectar a bases de datos:sqlite3, mysql, postgres, clickhouse.
ElDial()Una llamada normal devuelve un objeto de conexión que tiene tres métodos:read, writeycloseEl.readEl método se utiliza para leer los datos, elwriteEl método se utiliza para enviar datos y elcloseEl método se utiliza para cerrar la conexión.
Elreadel método admite los siguientes parámetros:
ws.read().ws.read(2000)especifica un tiempo de espera de dos segundos (2000 milisegundos).-1significa que la función devuelve inmediatamente, independientemente de la presencia o ausencia de mensajes, por ejemplo:ws.read(-1)- ¿ Por qué?
Pasando el parámetro-2significa que la función devuelve inmediatamente con o sin un mensaje, pero sólo el último mensaje se devuelve, y el mensaje tamponado se descarta.ws.read(-2).read()Descripción del búfer de función:
Los datos entrantes empujados por el protocolo WebSocket pueden causar acumulación de datos si el intervalo de tiempo entre la estrategiaread()Estos datos se almacenan en el búfer, que tiene una estructura de datos de una cola con un máximo de 2000.
| Escenario | No hay parámetro | Parámetro: -1 | Parámetro: -2 | Parámetro: 2000, en milisegundos |
|---|---|---|---|---|
| Datos ya en el búfer | Devuelva los datos más antiguos inmediatamente | Devuelva los datos más antiguos inmediatamente | Devuelva los últimos datos inmediatamente. | Devuelva los datos más antiguos inmediatamente |
| No hay datos en el búfer | Regresar cuando se bloquea a los datos | Devuelva nulo inmediatamente | Devuelva nulo inmediatamente | Espera 2000 ms, devuelve nulo si no hay datos, devuelve nulo si hay datos |
| La conexión WebSocket se desconecta o se vuelve a conectar por el subyacente | read() devuelve la cadena vacía, es decir: |
objetos
Número de teléfono y dirección Número de teléfono (dirección, tiempo límite)
Solicita la dirección. Dirección verdadero la cuerda segundos de tiempo de espera, tiempo de espera falsos 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();
}
}
Ejemplo de llamada de la función 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 acceder a la interfaz WebSocket de Binance:
var ws = null
function main(){
var param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
// When calling Dial function, specify reconnect=true to set reconnection mode and payload to be the message sent when reconnecting. When the WebSocket connection is disconnected, it will reconnect and send messages automatically.
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
if(ws){
var pingCyc = 1000 * 20
var lastPingTime = new Date().getTime()
while(true){
var nowTime = new Date().getTime()
var ret = ws.read()
Log("ret:", ret)
if(nowTime - lastPingTime > pingCyc){
var retPing = ws.write("ping")
lastPingTime = nowTime
Log("Send : ping", "#FF0000")
}
LogStatus("Current time:", _D())
Sleep(1000)
}
}
}
function onexit() {
ws.close()
Log("exit")
}
import json
import time
ws = None
def main():
global ws
param = {
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
}
ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload=" + json.dumps(param))
if ws:
pingCyc = 1000 * 20
lastPingTime = time.time() * 1000
while True:
nowTime = time.time() * 1000
ret = ws.read()
Log("ret:", ret)
if nowTime - lastPingTime > pingCyc:
retPing = ws.write("ping")
lastPingTime = nowTime
Log("Send: ping", "#FF0000")
LogStatus("Current time:", _D())
Sleep(1000)
def onexit():
ws.close()
Log("exit")
auto objWS = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true");
void main() {
json param = R"({
"op": "subscribe",
"args": [{
"channel": "tickers",
"instId": "BTC-USDT"
}]
})"_json;
objWS.write(param.dump());
if(objWS.Valid) {
uint64_t pingCyc = 1000 * 20;
uint64_t lastPingTime = Unix() * 1000;
while(true) {
uint64_t nowTime = Unix() * 1000;
auto ret = objWS.read();
Log("ret:", ret);
if(nowTime - lastPingTime > pingCyc) {
auto retPing = objWS.write("ping");
lastPingTime = nowTime;
Log("Send: ping", "#FF0000");
}
LogStatus("Current time:", _D());
Sleep(1000);
}
}
}
void onexit() {
objWS.close();
Log("exit");
}
Acceso a la interfaz del ticker de WebSocket de 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");
}
Acceso a la interfaz de ticker de WebSocket de Huobi:
function getLogin(pAccessKey, pSecretKey, pPassphrase) {
// Signature function for login
var ts = (new Date().getTime() / 1000).toString()
var login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey) // exchange.HMAC has been deprecated and is temporarily supported. Please use the latest exchange.Encode function instead.
}]
}
return login
}
var client_private = null
function main() {
// Because the read function uses a timeout setting, filtering the timeout reports errors that would otherwise be output with redundant errors
SetErrorFilter("timeout")
// Position channel subscription information
var posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
var accessKey = "xxx"
var secretKey = "xxx"
var passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000) // When logging in, you cannot subscribe to private channels immediately, you need to wait for server response
client_private.write(JSON.stringify(posSubscribe))
if (client_private) {
var lastPingTS = new Date().getTime()
while (true) {
var buf = client_private.read(-1)
if (buf) {
Log(buf)
}
// Detect disconnection, reconnect
if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
Log("Disconnection detected, close connection, reconnect")
client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(JSON.stringify(posSubscribe))
}
// Send heartbeat packets
var nowPingTS = new Date().getTime()
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping")
lastPingTS = nowPingTS
}
}
}
}
function onexit() {
var ret = client_private.close()
Log("Close the connection!", ret)
}
import json
import time
def getLogin(pAccessKey, pSecretKey, pPassphrase):
ts = str(time.time())
login = {
"op": "login",
"args":[{
"apiKey" : pAccessKey,
"passphrase" : pPassphrase,
"timestamp" : ts,
"sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey)
}]
}
return login
client_private = None
def main():
global client_private
SetErrorFilter("timeout")
posSubscribe = {
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
}
accessKey = "xxx"
secretKey = "xxx"
passphrase = "xxx"
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
if client_private:
lastPingTS = time.time() * 1000
while True:
buf = client_private.read(-1)
if buf:
Log(buf)
if buf == "" and client_private.write(json.dumps(posSubscribe)) == 0:
Log("Disconnection detected, close connection, reconnect")
ret = client_private.close()
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
Sleep(3000)
client_private.write(json.dumps(posSubscribe))
nowPingTS = time.time() * 1000
if nowPingTS - lastPingTS > 10 * 1000:
client_private.write("ping")
lastPingTS = nowPingTS
def onexit():
ret = client_private.close()
Log("Close the connection!", ret)
auto client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
json getLogin(string pAccessKey, string pSecretKey, string pPassphrase) {
auto ts = std::to_string(Unix());
json login = R"({
"op": "login",
"args": [{
"apiKey": "",
"passphrase": "",
"timestamp": "",
"sign": ""
}]
})"_json;
login["args"][0]["apiKey"] = pAccessKey;
login["args"][0]["passphrase"] = pPassphrase;
login["args"][0]["timestamp"] = ts;
login["args"][0]["sign"] = exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey);
return login;
}
void main() {
SetErrorFilter("timeout");
json posSubscribe = R"({
"op": "subscribe",
"args": [{
"channel": "positions",
"instType": "ANY"
}]
})"_json;
auto accessKey = "xxx";
auto secretKey = "xxx";
auto passphrase = "xxx";
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
if (client_private.Valid) {
uint64_t lastPingTS = Unix() * 1000;
while (true) {
auto buf = client_private.read(-1);
if (buf != "") {
Log(buf);
}
if (buf == "") {
if (client_private.write(posSubscribe.dump()) == 0) {
Log("Disconnection detected, close connection, reconnect");
client_private.close();
client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
Sleep(3000);
client_private.write(posSubscribe.dump());
}
}
uint64_t nowPingTS = Unix() * 1000;
if (nowPingTS - lastPingTS > 10 * 1000) {
client_private.write("ping");
lastPingTS = nowPingTS;
}
}
}
}
void onexit() {
client_private.close();
Log("exit");
}
Para acceder a la interfaz de autenticación de WebSocket de 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
El objeto de conexión devuelto por la función Dial al conectarse a una base de datos tiene dos funciones de método que son únicas para él:
exec(sqlString): Se utiliza para ejecutar instrucciones SQL de una manera similar a laDBExec() function.fd()Elfd()función devuelve un mango (por ejemplo, la variable mango es mango) para ser utilizado por otros hilos para reconectar (incluso si el objeto creado por Dial ya ha sido cerrado por la ejecución de laclose()La función de cierre de la conexión) mediante el paso de la manija en elDial()función, por ejemplo,Dial(handle)Conexión de reutilización.
El siguiente es un ejemplo de la función Dial que se conecta a unsqlite3 database.Detalles de laaddressParámetro, separado por el|símbolo después de la dirección normal:wss://ws.okx.com:8443/ws/v5/publicSi hay|caracteres en la cadena de parámetros, entonces||La parte después de eso es algunas configuraciones de parámetros de función, y cada parámetro está conectado con&Por ejemplo, elss5Los parámetros de sustitución y compresión se pueden establecer de la siguiente manera:Dial("wss://ws.okx.com:8443/ws/v5/public|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")
| Funciones soportadas por el parámetro de dirección de la función Dial | Descripción del parámetro |
|---|---|
| Parámetros relacionados con la compresión de datos del protocolo WebSocket: compress=valor del parámetro | comprimir es el método de compresión, las opciones de parámetros comprimir son: gzip_raw, gzip, etc. Si el método gzip no es gzip estándar, se puede utilizar el método extendido: gzip_raw |
| Parámetros relacionados con la compresión de datos del protocolo WebSocket: modo=valor del parámetro | el modo es el modo de compresión, el parámetro de modo puede ser dual, enviar, recv. dual es compresión bidireccional, enviar datos comprimidos, recibir datos comprimidos. enviar es enviar datos comprimidos. recv es recibir datos comprimidos, descompresión local. |
| El protocolo WebSocket establece los parámetros relacionados con la auto-reconexión subyacente: reconnect=valor del parámetro | reconnect es si se debe configurar reconnect, reconnect=true es para habilitar reconnect. |
| El protocolo WebSocket establece los parámetros subyacentes relacionados con la reconexión automática: intervalo=valor del parámetro | el intervalo es el intervalo de reintentos, en milisegundos, el intervalo=10000 es el intervalo de reintentos de 10 segundos, el valor predeterminado es 1 segundo cuando no está establecido, es decir, el intervalo=1000. |
| El protocolo WebSocket establece los parámetros subyacentes relacionados con la reconexión automática: carga útil=valor del parámetro | carga útil es el mensaje de suscripción que debe enviarse cuando se vuelve a conectar el WebSocket, por ejemplo: carga útil=okokok. |
| Parámetros relacionados con los calcetines5 proxy: proxy=valor del parámetro | Proxy es el ajuste de proxy ss5, formato de valor del parámetro: socks5://name:pwd@192.168.0.1:1080, el nombre es el nombre de usuario del servidor ss5, pwd es la contraseña de inicio de sesión del servidor ss5, 1080 es el puerto de servicio ss5. |
ElDial()La función solo es compatible con el comercio en vivo.
Al conectarse a una base de datos utilizando la función Dial, la cadena de conexión se escribe con referencia al proyecto de controlador de lenguaje go para cada base de datos.
| Bases de datos soportadas | Proyectos impulsores | Cuadrícula de conexión | Las observaciones |
|---|---|---|---|
| el mismo | github.com/mattn/go-sqlite3 | sqlite3://file:test.db?cache=compartido y modo=memoria | Elsqlite3://Prefijo indica que se está utilizando una base de datos sqlite3, ejemplo de llamada:Dial("sqlite3://test1.db") |
| ¿ Qué quieres decir con eso? | github.com/go-sql-driver/mysql | mysql://nombre de usuario:su contraseña@tcp(localhost:3306) / tu base de datos? | – |
| las plantas herbáceas | github.com/lib/pq | el nombre de la base de datos sslmode=disable password=yourpassword host=localhost port=5432 | – |
| La casa de click | github.com/ClickHouse/clickhouse-go | clickhouse://tcp://host:9000?nombre de usuario=nombre de usuario& contraseña=tu contraseña& base de datos=youdatabase | – |
Por favor, tenga en cuenta que cuando elpayloadcontenido establecido en eladdressParámetro contiene caracteres=o otros caracteres especiales, puede afectar al análisis de laaddressParámetro delDialFunción, como el siguiente ejemplo.
Ejemplo de llamada de interfaz privada del websocket de backPack Exchange:
var client = null
function main() {
// Base64-encoded public key of the key pair, i.e. the access key configured on FMZ
var base64ApiKey = "xxx"
var ts = String(new Date().getTime())
var data = "instruction=subscribe×tamp=" + ts + "&window=5000"
// Since signEd25519 returns a base64 encoding, it contains the character "="
var signature = signEd25519(data)
// The payload may contain the character "=" after being encoded by JSON
payload = {
"method": "SUBSCRIBE",
"params": ["account.orderUpdate"],
"signature": [base64ApiKey, signature, ts, "5000"]
}
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
if (!client) {
Log("Connection failed, program exited")
return
}
while (true) {
var buf = client.read()
Log(buf)
}
}
function onexit() {
client.close()
}
function signEd25519(data) {
return exchange.Encode("ed25519.seed", "raw", "base64", data, "base64", "{{secretkey}}")
}
La siguiente llamada en el código funciona bien:
client = Dial("wss://ws.backpack.exchange")
client.write(JSON.stringify(payload))
Si lo escribe directamente enpayload, no funcionará correctamente, por ejemplo:
client = Dial("wss://ws.backpack.exchange|payload=" + JSON.stringify(payload))
Actualmente, sólo JavaScript admite el uso de lamqtt, nats, amqp, ykafkaEl código de estrategia del lenguaje JavaScript se utiliza como ejemplo para mostrar el uso de los cuatro protocolos:mqtt, nats, amqp, ykafka:
// 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")
}
}
Referencia de la documentación detallada:Explorando FMZ: Práctica del protocolo de comunicación entre las estrategias de negociación en vivo
Envía una solicitud Http.
Devuelve los datos de respuesta de la solicitud.JSONstring, puede ser analizado por elJSON.parse()La función en elJavaScriptLa estrategia lingüística, y por eljson::parse()La función en elC++Si el depuración está configurado en true en la estructura de opciones, el valor de retorno es un objeto (JSON); si el depuración está configurado en false, el valor de retorno es una cadena.
cadena, objeto
HttpQuery ((url) HttpQuery ((url, opciones)
URL de solicitud de HTTP. - ¿ Qué pasa? verdadero la cuerda Por ejemplo, las configuraciones relacionadas con las solicitudes HTTP pueden estructurarse de la siguiente manera:
{
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
}
tlsLas huellas.
Los ajustes admitidos incluyen las siguientes opciones:
¿ Por qué no?"chrome_103", "chrome_104", "chrome_105", "chrome_106", "chrome_107", "chrome_108", "chrome_109", "chrome_110", "chrome_111", "chrome_112", "chrome_117"- ¿ Por qué?
¿Qué quieres decir?"safari_15_6_1", "safari_16_0", "safari_ipad_15_6", "safari_ios_15_5", "safari_ios_15_6", "safari_ios_16_0"- ¿ Por qué?
¿ Qué haces?"firefox_102", "firefox_104", "firefox_105", "firefox_106", "firefox_108", "firefox_110", "firefox_117"- ¿ Por qué?
¿ Qué quieres decir?"opera_89", "opera_90", "opera_91"- ¿ Por qué?
¿ Qué haces?"zalando_android_mobile", "zalando_ios_mobile"- ¿ Por qué?
No lo sé."nike_ios_mobile", "nike_android_mobile"- ¿ Por qué?
rascacielos:"cloudscraper"- ¿ Por qué?
¿ Qué es eso?"mms_ios"- ¿ Por qué?
- ¿ Por qué no?"mesh_ios", "mesh_ios_1", "mesh_ios_2", "mesh_android", "mesh_android_1", "mesh_android_2"- ¿ Por qué?
Confirmado"confirmed_ios", "confirmed_android"- ¿ Por qué?
Está bien."okhttp4_android_7", "okhttp4_android_8", "okhttp4_android_9", "okhttp4_android_10", "okhttp4_android_11", "okhttp4_android_12", "okhttp4_android_13",true, elHttpQueryLa llamada de la función devuelve el mensaje de respuesta completo.false, sólo los datos en elBodydel mensaje de respuesta se devuelve.profileel campo puede ser dejado fuera.opciones falsos 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);
}
Un ejemplo de acceso a la interfaz 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/");
}
La función HttpQuery utiliza la configuración de proxy.
ElHttpQuery()Función sólo soportaJavaScript, C++el lenguaje,PythonEl lenguaje puede utilizar elurllibla biblioteca para enviar peticiones HTTP directamente.HttpQuery()El sistema de intercambio de datos se utiliza principalmente para acceder a las interfaces del intercambio que no requieren una firma, como las interfaces públicas como la información del ticker.HttpQuery()El sistema de backtesting puede utilizarse para enviar solicitudes (sóloGETLas pruebas de retroceso se limitan a utilizar 20 visitas a diferentesURLs, yHttpQuery()Las visitas cacharán los datos.URLSe puede acceder por segunda vez, elHttpQuery()La función devuelve los datos almacenados en caché y no se producen más solicitudes reales de red.
¿Por qué no lo haces?
Envía una solicitud HTTP, una versión asíncrona delHttpQuery function.
ElHttpQuery_Go()función devuelve inmediatamente un objeto concurrente que se puede utilizar para obtener el resultado de una solicitud HTTP utilizando elwaitEl método deJSON.parse()Función puede ser utilizado para analizar elJSON.parse()La función en elJavaScriptLa estrategia del lenguaje.
objetos
HttpQuery_Go ((url) HttpQuery_Go ((url, opciones)
URL de solicitud de HTTP. - ¿ Qué pasa? verdadero la cuerda Por ejemplo, las configuraciones relacionadas con las solicitudes HTTP pueden estructurarse de la siguiente manera:
{
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, estoHttpQuery_GoLa llamada de la función devuelve el mensaje de respuesta completo.false, sólo los datos en elBodydel mensaje de respuesta se devuelve.profileel campo puede ser dejado fuera.opciones falsos 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
Acceso asíncrono a la interfaz pública de la bolsa para datos agregados de ticker.
ElHttpQuery_Go()Función sólo soportaJavaScript, elPythonEl lenguaje puede utilizarse con elurllibla biblioteca para enviar peticiones HTTP directamente.HttpQuery_Go()El sistema de intercambio de datos se utiliza principalmente para acceder a interfaces que no requieren una firma en el intercambio, como las interfaces públicas como la información del ticker.HttpQuery_GoFunción no soportada en el sistema de backtesting.
¿Por qué no lo haces?
Esta función codifica los datos según los parámetros transmitidos.
ElEncodefunción devuelve los datos después de codificación y cifrado.
la cuerda
Encódigo ((algo, inputFormat, outputFormat, datos) Encódigo ((algo, inputFormat, outputFormat, datos, claveFormat, clave)
El parámetroalgoes el algoritmo utilizado en el cálculo de la codificación.raw(no se utiliza algoritmo), el"signo", algotambién admite: algotambién admite: algopuede escribirse como ed25519.seedel cálculo.
algo
verdadero
la cuerda
Se utiliza para especificar el formato de datos deldatael parámetro.inputFormatel parámetro puede establecerse como uno de los siguientes:raw, hex, base64, string. hexcodificado, base64codificado, y outputFormatel parámetro puede establecerse como uno de los siguientes:raw, hex, base64, string. hexcodificado, base64codificado, y dataes los datos a tratar.
datos
verdadero
la cuerda
Se utiliza para especificar el formato de datos delkeyel parámetro.keyel parámetro puede establecerse como uno de los siguientes:raw, hex, base64, string. hexcodificado, base64codificado, y keyes la clave secreta utilizada paraHMACEl parámetrokeyse requiere cuando el parámetroalgoestá configurado para:signo biensignTxEl.keyel parámetro no se utiliza paraHMACcifrado cuando elalgoel parámetro está establecido en
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
}
Ejemplo de llamada de función de codificación.
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);
}
El parámetroalgoTambién admite:
ElEncode()la función sólo se admite para el comercio en vivo.keyykeyFormatlos parámetros no se pasan, entonceskeyno se utiliza el cifrado.
Obtenga la marca de tiempo del nanosegundo del momento actual.
ElUnixNano()La función devuelve la marca de tiempo del nanosegundo.
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);
}
Si necesita obtener marcas de tiempo de milisegundos, puede usar el siguiente código:
¿Qué quieres decir con eso?
Obtenga la fecha del momento actual en el segundo nivel.
Devuelve la marca de tiempo de segundo nivel. Número
Unix ((()
function main() {
var t = Unix()
Log(t)
}
def main():
t = Unix()
Log(t)
void main() {
auto t = Unix();
Log(t);
}
¿Por qué no lo haces?
Obtener la información del sistema del dispositivo donde se encuentra el docker.
Información del sistema. la cuerda
¿Qué quieres decir?
function main() {
Log("GetOS:", GetOS())
}
def main():
Log("GetOS:", GetOS())
void main() {
Log("GetOS:", GetOS());
}
Por ejemplo, una llamada a laGetOS()Función para un docker que se ejecuta en elMac OSel sistema operativo puede devolver:darwin/amd64Porque las computadoras de Apple tienen múltiples arquitecturas de hardware.darwines el nombre de laMac OS system.
Computa el hash MD5 del parámetrodata.
Valor hash de MD5. la cuerda
MD5 (datos)
Los datos que requieren el cálculo MD5. datos verdadero la cuerda
function main() {
Log("MD5", MD5("hello world"))
}
def main():
Log("MD5", MD5("hello world"))
void main() {
Log("MD5", MD5("hello world"));
}
Llamando alMD5("hello world")función, el valor de retorno es:5eb63bbbe01eeed093cb22bb8f5acdc3.
¿Por qué no lo haces?
Funciones de interfaz de base de datos.
Objeto que contiene el resultado de la ejecución de unCuadradouna declaración, por ejemplo:
{"columns":["TS","HIGH","OPEN","LOW","CLOSE","VOLUME"],"values":[[1518970320000,100,99.1,90,100,12345.6]]}
objetos
DBExec (sql)
Cuadradola cadena de instrucciones. Cuadrado verdadero la cuerda
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;"));
}
Apoyo a la base de datos en memoria, paraDBExecparámetros de función, siCuadradola declaración comienza con:Es adecuado para operaciones de base de datos que no requieren de un almacenamiento persistente, por ejemplo:
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);
}
Crea una 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));
}
Añadir, borrar, comprobar y cambiar los registros en la tabla.
La funciónDBExec()Puede operar la base de datos de operaciones en vivo (base de datos SQLite) mediante el paso de parámetros.Es muy bueno.El sistema reservó tablas en la base de datos de operaciones en vivo:kvdb, cfg, log, profit, chart, no opere en estas mesas.Las transaccionesLas funciones de control de los datos no son compatibles y no se recomienda realizar tales operaciones, que pueden causar conflictos en el sistema.DBExec()La función solo es compatible con el comercio en vivo.
¿Por qué no lo haces?
Crear un UUID.
UUID de 32 bits. la cuerda
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);
}
ElUUID()La función soporta sólo el comercio en vivo.
Escucha los acontecimientos, que vuelve cuando hay algunaWebSocketdatos legibles o tareas concurrentes, como por ejemplo:exchange.Go(), HttpQuery_Go(), etc. se han completado.
Si el objeto devuelto no es un valor nulo, elEventel contenido de la devolución es el tipo de activador de eventos. Por ejemplo, la siguiente estructura de valor de devolución:
{"Seq":1,"Event":"Exchange_GetTrades","ThreadId":0,"Index":3,"Nano":1682068771309583400}
objetos
Loop de evento EventLoop (tiempo muerto)
El parámetrotimeoutes la configuración de tiempo de espera, en milisegundos.timeoutespera que ocurra un evento antes de devolverlo si está establecido en 0, si es mayor que 0, establece el evento para esperar un tiempo de espera, y devuelve el evento más reciente inmediatamente si es menor que 0.
tiempo de espera
falsos
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);
}
La primera llamada a laEventLoop()función en el código inicializa el mecanismo para ese evento escuchado, y si el primeroEventLoop()El sistema subyacente envuelve una estructura de cola que almacena en caché un máximo de 500 devoluciones de llamada de eventos.EventLoop()La función no se llama a tiempo para sacarlos durante la ejecución del programa, las llamadas posteriores de eventos fuera de la caché 500 se perderán.EventLoop()función no afectan a la cola de caché del sistema subyacente WebSocket o las caché de funciones concurrentes tales comoexchange.Go(). Para estos cachés, todavía es necesario utilizar los métodos respectivos para recuperar los datos.EventLoop()Función para los datos que se han recuperado antes de laEventLoop()El objetivo principal de laEventLoop()La función principal de la red es la de notificar a la capa de estrategia que los nuevos datos de red han sido recibidos por el sistema subyacente.EventLoop()Por ejemplo, conexiones WebSocket, objetos creados porexchange.Go()Los datos de laEventLoop()La función soporta sólo el comercio en vivo.
Escuchar eventos en el hilo principal cuando se llama desde la función principalmain()En las estrategias escritas en elJavaScriptLa lenguathreading.Thread()función crea un hilo, que también puede ser llamado en la función de ejecución del hilo
En el caso de las empresas que se encuentran en una situación de riesgo, la información que se proporciona es la siguiente:
El__ServeLa función se utiliza para crear el servicio HTTP, el servicio TCP y el servicio Websocket (basado en el protocolo HTTP).
Devuelve una cadena que registra la dirección IP y el puerto del servicio creado. Por ejemplo:127.0.0.1:8088, [::]:8089.
la cuerda
__Servir (servirURI, manejador de datos) __Service ((serveURI, manejador,...args)
ElserveURIEl parámetro se utiliza para configurar el protocolo, dirección IP, puerto y otras configuraciones del servicio de vinculación, tales comohttp://0.0.0.0:8088?gzip=true, es decir,http://:8088?gzip=true.
serveURIconfiguración de parámetros, comotcp://127.0.0.1:6666?tls=true; puede añadir certificados y claves privadas, tales comotls=true&cert_pem=xxxx&cert_key_pem=xxxx.serveURIconfiguración de parámetros, tales comohttp://127.0.0.1:6666?gzip=true; puede configurar la configuración de compresión:gzip=true- ¿ Por qué?
ElserveURIEl parámetro se utiliza para Https, comohttps://127.0.0.1:6666?tls=true&gzip=true; puede añadircert_pemycert_key_pemlos parámetros para cargar el certificado.servicioURI
verdadero
la cuerda
ElhandlerEl parámetro se utiliza para pasar en la función de procesamiento de enrutamiento (protocolo HTTP), la función de procesamiento de mensajes (protocolo TCP) y la función de procesamiento de flujo (Websocket).
La función de devolución de llamada transmitida por el parámetrohandlerpuede definir múltiples parámetros, el primer parámetro es el objeto ctx (objeto de contexto).
manipuladora
verdadero
Función
El parámetro real de la función de devolución de llamada pasado como el parámetrohandlerPuede haber varios parámetros.arg, por ejemplo:
__Serve("http://:8088", function(ctx, a, b, c) {
Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)
Los parámetros1, 2, 3En el momento de llamar a la__Serve()función corresponde a los parámetrosa, b, cPasado en la función de devolución de llamada.
el falsos cadena, número, bool, objeto, matriz, función, valor nulo y otros tipos compatibles con el 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
Websocketel servicio se implementa basado en el protocolo Http. Puede establecer una rama de enrutamiento en la ruta y diseñar el código de implementación paraWebsocketSe puede consultar el código de muestra en esta sección.La función de devolución de llamada transmitida por el parámetrohandlerrecibe unactxel parámetro.ctxParámetro es un objeto de contexto utilizado para obtener y escribir datos, con los siguientes métodos:
HTTP/1.1, tcp.http://127.0.0.1:8088?num=123, y la función de procesamiento de devoluciones de llamada transmitida por el parámetrohandlerlas devoluciones"123"¿Cuándo?ctx.query("num")se llama.User-Agenten los encabezados de la solicitud actual:ctx.header("User-Agent").GET, POST, etc.ctxobjeto de contexto al protocolo Websocket; devolviendo un valor booleano (verdadero) si el cambio es exitoso, y un valor booleano (falso) si falla.readmétodo no es compatible en el protocolo HTTP ordinario. Puede especificar el parámetro de tiempo de esperatimeout_msen milisegundos.JSON.stringify()para codificar el objeto JSON en una cadena y luego escribirlo.WebSocketProtocolo, se puede utilizar este método para pasar la cadena codificada al cliente.En el caso de las aplicaciones que se utilicen para la búsqueda de datos, el número de páginas que se utilicen para la búsqueda de datos es el número de páginas que se utilicen para la búsqueda de datos.
La estructura de datos es una tabla KV que se guarda permanentemente en el archivo de base de datos local del docker.
Datos de valores clave guardados de forma persistente enk-vlas parejas clave-valor.
cadena, número, bool, objeto, matriz, valor nulo
- ¿Qué quieres decir? _G(k) - ¿Por qué no?
El parámetrokes el nombre de la clave en el par clave-valor guardado y no es sensible a mayúsculas y minúsculas.
el
falsos
cadena, valor cero
El parámetroves el valor clave en el par clave-valor guardado, que puede ser cualquier dato que pueda serJSONen serie.
V
falsos
cadena, 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();
}
Una base de datos separada para cada operación en vivo, los datos guardados por el_G()La función siempre estará allí si se reinicia la estrategia o si el docker deja de funcionar._G()Cuando se utilice el_G()Función para persistir los datos guardados, debe ser utilizado razonablemente de acuerdo con la memoria y el espacio en disco duro del dispositivo de hardware, y no debe ser mal utilizado.
Cuando se llama a la_G()En el caso de las transacciones en vivo y no se pasan parámetros, el_G()Función devuelve elIdEn el caso de las transacciones en vivo._G()función, el parámetrovse pasa como nulo para indicar la eliminación de lak-vCuando se llama el_G()función, sólo el parámetrokse pasa en la cadena, y el_G()función devuelve el valor de clave correspondiente al parámetro guardadokCuando llamas a la_G()función, sólo el parámetrokse pasa en un valor nulo, lo que indica que todos los registros de lak-vCuando el par de valores clave se elimina.k-vLos pares de valores clave se han guardado de forma persistente, el_G()la función se llama de nuevo, pasando en el nombre de la clave que se ha guardado persistentemente como parámetrok. Pasando el nuevo valor clave como parámetrovLo actualizaremos.k-vel par clave-valor.
¿Por qué no lo haces?
Convierte marcas de tiempo de milisegundos oDateobjetos a las cadenas de tiempo.
Una cadena de tiempo. la cuerda
¿Qué es esto? _D (tiempo) _D (tiempo, fmt)
Marca de tiempo de milisegundos oDateObjeto.
el sello de tiempo
falsos
Número, objeto
El formato de la cadena,JavaScriptformato predeterminado del idioma:yyyy-MM-dd hh:mm:ss; Pythonformato predeterminado del idioma:%Y-%m-%d %H:%M:%S; C++formato predeterminado del idioma:%Y-%m-%d %H:%M:%S- ¿ Por qué?
Fmt también
falsos
la cuerda
function main(){
var time = _D()
Log(time)
}
def main():
strTime = _D()
Log(strTime)
void main() {
auto strTime = _D();
Log(strTime);
}
Obtener e imprimir la cadena de tiempo actual:
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));
}
La marca de tiempo es 1574993606000, utilizando la conversión 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
}
Formato con el parámetrofmtes diferente paraJavaScript, Python, yC++lenguas, como se muestra en los siguientes ejemplos:
Devuelve la cadena de tiempo actual sin pasar ningún parámetro._D()La función en elPythonestrategia, usted necesita ser consciente de que los parámetros pasados son marcas de tiempo de segundo nivel (marcas de tiempo de nivel de milisegundos en las estrategias JavaScript y C ++, donde 1 segundo es igual a 1000 milisegundos)._D()función para analizar una cadena de tiempo con una marca de tiempo legible en el comercio en vivo, usted necesita prestar atención a la zona horaria y la configuración de tiempo del sistema operativo donde se encuentra el programa docker._D()La función analiza una marca de tiempo en una cadena de tiempo legible dependiendo del tiempo del sistema docker.
¿Por qué no lo haces?
Formate un número con coma flotante.
El número de coma flotante formateado de acuerdo con el ajuste de precisión. Número
_N() _N (número) _N (número, precisión)
El número de coma flotante que debe ser formateado.
No
verdadero
Número
El ajuste de precisión para el formato, el parámetroprecisiones un número entero, y el parámetroprecisionpor defecto a 4.
Precisión
falsos
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 ejemplo,_N(3.1415, 2)borrará el valor después3.1415dos decimales y la función devuelve3.14.
function main(){
var i = 1300
Log(i)
var ii = _N(i, -3)
// Check the logs and see that it is 1000
Log(ii)
}
def main():
i = 1300
Log(i)
ii = _N(i, -3)
Log(ii)
void main() {
auto i = 1300;
Log(i);
auto ii = _N(i, -3);
Log(ii);
}
Si necesitas cambiar todos los dígitos N a la izquierda del punto decimal a 0, puedes escribirlo así:
El parámetroprecisionpuede ser un número entero positivo, negativo.
¿Por qué no lo haces?
Intentar de nuevo la función de tolerancia a fallas de la interfaz.
El valor de retorno de la función de llamada de retorno cuando se ejecuta. Todos los tipos son compatibles con el sistema exceptovalor lógico falsoyvalor nulo.
- ¿Qué es eso? - ¿Por qué no lo haces?
El parámetropfnes una referencia de función, que es unFunción de devolución de llamada- ¿ Por qué?
Pfn
verdadero
Función
Parámetros paraLas funciones de devolución de llamada, puede haber más de un parámetroargTipo y número de parámetrosargdependerá de los parámetros de laFunción de devolución de llamada¿ Qué pasa?
el
falsos
cadena, número, bool, objeto, matriz, función, todos los tipos son compatibles con el 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 las funciones tolerantes a errores sin 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 las funciones con parámetros tolerantes a errores:
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
También se puede utilizar para la tolerancia a fallos de las funciones personalizadas:
El_C()función seguirá llamando a la función especificada hasta que devuelva con éxito (la función a la que se refiere el parámetropfnlas devolucionesNo hay nadao bien- No es cierto.Cuando lo llamen, volverá a llamar.pfnPor ejemplo:_C(exchange.GetTicker)El intervalo de reintentos predeterminado es de 3 segundos, puede llamar al_CDelay()Función para establecer el intervalo de reintentos._CDelay(1000)El uso de un dispositivo de control de la velocidad es un medio para cambiar el intervalo de repetición de las pruebas de_C()Función a 1 segundo.
La tolerancia a fallos puede realizarse para, entre otras cosas, las siguientes funciones:
exchange.GetTicker()exchange.GetDepth()exchange.GetTrades()exchange.GetRecords()exchange.GetAccount()exchange.GetOrders()exchange.GetOrder()exchange.GetPositions()Todos pueden ser llamados por el_C()La función de tolerancia a fallos_C()la función no se limita a la función de tolerancia a fallas mencionada anteriormente, el parámetropfnes una referencia de función en lugar de una llamada de función.
Observe que es_C(exchange.GetTicker), no_C(exchange.GetTicker()).Devuelve el número de períodos de intersección de la matrizarr1y la matrizarr2.
El número de períodos transversales de la matrizarr1y la matrizarr2- ¿ Por qué?
Número
_Cruz ((arr1, arr2)
Los elementos son matrices de tiponumber- ¿ Por qué?
Arr1
verdadero
el conjunto
Los elementos son matrices de tiponumber- ¿ Por qué?
arr2
verdadero
el conjunto
// 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));
}
Se puede simular un conjunto de datos para probar la función _Cross ((Arr1, Arr2):
Si el valor de retorno de la_Cross()Si la función es un número positivo, indica el período de penetración ascendente, si es un número negativo, indica el período de penetración descendente, 0 significa lo mismo que el precio actual.Análisis e instrucciones de uso sobre la función integrada _Cross.
La funciónJSONParse()se utiliza para analizarJSON strings.
JSONObjeto.
Objeto
JSONParse (s)
JSONla cuerda.
el
verdadero
la cuerda
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.
}
Las cadenas JSON con valores grandes se pueden analizar correctamente, y analizará los valores grandes como tipos de cadena.JSONParse()Función no soportada en el sistema de backtest.
Registros de salida.
Log ((...msgs)
El parámetromsges el contenido de la salida, y el parámetromsgpuede ser superado por más de uno.
mensaje de texto
falsos
cadena, número, bool, objeto, matriz, cualquier tipo soportado por el sistema como null.
function main() {
Log("msg1", "msg2", "msg3")
}
def main():
Log("msg1", "msg2", "msg3")
void main() {
Log("msg1", "msg2", "msg3");
}
El número demsglos parámetros pueden ser pasados:
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@");
}
Apoya el ajuste del color del mensaje de salida, si usamos el ajuste del color y empujar al mismo tiempo, tenemos que establecer el color primero y utilizar@El personaje para poner el último empuje.
function main() {
Log("`data:image/png;base64,AAAA`")
}
def main():
Log("`data:image/png;base64,AAAA`")
void main() {
Log("`data:image/png;base64,AAAA`");
}
ElLog()Función de soporte de impresiónbase64imágenes codificadas, comenzando con`y termina con`, por ejemplo:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
Log(plt)
ElLog()Función soporta la impresión directaPython¿ Qué?matplotlib.pyplotEn el caso de los objetos, los objetos que se encuentran dentro de los objetossavefigEl método de impresión puede imprimirse directamente utilizando elLogfunción, por ejemplo:
function main() {
Log("[trans]中文|abc[/trans]")
}
def main():
Log("[trans]中文|abc[/trans]")
void main() {
Log("[trans]中文|abc[/trans]");
}
ElLog()La función soporta el cambio de idioma.Log()la función emite texto que cambiará al idioma correspondiente automáticamente en función de la configuración del idioma en la página de la plataforma, por ejemplo:
ElLog()La función produce un mensaje de registro en el área de registro del sistema de negociación en vivo o backtesting, y el registro se guarda en la base de datos de negociación en vivo cuando se está ejecutando la negociación en vivo.Log()Función de salida de un mensaje de registro que termina con el@Push a la dirección de correo electrónico, dirección WebHook, etc. configurado en elPulsa la opción ConfiguraciónEl envío de mensajes no es soportado porHerramientas de depuraciónLas reglas de restricción específicas son las siguientes: dentro de un ciclo de 20 segundos de una negociación en vivo, solo se retendrá y se empujará el último mensaje de empuje, y otros mensajes se filtrarán y no se empujarán (la salida de registro de empuje por la función Log se imprimirá y mostrará normalmente en el área de registro).
ParaWebHookPush, puedes usar el programa de servicio 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)
}
Se ha puestoWebHookEn elPulsa la opción Configuración: http://XXX.XX.XXX.XX:9090/data?data=Hello_FMZ- ¿ Por qué?
Después de ejecutar el escritoGolangprograma de servicio, comenzamos a ejecutar la estrategia de comercio en vivo, lo siguiente es la estrategia escrita enJavaScriptLa estrategia se ejecuta ejecutando elLog()función y empujando el mensaje:
function main() {
Log("msg", "@")
}
Un programa de servicio escrito en elGolangel lenguaje recibe el empuje y el programa de servicio imprime el mensaje:
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
¿Qué es lo que está pasando?
Registre el valor de las ganancias y pérdidas, imprima el valor de las ganancias y pérdidas y trace la curva de retorno basada en el valor de las ganancias y pérdidas.
LogProfit (beneficio) LogProfit ((beneficio,...argumentos)
El parámetroprofites el dato de ingresos, que se obtiene mediante el algoritmo de diseño y el cálculo de la estrategia.
ganancia
verdadero
Número
Parámetro ampliado para obtener información incidental en el registro de ingresos,argLos parámetros pueden ser pasados más de uno.
el
falsos
cadena, número, bool, objeto, matriz, cualquier tipo soportado por el sistema como null.
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);
}
}
ElLogProfitfunción, si termina con el carácter&Por ejemplo:
¿Por qué no lo haces?
Borrar todos los registros de ingresos, gráficos de ingresos.
LogProfitReset (() LogProfitReset ((queda)
ElremainEl parámetro se utiliza para especificar el número de entradas de registro (valor entero) a conservar.
Quedarse
falsos
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);
}
¿Por qué no lo haces?
Información de salida en la barra de estado del sistema de backtesting o en la página de operaciones en vivo.
LogStatus ((...msgs) El registro de los datos de los usuarios
El parámetromsges el contenido de la salida, y el parámetromsgpuede ser superado por más de uno.
mensaje de texto
falsos
cadena, número, bool, objeto, matriz, cualquier tipo soportado por el sistema como null.
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");
}
Apoya la configuración del color del contenido de salida:
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() + "`");
}
Ejemplo de salida de datos en la 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() + "`");
}
Apoya el diseño de controles de botón en la barra de estado (estructura de botón anterior):
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() + "`");
}
Configurar la función de descripción desactivada del botón de la barra de estado (estructura de botón anterior):
function test1() {
Log("Calling custom functions")
}
function main() {
while (true) {
var table = {
type: 'table',
title: 'operation',
cols: ['column1', 'column2', 'Action'],
rows: [
['a', '1', {
'type': 'button',
'cmd': "CoverAll",
'name': 'Close out positions'
}],
['b', '1', {
'type': 'button',
'cmd': 10,
'name': 'Send values'
}],
['c', '1', {
'type': 'button',
'cmd': _D(),
'name': 'Calling functions'
}],
['d', '1', {
'type': 'button',
'cmd': 'test1',
'name': 'Calling custom functions'
}]
]
}
LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')
var str_cmd = GetCommand()
if (str_cmd) {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if(str_cmd == "test1") {
test1()
}
}
Sleep(500)
}
}
import json
def test1():
Log("Calling custom functions")
def main():
while True:
table = {
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": _D(),
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
}
LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
str_cmd = GetCommand()
if str_cmd:
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd)
if str_cmd == "test1":
test1()
Sleep(500)
void test1() {
Log("Calling custom functions");
}
void main() {
while(true) {
json table = R"({
"type": "table",
"title": "operation",
"cols": ["column1", "column2", "Action"],
"rows": [
["a", "1", {
"type": "button",
"cmd": "CoverAll",
"name": "Close out positions"
}],
["b", "1", {
"type": "button",
"cmd": 10,
"name": "Send values"
}],
["c", "1", {
"type": "button",
"cmd": "",
"name": "Calling functions"
}],
["d", "1", {
"type": "button",
"cmd": "test1",
"name": "Calling custom functions"
}]
]
})"_json;
table["rows"][2][2]["cmd"] = _D();
LogStatus(_D(), "\n", "`" + table.dump() + "`");
auto str_cmd = GetCommand();
if(str_cmd != "") {
Log("Received interaction data str_cmd:", "type:", typeof(str_cmd), "value:", str_cmd);
if(str_cmd == "test1") {
test1();
}
}
Sleep(500);
}
}
En combinación con elGetCommand()función, construye la función de interacción del botón de la barra de estado (estructura de botón anterior):
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);
}
}
Los datos de entrada también son compatibles cuando se construyen botones de la barra de estado para la interacción, y los comandos de interacción son capturados por elGetCommand()La función final.inputelementos (estructura de botón antiguo) a la estructura de datos del control del botón en la barra de estado, por ejemplo, añadiendo"input": {"name": "number of open positions", "type": "number", "defValue": 1}En el{"type": "button", "cmd": "open", "name": "open position"}causará que aparezca una ventana emergente con un control de cuadro de entrada cuando se haga clic en el botón (el valor predeterminado en el cuadro de entrada es 1, que es los datos establecidos pordefValuePor ejemplo, cuando se ejecuta el siguiente código de prueba, después de hacer clic en el botón "Open positionGetCommand()La función captará el mensaje: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);
}
}
Apoya controles de botones agrupados (estructura de botones antigua), funcionalmente consistente conbotones de la barra de estado que admiten la entrada de datosLos comandos interactivos son finalmente capturados por elGetCommand()La diferencia es que con el"group"configuración de campo, cuando se hace clic en el botón para activar la interacción, el diálogo que aparece en la página contiene un conjunto degrupode controles de entrada configurados para introducir un grupo de datos a la vez.
Algunos puntos a tener en cuenta sobre el"group"campo en la estructura del mando del botón de la barra de estado y el mando del botón de grupo:
typepropiedad en grupo admite sólo los siguientes cuatro tipos, y eldefValuepropiedad es el valor predeterminado.
|símbolo para separar cada opción en un cuadro desplegable tal como está configurado.
"name": "tradePrice@orderType==1"El sistema de control de lael precio de comercioControl de entrada disponible sólo cuando elordenTipoel control desplegable se selecciona comoOrden pendiente.|símbolos para separar el contenido de la descripción en chino e inglés.name, descriptionen grupo yname, descriptionen la estructura de botones no tienen las mismas definiciones aunque tengan los mismos nombres de campos.
La definición denameen grupo también es diferente de la definición denameen la entrada.Log("cmd:", cmd)declaración en el siguiente ensayo de ejemplo:cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, es decir, lo que es devuelto por elGetCommand()Función cuando se produce una interacción:open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.typepropiedad del botón de control sólo admite:"button"¿ Qué pasa?
Controls de botón que admiten datos de entrada, es decir, controles con elinputconjunto de propiedades, eltypepropiedad en la información de configuración de lainputcampo admite múltiples tipos de control.
Consulte los siguientes ejemplos: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);
}
}
Cuando el botón de control de grupo de la barra de estado (implementado mediante la configuración degroupcampo) y el control del botón de la barra de estado (implementadoinputcampo) se hacen clic para activar la interacción (estructura de botón antiguo), el control del cuadro desplegable en el cuadro de diálogo que aparece en la página también admite múltiples selecciones. El siguiente ejemplo demuestra cómo diseñar un control del cuadro desplegable con múltiples opciones de selección:
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...
Cuando haga clic en el botón para activar la interacción, aparecerá una ventana emergente de múltiples controles. Para obtener más detalles, consulte:Guía de usuario - Controles interactivos en la 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() + "`");
}
Combinación horizontal de las celdas dentro del cuadro trazado por elLogStatus()Función:
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() + "`");
}
Combinar verticalmente las celdas de la tabla dibujada por elLogStatus()Función:
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() + "`");
}
Muestra de la tabla de la 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() + "`");
}
Además de mostrar tablas en páginas, también se pueden mostrar múltiples tablas en un orden de arriba hacia abajo:
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() + "`");
}
Soporte para configurar el modo de desplazamiento horizontal y vertical de la tabla de la barra de estado.scrollatributo de"auto", cuando el número de filas verticales de la tabla de barras de estado exceda de 20 filas, el contenido se desplazará.scrollse puede utilizar para aliviar el problema de retraso de escribir una gran cantidad de datos en la barra de estado durante la negociación en vivo.
La producción de información de laLogStatus()La función cuando se está ejecutando la negociación en vivo no se guarda en la base de datos de negociación en vivo, sino que solo actualiza el contenido de la barra de estado de la negociación en vivo actual.
ElLogStatus()Función de soporte de impresiónbase64imágenes codificadas, comenzando con`y termina con`Por ejemplo:LogStatus("`data:image/png;base64,AAAA`")- ¿ Por qué?
ElLogStatus()Función de soporte de transmisiónmatplotlib.pyplotobjetos directamente enPython, siempre que el objeto contenga elsavefigEn el caso de los datos de los datos de los datos de los datos de los datos de los datos de losLogStatus()función, por ejemplo:
import matplotlib.pyplot as plt
def main():
plt.plot([3,6,2,4,7,1])
LogStatus(plt)
Cuando la estrategia está ejecutando el comercio en vivo, si vas a través del historial en la página de comercio en vivo, la barra de estado se quedará dormida y dejará de actualizarse.base64las imágenes codificadas en la barra de estado, y también admite la salidabase64las imágenes codificadas en la tabla que se muestra en la barra de estado.
¿Por qué no lo haces?
Activar o desactivar el registro de la información de pedido.
Habilitar el registro (habilitado)
Si elenableel parámetro se establece en un valor falso, por ejemplo:false, el registro de pedidos (es decir, el registro generado por funciones comoexchange.Buy()) no se imprime ni se escribe en la base de datos de las operaciones en vivo.
permitir
verdadero
Boole
function main() {
EnableLog(false)
}
def main():
EnableLog(False)
void main() {
EnableLog(false);
}
En el caso de las empresas que no cumplen con los requisitos de la norma, el importe de la compensación se fijará en el importe de la compensación.
Personalizar la función de dibujo de gráficos.
Objeto gráfico. Objeto
Gráfico (opciones)
EloptionsEl parámetro es la configuración del gráfico.Chart()Parámetro de funciónoptionses unaJSONSe puede distribuir en serieHighStocksParámetro paraHighcharts.StockChart- Un ejemplo adicional.__isStockse añade atributo sobre el parámetro nativo, y si__isStock:falseSi se especifica el valor de la tabla, se muestra como un gráfico normal.__isStockel atributo se establece en un valor falso, por ejemplofalse, es decir, el gráfico utilizado es unHighchartsSi el__isStockel atributo se establece en un valor verdadero, por ejemplotrue, es decir, el gráfico utilizado es unHighstocksgráfico (por defecto)__isStockes cierto por ejemplotrue) Puede consultar elBiblioteca de gráficos de HighStocks- ¿ Por qué?
opciones
verdadero
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});
}
}
Configuración de dibujo de gráficos múltiples:
extension.layoutatributo
Si el atributo está establecido con el valor extension.heightatributo
El atributo se utiliza para establecer la altura del gráfico, ya sea como un valor numérico, o como extension.colatributo
El atributo se utiliza para establecer el ancho del gráfico, el ancho de la página se divide en 12 celdas, conjunto 8, es decir, el gráfico ocupa 8 celdas de ancho.// 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);
}
}
Ejemplo de un dibujo simple:
// Objects used to initialize the chart
var chart = {
// Chart title
title: {text: "line value triggers the plotLines value"},
// Y-axis related settings
yAxis: {
// A horizontal line perpendicular to the Y-axis, used as a trigger line, is a structural array that can set multiple trigger lines
plotLines: [{
// The value of the trigger line, how much it set, this line will be displayed in the corresponding value position
value: 0,
// Set the color of the trigger line
color: 'red',
// Width
width: 2,
// Displaying labels
label: {
// Label text
text: 'Trigger value',
// Centered label position
align: 'center'
}
}]
},
// X-axis related settings, here the setting type is time axis
xAxis: {type: "datetime"},
series: [
{name: "sin", type: "spline", data: []},
// This is an important data series, you can set multiple data series, according to the array index control
{name: "cos", type: "spline", data: []}
]
}
function main(){
// Circumference
var pi = 3.1415926535897
// Variables for recording timestamps
var time = 0
// Angle
var angle = 0
// Coordinate y values for receiving sine and cosine values
var y = 0
// Call the API interface to initialize the chart with the chart object
var objChart = Chart(chart)
// Initially, clear the chart
objChart.reset()
// Set the value of the trigger line to 1
chart.yAxis.plotLines[0].value = 1
// Loop
while(true){
// Get the timestamp of the current moment
time = new Date().getTime()
// Angle increases by 5 degrees every 500ms and calculates the sine value
y = Math.sin(angle * 2 * pi / 360)
// Write the calculated y value to the data series of the corresponding index of the chart, the first parameter of the add function is the specified data series index
objChart.add(0, [time, y])
// Calculate the cosine value
y = Math.cos(angle * 2 * pi / 360)
objChart.add(1, [time, y])
// Increase by 5 degrees
angle += 5
// Pause for 5 seconds to avoid drawing too often and growing data too fast
Sleep(5000)
}
}
import math
import time
chart = {
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
}
def main():
pi = 3.1415926535897
ts = 0
angle = 0
y = 0
objChart = Chart(chart)
objChart.reset()
chart["yAxis"]["plotLines"][0]["value"] = 1
while True:
ts = time.time() * 1000
y = math.sin(angle * 2 * pi / 360)
objChart.add(0, [ts, y])
y = math.cos(angle * 2 * pi / 360)
objChart.add(1, [ts, y])
angle += 5
Sleep(5000)
void main() {
json chart = R"({
"title": {"text": "line value triggers the plotLines value"},
"yAxis": {
"plotLines": [{
"value": 0,
"color": "red",
"width": 2,
"label": {
"text": "trigger value",
"align": "center"
}
}]
},
"xAxis": {"type": "datetime"},
"series": [{"name": "sin", "type": "spline", "data": []},
{"name": "cos", "type": "spline", "data": []}]
})"_json;
auto pi = 3.1415926535897;
auto ts = 0;
auto angle = 0.0;
auto y = 0.0;
auto objChart = Chart(chart);
objChart.reset();
chart["yAxis"]["plotLines"][0]["value"] = 1;
while(true) {
ts = Unix() * 1000;
y = sin(angle * 2 * pi / 360);
objChart.add(0, {ts, y});
y = cos(angle * 2 * pi / 360);
objChart.add(1, {ts, y});
angle += 5;
Sleep(5000);
}
}
Ejemplo de dibujo de curvas trigonométricas:
/*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;
}
}
Ejemplos complejos de uso 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);
Las tablas de tipopiePor ejemplo, el código en el ejemplo anterior actualiza el gráfico usandoc.update(chartCfg)después de actualizar los datos, como sigue:
ElChart()función devuelve un objeto de gráfico que tiene 4 métodos:add(), reset(), update(), del().
update()Método:
Elupdate()El parámetro de este método es el objeto de configuración de gráfico (JSON).del()Método:
Eldel()El método puede eliminar la serie de datos del índice especificado basado en el parámetro de serie pasado.add()Método:
Eladd()El método puede escribir datos en el gráfico, con los siguientes parámetros en orden:series: se utiliza para establecer el índice de la serie de datos, que es un número entero.data: se utiliza para establecer los datos específicos a escribir, es una matriz.index(opcional): se utiliza para establecer el índice de datos, es un número entero.-1se refiere a los últimos datos del conjunto de datos.
Por ejemplo, al dibujar una línea, modificar los datos en el último punto de la línea:chart.add(0, [1574993606000, 13.5], -1), es decir, cambiar los datos en el penúltimo primer punto del gráficoseries[0].data- ¿ Por qué?
Elindexno se establece el parámetro, lo que significa que los datos se añaden al último punto de la serie de datos actual.reset()Método:
Elreset()El método se utiliza para vaciar los datos del gráfico.reset()método puede tomar un parámetroremainPara especificar el número de entradas a mantener.remainse pasa para borrar todos los datos.¿Por qué no lo haces?
La función se utiliza para el dibujo personalizado en el tiempo de ejecución de la estrategia utilizando un método de dibujo similar a laPine language.
El objeto de la tabla.KLineChart()función devuelve un objeto de gráfico con varios métodos, entre los cuales usted necesita prestar atención abegin()yclose()La operación de dibujo debe comenzar con unbegin()llamada de la función y termina con unclose()llamada de la función cuando se atraviesa sobre los datos KLine para realizar la operación de dibujo.
objeto
Las opciones de KLineChart
Eloptionsel parámetro es la configuración del gráfico.
opciones
verdadero
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
Si un objeto de control de gráfico es necesario para dibujar en el área de dibujo de estrategia personalizada, utilizar elKLineChart()La función para crear el objeto.KLineChart()La función es una estructura de configuración de gráficos, la utilizada en el código de referencia es simple:{overlay: true}. Esta estructura de configuración de gráfico sólo establece el contenido de dibujo a ser emitido en el gráfico principal.overlayse establece en un valor falso, por ejemplofalseSi necesita especificar una función de dibujo para dibujar en el gráfico principal, también puede especificar el parámetrooverlaycomo un valor verdadero en la llamada de función específica, por ejemplo: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
Las funciones de la interfaz de dibujo delPinelas lenguas soportadas en la operación de dibujo son:barcolor, que establece el color de la línea K.
barcolor ((color, offset, editable, show_last, título, muestra) Los parámetros de visualización son opcionales:
ninguno , todos
c.bgcolor('rgba(0, 255, 0, 0.5)')
c.bgcolor('rgba(0, 255, 0, 0.5)')
// Not supported for now
bgcolor, llena el fondo de la línea K con el color especificado.
bgcolor ((color, offset, editable, show_last, título, visualización, superposición) Los parámetros de visualización son opcionales:
ninguno , todos
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, trazar una serie de datos en un gráfico.
plot ((serie, título, color, ancho de línea, estilo, precio de seguimiento, base de datos, desplazamiento, unión, editable, show_last, visualización) Los parámetros de estilo son opcionales:
stepline_diamond , stepline , cross , areabr , area , circles , columns , histogram , linebr , line Los parámetros de visualización son opcionales: ninguno , todos
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, llenar el fondo entre dos gráficos ohlinecon los colores proporcionados.
rellenar ((línea1, línea2, color, título, editable, rellenar espacios, mostrar) Los parámetros de visualización son opcionales:
ninguno , todos
Desde elJavaScriptlenguaje no puede especificar los parámetros entrantes basados en los nombres de función parámetros formales, para resolver este problema, se puede utilizar un{key: value}estructura para especificar los parámetros a pasar a un nombre de parámetro formal determinado.
Por ejemplo, el código de referencia utiliza{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)'}Especifica elcolorParámetro delfillla función.
Si necesita especificar varios parámetros con nombres de parámetros de forma consecutiva, puede utilizar{key1: value1, key2: value2, key3: value3}- ¿ Por qué?
Por ejemplo, en este ejemplo, untitlese especifica el parámetro:{color: bar.Close > bar.Open ? 'rgba(255, 0, 0, 0, 0.2)' : 'rgba(255, 0, 0, 0, 0.2)', title: 'fill'}- ¿ Por qué?
Para el valor del color, se puede establecer con'rgba(255, 0, 0, 0, 0.2)'o con'#FF0000'.
c.hline(bar.High)
c.hline(bar.High)
// Not supported for now
hline, la línea horizontal se presenta a un nivel de precio fijo dado.
línea ((precio, título, color, estilo de línea, ancho de línea, editable, pantalla) Los parámetros del estilo de línea son opcionales:
dashed , dotted , solid Los parámetros de visualización son opcionales: ninguno , todos
c.plotarrow(bar.Close - bar.Open)
c.plotarrow(bar.Close - bar.Open)
// Not supported for now
plotarrow, trazar flechas hacia arriba y hacia abajo en la tabla.
Plotarrow ((serie, título, colorup, colorado, desplazado, minheight, maxheight, editable, show_last, display) Los parámetros de visualización son opcionales:
ninguno , todos
c.plotshape(bar.Low, {style: 'diamond'})
c.plotshape(bar.Low, style = 'diamond')
// Not supported for now
plotshape, dibujar formas visuales en el gráfico.
Plotshape (serie, título, estilo, ubicación, color, desplazamiento, texto, color de texto, editable, tamaño, show_last, pantalla) Los parámetros de estilo son opcionales:
diamond size.autoEs pequeño. Los parámetros de visualización son opcionales:, square , label_down , label_up , arrow_down , arrow_up , circle , flag , triangle_down , triangle_up , cross , xcross Los parámetros de ubicación son opcionales: bar superior , bar inferior , top , bottom , absolute Los parámetros de tamaño son opcionales: 10px , 14px , 20px , 40px , 80px , comparando size.tiny, size.small, size.normal, size.large, size.huge en el lenguaje Pine. ninguno , todos
c.plotchar(bar.Close, {char: 'X'})
c.plotchar(bar.Close, char = 'X')
// Not supported for now
plotchar, dibujar formas visuales en el gráfico utilizando cualquier carácter Unicode dado.
plotchar ((serie, título, char, ubicación, color, desplazamiento, texto, color de texto, editable, tamaño, show_last, pantalla) Los parámetros de ubicación son opcionales:
bar superior size.autoEs pequeño. Los parámetros de visualización son opcionales:, bar inferior , top , bottom , absolute Los parámetros de tamaño son opcionales: 10px , 14px , 20px , 40px , 80px , comparando size.tiny, size.small, size.normal, size.large, size.huge en el lenguaje Pine. ninguno , todos
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, trazar un gráfico de línea K en un gráfico.
plotcandle ((abierto, alto, bajo, cerrado, título, color, wickcolor, editable, show_last, bordercolor, display) Los parámetros de visualización son opcionales:
ninguno , todos
c.signal("long", bar.High, 1.5)
c.signal("long", bar.High, 1.5)
// Not supported for now
signal, una función no disponible en el lenguaje Pine, se utiliza para dibujar señales de compra y venta aquí.
señal ((dirección, precio, cantidad, identificación) El parámetro
long se pasa para indicar la dirección de la transacción, se puede elegir long , closelong , short , closeshort . bar.Highes la posición del eje Y de la señal de marca. El parámetro 1.5 que se pasa indica el número de transacciones de la señal. El cuarto parámetro se puede pasar para reemplazar el contenido de texto predeterminado dibujado, y el texto predeterminado del marcador de señal dibujado es la dirección de la transacción, por ejemplocloselong .
c.reset()
c.reset()
// Not supported for now
reset, una función no disponible en el lenguaje Pine, se utiliza para vaciar los datos del gráfico.
Reinicio (remain) El
reset()el método puede adoptar un parámetro,remain, para especificar el número de datos a conservar.remainsignifica borrar todos los datos.
Estrategia dibujo personalizado sólo puede utilizar una de las formas deKLineChart()función oChart()Para algunas configuraciones de color y estilo utilizadas en elKLineChart()llamada de la función, por favor consulte elUtilice la función KLineChart para hacer más fácil el diseño del dibujo de estrategias.
¿Por qué no lo haces?
Limpia el registro.
LogReset ((permanecer)
ElremainEl parámetro se utiliza para establecer el número de entradas de registro recientes que se deben conservar.
Quedarse
falsos
Número
function main() {
// Keep the last 10 logs and clear the rest
LogReset(10)
}
def main():
LogReset(10)
void main() {
LogReset(10);
}
El registro de inicio para cada inicio de la estrategia de negociación en vivo cuenta como uno, por lo que si no se pasan parámetros y no hay salida de registro al comienzo de la estrategia, no se mostrarán registros en absoluto, esperando que se devuelva el registro de docker (no es una excepción).
¿Por qué no lo haces?
Se utiliza para recuperar el espacio de almacenamiento ocupado porEs muy bueno.Cuando se eliminan datos después de llamar alLogReset()Función para borrar el registro.
LogVacuum (en inglés)
function main() {
LogReset()
LogVacuum()
}
def main():
LogReset()
LogVacuum()
void main() {
LogReset()
LogVacuum()
}
La razón es queSQLiteno recupera el espacio ocupado al eliminar datos, y necesita ejecutarVACUUMLa operación de movimiento de archivo ocurre cuando se llama esta función, y el retraso es grande, por lo que se recomienda llamar a un intervalo de tiempo adecuado.
¿Por qué no lo haces?
Se utiliza para la salida de información de depuración en la columna 123456, elconsole.logla función de salida de depuración de la información en la página de comercio en vivo, y al mismo tiempo, crear un archivo de registro con la extensión.logy escribir la información de depuración en el/logs/storage/123456/en el directorio del docker al que pertenece el comercio en vivo, con el prefijo de nombre de archivostdout_.
Console.log (...msgs)
El parámetromsges el contenido de la salida, y el parámetromsgpuede ser superado por más de uno.
mensaje de texto
falsos
cadena, número, bool, objeto, matriz, nulo y otros tipos compatibles con el sistema.
function main() {
console.log("test console.log")
}
# Not supported
// Not supported
JavaScriptEl lenguaje apoya esta función.[object Object], así que trate de obtener tanta información legible como sea posible.¿Por qué no lo haces?
Se utiliza para la salida de error en el campo 123456, elconsole.errorLa función crea un archivo de registro con la extensión.logEn el/logs/storage/123456/directorio del docker donde pertenece el comercio en vivo, y escribe la salida de error con el prefijostderr_.
Console.error (...msgs) (Efectos de la consola)
El parámetromsges el contenido de la salida, y el parámetromsgpuede ser superado por más de uno.
mensaje de texto
falsos
cadena, número, bool, objeto, matriz, nulo y otros tipos compatibles con el sistema.
function main() {
console.error("test console.error")
}
# Not supported
// Not supported
JavaScriptEl lenguaje apoya esta función.[object Object], así que trate de obtener tanta información legible como sea posible.¿Por qué no lo haces?
Obtener la estructura {@struct/Ticker Ticker} del spot o contrato correspondiente al par de operaciones establecido actualmente, el código del contrato, es decir, los datos del ticker.GetTicker ()Función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}, el uso deexchangefunciones (métodos) de miembros de objetos relacionadas únicamente conexchange, y no se repetirá en el documento.
Elexchange.GetTicker()función devuelve la estructura {@struct/Ticker Ticker} cuando la solicitud de datos tiene éxito, y devuelve el valor nulo cuando la solicitud de datos falla.
{@struct/Ticker Ticker}, valor nulo
El cambio.GetTicker ((() intercambio.GetTicker (símbolo)
El parámetrosymbolse utiliza para especificar el par de operaciones específico y el código de contrato correspondiente a los datos {@struct/Ticker Ticker} solicitados. Si no se pasa este parámetro, se solicitarán por defecto los datos de mercado del par de operaciones y el código de contrato actualmente establecidos.
Cuando se llama a laexchange.GetTicker(symbol)función,exchangeSi necesita solicitar datos de mercado con la moneda denominada en USDT y la moneda de negociación en BTC, el parámetrosymboles:"BTC_USDT", y el formato es el formato del par de operaciones definido por la plataforma FMZ.
Cuando se llama a laexchange.GetTicker(symbol)función,exchangeSi usted necesita solicitar los datos de mercado de BTCsymboles:"BTC_USDT.swap", y el formato es una combinación dePares de negociaciónycódigo del contratodefinidas por la plataforma FMZ, separadas por el carácter exchange.GetTicker(symbol)función,exchangeSi usted necesita solicitar los datos de mercado de BTCsymboles:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo), el formato es la combinación dePares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el carácter
el símbolo falsos la cuerda
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 los objetos de cambio de futuros (es decir,exchangeo bienexchanges[0]), debe establecer el código del contrato utilizando elexchange.SetContractType()función antes de llamar a la función ticker, que no se repetirá.
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);
}
Utilice elsymbolParámetro para solicitar datos de mercado para un símbolo específico (símbolo spot).
ElTickerdatos devueltos por elexchange.GetTicker()En la actualidad, la mayoría de los sistemas de backtesting se encuentran integrados en el sistema.HighyLowLos valores simulados, tomados de los valores de venta y compra del mercado en ese momento.Tickerdatos devueltos por elexchange.GetTicker()En el mercado real, elHighyLowLos valores se basan en los datos devueltos por el intercambio encapsuladoTickInterfaz, que incluye los precios más altos y más bajos dentro de un determinado período (generalmente un período de 24 horas).
Los intercambios que no apoyan elexchange.GetTicker()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| ¿ Qué haces? | – | El valor de las pérdidas |
En el caso de las empresas que no se encuentran en el mercado de valores, el valor de los valores obtenidos es el valor de los valores obtenidos en el mercado.
Obtener la estructura {@struct/Depth Depth} del spot o contrato correspondiente al par de operaciones establecido actualmente, código del contrato, es decir, datos de la cartera de órdenes.
Elexchange.GetDepth()La función devuelve la estructura {@struct/Depth Depth} si la solicitud de datos tiene éxito, y devuelve nulo si la solicitud de datos falla.
{@struct/Depth Depth}, valor nulo
El cambio.GetDepth() intercambio.Simbolo de Profundidad.
El parámetrosymbolSe utiliza para especificar el par de operaciones específico y el código del contrato correspondiente a los datos {@struct/Depth Depth} solicitados. Si no se pasa este parámetro, se solicitarán por defecto los datos del libro de órdenes del par de operaciones actualmente establecido y el código del contrato.exchange.GetDepth(symbol)función,exchangeSi necesita solicitar obtener los datos del libro de pedidos con la moneda denominada en USDT y la moneda de la transacción en BTC, el parámetrosymboles:"BTC_USDT", y el formato es el formato del par de operaciones definido por la plataforma FMZ.exchange.GetDepth(symbol)función,exchangeSi necesita solicitar los datos del libro de pedidos del contrato perpetuo estándar U de BTCsymboles:"BTC_USDT.swap", y el formato es una combinación dePares de negociaciónycódigo del contratodefinido por la plataforma FMZ, separado por el carácter exchange.GetDepth(symbol)función,exchangeSi necesita solicitar los datos del libro de pedidos del contrato de opción estándar U de BTCsymboles:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo), el formato es la combinación dePares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el 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);
}
Pruebaexchange.GetDepth()Función:
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);
}
Cuando el configuradoexchangeobjeto es un objeto de intercambio de futuros, utilizar elsymbolParámetro para solicitar los datos del libro de pedidos de un símbolo específico (símbolo de futuros).
En el sistema de backtesting, los datos de cada grado devueltos por elexchange.GetDepth()Función cuando se utiliza elSimulación de tickEn el sistema de backtesting, los datos devueltos por elexchange.GetDepth()Función cuando se utiliza elEl verdadero tickLas pruebas de retroceso son una instantánea profunda de segundo nivel.
Se trata de una lista de las acciones que se han emitido en el mercado de valores de valores de valores de valores.
Obtener la matriz de estructura {@struct/Trade Trade} del spot o contrato correspondiente al par de operaciones establecido actualmente, código del contrato, es decir, los datos de transacción de mercado.
Elexchange.GetTrades()La función devuelve una matriz de estructuras {@struct/Trade Trade} si la solicitud de datos tiene éxito, y devuelve valores nulos si la solicitud de datos falla.
{@struct/Trade Trade} matriz, valores nulos
En cambio.GetTrades ((() el símbolo de intercambio.GetTrades
El parámetrosymbolSe utiliza para especificar el par de operaciones específico y el código del contrato correspondiente a los datos de la matriz {@struct/Trade Trade} solicitados. Si no se pasa este parámetro, se solicitarán por defecto los últimos datos del registro de transacciones del par de operaciones y el código del contrato actualmente establecidos.exchange.GetTrades(symbol)función,exchangeSi necesita solicitar obtener los datos del libro de pedidos con la moneda denominada en USDT y la moneda de negociación en BTC, el parámetrosymboles:"BTC_USDT", y el formato es el formato del par de operaciones definido por la plataforma FMZ.exchange.GetTrades(symbol)función,exchangeSi necesita solicitar los datos del libro de pedidos del contrato perpetuo estándar U de BTCsymboles:"BTC_USDT.swap", y el formato es una combinación dePares de negociaciónycódigo del contratodefinido por la plataforma FMZ, separado por el carácter exchange.GetTrades(symbol)función,exchangeSi necesita solicitar los datos del libro de pedidos del contrato de opción estándar U de BTCsymboles:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo), el formato es la combinación dePares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el 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);
}
Prueba elexchange.GetTrades()Función:
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);
}
Cuando el configuradoexchangeobjeto es un objeto de intercambio de futuros, utilizar elsymbolParámetro para solicitar datos de registro de transacciones de mercado para un símbolo específico (símbolo de futuros).
exchange.GetTrades()Algunos intercambios no admiten esta función, y los datos específicos devueltos son cuánto del rango de registros de transacciones depende del intercambio y necesita ser manejado de acuerdo con la situación específica.exchange.GetRecords ()La función devuelve el mismo orden de datos, es decir, el último elemento de la matriz es el dato más cercano al tiempo actual.
Elexchange.GetTrades()función devuelve una matriz vacía cuando se utilizaSimulación de tickLos datos devueltos por elexchange.GetTrades()Función en el usoEl verdadero tickLa prueba de retroceso en el sistema de prueba de retroceso es la toma instantánea de los datos del flujo de pedidos, es decir, la matriz de estructuras {@struct/Trade Trade}.
Los intercambios que no apoyan elexchange.GetTrades()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener Trades | – | Los valores de los activos de la entidad de crédito que no se incluyen en el balance de la entidad de crédito |
En el caso de las empresas que no se encuentran en el mercado, las empresas que no se encuentran en el mercado deben tener un registro de los resultados de los intercambios.
Obtener la matriz de estructura {@struct/Record Record} del spot o contrato correspondiente al par de operaciones establecido actualmente, código del contrato, es decir, datos de línea K.
Elexchange.GetRecords()función devuelve una matriz de {@struct/Record Record} estructuras cuando la solicitud de datos tiene éxito, y devuelve valores nulos cuando la solicitud de datos falla.
{@struct/Record Record} matrices, valores nulos
¿ Qué pasa con los registros? intercambio.GetRecords (símbolo) intercambio.GetRecords (símbolo, punto) intercambio.GetRecords (símbolo, punto, límite) El cambio.GetRecords (período) intercambio.GetRecords (período, límite)
El parámetrosymbolSe utiliza para especificar el par de operaciones específico y el código del contrato correspondiente a los datos de la matriz {@struct/Record Record} solicitados. Si este parámetro no se pasa, se solicitarán por defecto los datos de la línea K del par de operaciones actualmente establecido y el código del contrato.exchange.GetRecords(symbol)función,exchangeSi necesita solicitar obtener los datos con la moneda denominada como USDT y la moneda de la transacción como BTC, el parámetrosymboles:"BTC_USDT", y el formato es el formato del par de operaciones definido por la plataforma FMZ.exchange.GetRecords(symbol)función,exchangeSi necesita solicitar los datos del libro de pedidos del contrato perpetuo estándar U de BTCsymboles:"BTC_USDT.swap", y el formato es una combinación dePares de negociaciónycódigo del contratodefinido por la plataforma FMZ, separado por el carácter exchange.GetRecords(symbol)función,exchangeSi necesita solicitar los datos del libro de pedidos del contrato de opción estándar U de BTCsymboles:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo), el formato es la combinación dePares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el carácter periodespecifica el período de los datos de línea K solicitados, por ejemplo: {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15}, etc. El valor del parámetroperiodSi este parámetro no se pasa, el período de los datos de línea K solicitados por defecto es el período de línea K predeterminado de la configuración actual de estrategia en tiempo real/backtest.
el período
falsos
Número
El parámetrolimitSe utiliza para especificar la longitud de los datos de línea K solicitados. Si este parámetro no se pasa, la longitud de la solicitud predeterminada es el número máximo de barras de línea K solicitadas en un momento de la interfaz de línea K de intercambio. Este parámetro puede causar que la paginación solicite los datos de línea K de intercambio, y el consumo de tiempo de la llamada de función aumentará durante la consulta de paginación.
el límite
falsos
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]);
}
Obtener datos de línea K para un 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]);
}
Datos de barra de la línea K de salida:
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);
}
Cuando el configuradoexchangeobjeto es un objeto de intercambio de futuros, utilizar elsymbol, period, ylimitlos parámetros para solicitar los datos de línea K de un producto específico (producto futuro).
El período predeterminado de la línea K se puede establecer en las páginas de backtest y de operaciones reales.exchange.GetRecords()Si no se especifica ningún parámetro cuando se llama la función, se devolverán los datos de línea K correspondientes de acuerdo con el período de línea K establecido en el backtest y los parámetros reales del mercado.
El valor de retorno es una matriz deRecordEn el caso de las estructuras, los datos de línea K devueltos se acumularán con el tiempo, el límite superior de las barras de línea K acumuladas se ve afectado por laexchange.SetMaxBarLen()El límite predeterminado es de 5000 bares cuando no está establecido. Cuando los datos de la línea K alcanzan el límite de acumulación de la barra de la línea K, se actualizarán agregando una barra de la línea K y eliminando la barra de la línea K más temprana (por ejemplo, cola de entrada/salida).TradeLas líneas K se generan en tiempo real.
Si la interfaz de línea K del intercambio admite consultas de paginación, se realizarán varias solicitudes de API al llamar alexchange.SetMaxBarLen()función para establecer una longitud de línea K más grande.
Cuando elexchange.GetRecords()Cuando la función se llama inicialmente, el número de barras de línea K obtenidas difiere entre la prueba posterior y la negociación real: - El sistema de prueba posterior obtendrá un cierto número de barras de línea K antes del inicio del intervalo de tiempo de prueba posterior por adelantado (el valor predeterminado es 5000, la configuración del sistema de prueba posterior y la cantidad de datos afectarán al número final devuelto), como los datos iniciales de línea K. - El número de barras de línea K obtenidas durante la negociación real se basa en la cantidad máxima de datos que se pueden obtener de la interfaz de línea K de la bolsa.
ElperiodSi el parámetro se establece en 5, que es una solicitud para obtener datos de línea K con un período de 5 segundos.periodel parámetro no es divisible por 60 (es decir, el período representado no es divisible por minutos).exchange.GetTrades()En el caso de las transacciones, los datos de registro de transacciones deben ser obtenidos y los datos de línea K requeridos sintetizados.periodSi el parámetro es divisible por 60, entonces los datos de línea K requeridos se sintetizan utilizando un mínimo de datos de línea K de 1 minuto (si es posible, los datos de línea K requeridos se sintetizan utilizando un período más largo).
La simulación de nivel de backtesting en el sistema de backtesting requiere la configuración del período de la línea K subyacente (cuando el sistema de backtesting simula la backtesting de nivel, los datos de la línea K correspondientes se utilizan para generar datos de Tick de acuerdo con el período de la línea K subyacente).
ElC++lenguaje tiene el siguiente ejemplo de código si necesita construir sus propios datos de línea 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);
}
Los intercambios que no apoyan laexchange.GetRecords()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener registros | Zaif / Coincheck / BitFlyer. ¿ Qué es esto? | El valor de las pérdidas |
Se trata de un sistema de intercambio de datos que permite a los operadores de los mercados de datos de obtener información sobre las operaciones de intercambio de datos.
Obtener el período de línea K establecido en la página web de la plataforma de comercio de FMZ Quant cuando backtesting y ejecutar la estrategia en el comercio en vivo, es decir, el período de línea K predeterminado utilizado al llamar a laexchange.GetRecords()Función sin pasar parámetros.
Período de línea K en segundos, valor entero en segundos. Número
cambio.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");
}
¿Por qué no lo haces?
Establezca la longitud máxima de la línea K.
En el caso de los productos de la clase A, el valor de la diferenciación será el mismo.
El parámetronse utiliza para especificar la longitud máxima de la línea K.
No
verdadero
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]);
}
Elexchange.SetMaxBarLen()La función afecta dos aspectos para el tiempo de ejecución de la estrategia de criptomonedas:
¿Por qué no lo haces?
Obtener el contenido original devuelto por el últimorestsolicitud para el objeto de intercambio actual ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).
Los datos de respuesta para elrestel pedido.
la cuerda
¿Qué está pasando?
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);
}
Elexchange.GetRawJSON()Las estrategias de negociación en el mercado de divisas no soportan esta función.C++ language.
¿Qué es lo que está pasando?
Obtener el tipo de cambio actualmente establecido para el objeto de intercambio.
El valor actual del tipo de cambio del objeto de cambio. Número
El cambio.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());
}
Si esexchange.SetRate()No ha sido convocado para fijar el tipo de conversión, elexchange.GetRate()La función devuelve un valor de tasa predeterminado de 1. Es decir, los datos relacionados con la moneda que se muestra actualmente (quoteCurrency) no se han convertido.
Si se ha establecido un valor de tipo de cambio utilizandoexchange.SetRate(), por ejemplo,exchange.SetRate(7)Luego, toda la información de precios, tales como cotizaciones, profundidades y precios de pedido obtenidos a través delexchangeel objeto de cambio se convertirá multiplicando por el tipo de cambio establecido7- ¿ Por qué?
Siexchangecorresponde a un intercambio con USD como moneda denominada, después de llamarexchange.SetRate(7), todos los precios en el mercado en vivo se convertirán a un precio cercano al yuan por multiplicación7En este punto, el valor del tipo de cambio obtenido utilizandoexchange.GetRate()es7.
¿Por qué no lo haces?
Elexchange.SetData()La función se utiliza para establecer los datos cargados cuando se ejecuta la estrategia.
La longitud de la cadena después del parámetrovalueCodificación JSON.
Número
intercambio.Configurar datos (clave, valor)
Nombre de la recopilación de datos.
llave
verdadero
la cuerda
Los datos que deben cargarse por elexchange.SetData()La estructura de datos es la misma que el formato de datos solicitado por elexchange.GetData()Función al solicitar datos externos, es decir:"schema": ["time", "data"]- ¿ Por qué?
Valor
verdadero
el conjunto
/*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);
}
}
Se requiere que los datos para el parámetrovalueSe trata de un documento que debe tener el mismo formato que eldatavariable en el siguiente ejemplo.1579622400000corresponde al tiempo2020-01-22 00:00:00, y que cuando el programa de estrategia se ejecuta después de este tiempo, llamar a laexchange.GetData()Función para obtener los datos antes de la próxima marca de tiempo de los datos1579708800000, es decir, el tiempo2020-01-23 00:00:00Lo que obtienes es[1579622400000, 123]el contenido de esos datos, a medida que el programa continúa ejecutándose, el tiempo cambia, y así sucesivamente para obtener el elemento de datos por elemento. en el siguiente ejemplo, en tiempo de ejecución (backtesting o comercio en vivo), el momento actual alcanza o excede la marca de tiempo1579795200000, elexchange.GetData()La función se llama y el valor de retorno es:{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000corresponde a1579795200000en los datos[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]corresponde a los datos["abc", 123, {"price": 123}]]En el[1579795200000, ["abc", 123, {"price": 123}]].
Los datos cargados pueden ser cualquier indicador económico, datos de la industria, indicadores relevantes, etc., utilizados para la evaluación cuantitativa de la estrategia de toda la información cuantificable.
¿Por qué no lo haces?
Elexchange.GetData()La función se utiliza para obtener datos cargados por elexchange.SetData()Función o proporcionado por un enlace externo.
Registros en la recopilación de datos. Objeto
El cambio.GetData ((clave) intercambio.GetData ((clave, tiempo de espera)
El nombre de la recopilación de datos. llave verdadero la cuerda Se utiliza para establecer el tiempo de caché en milisegundos. tiempo de espera falsos 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);
}
}
La llamada para obtener los datos escritos directamente.
/*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);
}
}
Apoya la solicitud de datos a través de enlaces externos, el formato de los datos solicitados para:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
¿Dónde está?schemaes el formato de datos de cada registro en el cuerpo de los datos cargados, que se fija en["time", "data"]correspondiente al formato de los datos de entrada por entrada en eldatael atributo.
Lo que se almacena en eldataatributo es el cuerpo de los datos, con cada entrada que consta de una marca de tiempo de nivel de milisegundos y el contenido de los datos (que pueden ser cualquier dato codificable en JSON).
El programa de servicio para pruebas, escrito en Go:
package main
import (
"fmt"
"net/http"
"encoding/json"
)
func Handle (w http.ResponseWriter, r *http.Request) {
defer func() {
fmt.Println("req:", *r)
ret := map[string]interface{}{
"schema": []string{"time","data"},
"data": []interface{}{
[]interface{}{1579536000000, "abc"},
[]interface{}{1579622400000, 123},
[]interface{}{1579708800000, map[string]interface{}{"price":123}},
[]interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
},
}
b, _ := json.Marshal(ret)
w.Write(b)
}()
}
func main () {
fmt.Println("listen http://localhost:9090")
http.HandleFunc("/data", Handle)
http.ListenAndServe(":9090", nil)
}
Los datos de respuesta del programa al recibir la solicitud:
{
"schema":["time","data"],
"data":[
[1579536000000, "abc"],
[1579622400000, 123],
[1579708800000, {"price": 123}],
[1579795200000, ["abc", 123, {"price": 123}]]
]
}
Código de la estrategia de ensayo:
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"));
}
El método de llamada para obtener los datos de un enlace 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"));
}
Solicitar datos para una consulta creada en la plataformaDatos y datos, solicitando que el formato de datos de la respuesta sea (debe contener tiempo, campos de datos descritos en el esquema):
{
"data": [],
"schema": ["time", "data"]
}
El campo exchange.GetData()Cuando se llama una función, se devuelve un objeto JSON, por ejemplo:{"Time":1579795200000, "Data":"..."}.
Obtener los datos a la vez para backtesting y almacenar en caché un minuto de datos para el comercio en vivo.from(tiempo marcado en segundos),to(tiempo marcado en segundos) a la solicitud, parámetros tales comoperiod(período de línea K subyacente, marcado en milisegundos) se utilizan para determinar el período de tiempo durante el cual se deben adquirir los datos.
¿Qué es lo que está pasando?
Elexchange.GetMarkets()La función se utiliza para obtener información sobre el mercado de divisas.
Diccionario que contiene la estructura {@struct/Market Market}. Objeto
En cambio.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]);
}
Ejemplo de llamada a un objeto de cambio 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() + "`");
}
Utilice el objeto de intercambio de futuros para llamar a laexchange.GetMarkets()Antes de llamar a cualquier función de mercado, GetMarkets solo devuelve los datos de mercado del par de operaciones predeterminado actual. Después de llamar a la función de mercado, devuelve los datos de mercado de todas las variedades solicitadas. Puede consultar el siguiente ejemplo de prueba:
Elexchange.GetMarkets()función devuelve un diccionario con una clave llamada el nombre de la variedad comercial, y para fijaciones al contado formateadas como un par comercial, por ejemplo:
{
"BTC_USDT" : {...}, // The key value is the Market structure
"LTC_USDT" : {...},
...
}
Para los intercambios de contratos de futuros, ya que puede haber múltiples contratos para una sola variedad, por ejemplo:BTC_USDTEn el caso de los contratos de comercio de pares, hay contratos perpetuos, contratos trimestrales, etc.exchange.GetMarkets()función devuelve un diccionario con el nombre clave del par combinado con el código del contrato, por ejemplo:
{
"BTC_USDT.swap" : {...}, // The key value is the Market structure
"BTC_USDT.quarter" : {...},
"LTC_USDT.swap" : {...},
...
}
exchange.GetMarkets()La función admite operaciones en vivo, sistema de backtesting.exchange.GetMarkets()La función devuelve información de mercado sólo para las variedades que se negocian en línea en el intercambio.exchange.GetMarkets()La función no admite contratos de opciones.Los intercambios que no apoyan laexchange.GetMarkets()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener Mercados | Coincheck / Bithumb / BitFlyer y otros | – |
¿Qué es esto?
Elexchange.GetTickers()La función se utiliza para obtener datos de ticker agregados de intercambio (la matriz de la estructura {@struct/Ticker Ticker}).exchangedevuelve datos de ticker para todos los pares de operaciones cuando se trata de un objeto de intercambio al contado;exchangedevuelve datos de ticker para todos los contratos cuando se trata de un objeto de intercambio de futuros.
Elexchange.GetTickers()función devuelve una matriz de {@struct/Ticker Ticker} estructuras cuando tiene éxito en la solicitud de datos, y nulo cuando falla.
Las matrices de {@struct/Ticker Ticker}, valores nulos
El intercambio.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());
}
}
Llama alexchange.GetTickers()Función para obtener datos 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() + "`");
}
Utilice el objeto de intercambio spot y llame alexchange.GetTickers()Antes de llamar a cualquier función de mercado, GetTickers solo devuelve los datos de ticker del par de operaciones predeterminado actual. Después de llamar a la función de mercado, devuelve los datos de ticker de todas las variedades solicitadas. Puede consultar el siguiente ejemplo de prueba:
Los intercambios que no apoyan laexchange.GetTickers()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Los GetTickers | Zaif / WOO / Géminis / Coincheck / BitFlyer / Bibox | Los futuros de los bancos centrales de los Estados miembros que no cumplan los requisitos de la Directiva 2009/138/CE se considerarán como activos de la entidad de crédito. |
¿Por qué no lo haces?
Elexchange.Buy()La función se utiliza para realizar órdenes de compra.Buy()La función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}.Buy()La función opera en la cuenta de cambio vinculada al objeto de cambioexchangeEl objetivo de las funciones (métodos) de los miembros de laexchangeobjeto sólo está relacionado conexchange, y no se repetirá después de la documentación.
Una orden exitosa devuelve el ID de orden, una orden fallida devuelve un valor nulo.
El atributoIdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato del par de negociación al contadoETH_USDTel orden del intercambio OKX es:ETH-USDT,1547130415509278720- ¿ Por qué?
Cuando se llama a laexchange.Buy()función para realizar una orden, la orden de valor de retornoIdes coherente con laIdatributo de la estructura de orden {@struct/Order Order}.
cadena, valor cero
intercambio.Comprar ((precio, cantidad) intercambio.Comprar ((precio, cantidad,...argumentos)
ElpriceEl parámetro se utiliza para establecer el precio de la orden.
precio
verdadero
Número
ElamountEl parámetro se utiliza para establecer el importe del pedido.
cantidad
verdadero
Número
Parámetros ampliados que pueden producir información de acompañamiento en este registro de pedidos,argLos parámetros pueden ser pasados más de uno.
el
falsos
cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}
El número de orden devuelto porexchange.Buy()puede utilizarse para consultar la información del pedido y cancelar el pedido.
// 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);
}
Cuando se realiza una orden para un contrato de futuros de criptomonedas, se debe tener cuidado de garantizar que la dirección del comercio se establezca correctamente, ya que un desajuste entre la dirección del comercio y la función del comercio dará lugar a un error:
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);
}
Orden del mercado al contado.
Al realizar una orden para un contrato de futuros, debe prestar atención a si la dirección del comercio está establecida correctamente, ya que se reportará un error si la dirección del comercio y la función del comercio no coinciden.
El parámetropriceestá configurado para:-1para la colocación de órdenes de mercado, lo que requiere que la interfaz de colocación de órdenes de la bolsa soporte las órdenes de mercado.amountes la cantidad de dinero en la moneda de la orden. al colocar órdenes de mercado para contratos de futuros de criptomonedas, el parámetro de cantidadamountes el número de contratos. Hay algunos intercambios de criptomonedas que no admiten la interfaz de orden de mercado durante la negociación en vivo. La cantidad de orden para las órdenes de compra de mercado en algunos intercambios al contado es el número de monedas comerciales.Instrucciones especiales para los intercambiosEn la Idde lasexchange.Buy()La función puede ser diferente del valor de retorno de la ordenIdse describe en el documento actual.
El valor de las operaciones de cambio se calcula en función de las condiciones de cambio de las operaciones de cambio.
Elexchange.Sell()La función se utiliza para colocar órdenes de venta.
Una orden exitosa devuelve el orden Id, una orden fallida devuelve un valor nulo.IdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato del par de negociación al contadoETH_USDTel orden del intercambio OKX es:ETH-USDT,1547130415509278720Cuando llamas a laexchange.Sell()función para realizar una orden, la orden de valor de retornoIdes coherente con laIdatributo de la estructura de orden {@struct/Order Order}.
cadena, valor cero
intercambio.Venta (precio, cantidad) intercambio.Venta ((precio, cantidad,...argumentos)
ElpriceEl parámetro se utiliza para establecer el precio de la orden.
precio
verdadero
Número
ElamountEl parámetro se utiliza para establecer el importe del pedido.
cantidad
verdadero
Número
Parámetros ampliados que pueden producir información de acompañamiento en este registro de pedidos,argLos parámetros pueden ser pasados más de uno.
el
falsos
cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}
El número de orden devuelto porexchange.Sell()puede utilizarse para consultar información de pedidos y cancelar pedidos.
// 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);
}
Cuando se realiza una orden para un contrato de futuros de criptomonedas, se debe tener cuidado de garantizar que la dirección del comercio se establezca correctamente, ya que un desajuste entre la dirección del comercio y la función del comercio dará lugar a un error:
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);
}
Orden del mercado al contado.
Al realizar una orden para un contrato de futuros, debe prestar atención a si la dirección de negociación está establecida correctamente, ya que se reportará un error si la dirección de negociación y la función de negociación no coinciden.
El parámetropriceestá configurado para:-1para la colocación de órdenes de mercado, lo que requiere que la interfaz de colocación de órdenes de la bolsa soporte las órdenes de mercado.amountCuando se colocan órdenes de mercado para contratos de futuros de criptomonedas, el parámetro de cantidadamountHay algunos intercambios de criptomonedas que no admiten la interfaz de orden de mercado durante el comercio en vivo.
Si está utilizando una versión anterior del docker, el valor de retorno de la ordenIdde lasexchange.Sell()La función puede ser diferente del valor de retorno de la ordenIdse describe en el documento actual.
El valor de las operaciones de cambio se calcula a partir de la suma de las operaciones de cambio.
Elexchange.CreateOrder()La función se utiliza para hacer un pedido.
Si el pedido se realiza con éxito, se devuelve el ID del pedido; si el pedido falla, se devuelve un valor nulo.IdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato de la orden del par de negociación al contadoETH_USDTde la bolsa OKX es:ETH-USDT,1547130415509278720Cuando llamas a laexchange.CreateOrder(symbol, side, price, amount)función para realizar una orden, el valor devuelto de la ordenIdes coherente con laIdpropiedad de la estructura del orden {@struct/Order Order}.
cadena, valor cero
intercambio.CreateOrder ((símbolo, lado, precio, cantidad) intercambio.CreateOrder ((símbolo, lado, precio, cantidad,...args)
El parámetrosymbolSe utiliza para especificar el par de operaciones específico y el código del contrato de la orden.exchange.CreateOrder(symbol, side, price, amount)función para realizar un pedido,exchangeSi la moneda denominada de la orden es USDT y la moneda de transacción es BTC, el parámetrosymboles:"BTC_USDT", en el formato del par de operaciones definido por la plataforma FMZ.exchange.CreateOrder(symbol, side, price, amount)función para realizar un pedido,exchangeSi la orden es una orden de contrato perpetuo estándar BTCsymboles:"BTC_USDT.swap", y el formato es una combinación dePares de negociaciónycódigo del contratodefinido por la plataforma FMZ, separado por el carácter exchange.CreateOrder(symbol, side, price, amount)función para realizar un pedido,exchangeSi la orden es una orden de contrato de opción estándar U de BTCsymboles:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo), y el formato es una combinación dePares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el carácter sideel parámetro se utiliza para especificar la dirección de negociación de la orden.
Para los objetos de intercambio al contado, los valores opcionales de lasidelos parámetros son:buy, sell. buysignifica comprar, ysellsignifica vender.
En el caso de los objetos de cambio de futuros, los valores opcionales de lasidelos parámetros son:buy, closebuy, sell, closesell. buysignifica la apertura de una posición larga,closebuysignifica el cierre de una posición larga,sellsignifica abrir una posición corta, yclosesellsignifica cerrar una posición corta.
el lado
verdadero
la cuerda
El parámetropriceSe utiliza para establecer el precio de la orden. Un precio de -1 indica que la orden es una orden de mercado.
precio
verdadero
Número
El parámetroamountSe utiliza para establecer la cantidad de orden. Tenga en cuenta que cuando la orden es una orden de compra de mercado, la cantidad de orden es el importe de compra; la cantidad de orden de la orden de compra de mercado de algunos intercambios al contado es el número de monedas de negociación.Instrucciones especiales para los intercambiosen la arglos parámetros pueden ser pasados.
el
falsos
Cualquier tipo compatible con el sistema, como cadena, 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);
}
Los objetos de intercambio al contado y los objetos de intercambio de futuros se denominanexchange.CreateOrder()Función para hacer un pedido.
En el caso de las empresas de servicios de la Unión Europea, el número de empresas de servicios de servicios de la Unión Europea es el siguiente:
Elexchange.CancelOrder()La función se utiliza para cancelar el pedido.
El atributoIdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato de la orden del par de negociación al contadoETH_USDTde la bolsa OKX es:ETH-USDT,1547130415509278720- ¿ Por qué?
El parámetroorderIdEn el momento de llamar a laexchange.CancelOrder()La función para cancelar una orden es consistente con laIdpropiedad de la estructura del orden {@struct/Order Order}.
Elexchange.CancelOrder()función devuelve un valor verdadero, por ejemplotruesignifica que la solicitud de orden de cancelación fue enviada con éxito. Si devuelve un valor falso, comofalseEl valor devuelto sólo representa el éxito o fracaso de la solicitud enviada para determinar si el intercambio cancela el pedido.exchange.GetOrders()para determinar si la orden se cancela.
- ¿ Qué?
Intercambio.Cancelar Pedido (Identificación del pedido) Intercambio.Cancelar Orden ((ordenId,...args)
ElorderIdEl parámetro se utiliza para especificar la orden a cancelar.
ordenado
verdadero
número, cadena
Parámetros extendidos, puede enviar la información adjunta a este registro de retiro,argLos parámetros pueden ser pasados más de uno.
el
falsos
cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}
Cancela la orden.
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);
}
}
Funciones de la API FMZ que pueden producir funciones de salida de registro tales como:Log(), exchange.Buy(), exchange.CancelOrder()puede ser seguido por algunos parámetros de salida de acompañamiento después de los parámetros necesarios, por ejemplo:exchange.CancelOrder(orders[i].Id, orders[i]), de modo que al cancelar el pedido cuyo ID esorders[i].Id, la información de la orden se emite con ella. Es decir, la estructura de {@struct/Order Order} deorders[i].
Si está utilizando una versión anterior del docker, el parámetro orderId de la función exchange.CancelOrder() puede ser diferente del orderId descrito en el documento actual.
Se trata de una lista de las acciones que se han emitido en el mercado de valores.
Elexchange.GetOrder()La función se utiliza para obtener la información del pedido.
Consultar los detalles del orden de acuerdo con el número de orden, y devolver la estructura {@struct/Order Order} si la consulta tiene éxito, o devolver nulo si la consulta falla. {@struct/Order Order}, valor nulo
En el caso de las operaciones de intercambio.GetOrder ((orderId))
ElorderIdEl parámetro se utiliza para especificar el orden a consultar.
El atributoIdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato de la orden del par de negociación al contadoETH_USDTde la bolsa OKX es:ETH-USDT,1547130415509278720- ¿ Por qué?
El parámetroorderIdEn el momento de llamar a laexchange.GetOrder()Función para consultar una orden es consistente con elIdpropiedad de la estructura del orden {@struct/Order Order}.
ordenado verdadero la cuerda
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);
}
Elexchange.GetOrder()La función no es soportada por algunos intercambios.AvgPriceAlgunos intercambios no admiten este campo, y si no lo hacen, se establece en 0.
Si está utilizando una versión anterior del docker, elorderIdParámetro delexchange.GetOrder()La función de laorderIddescrito en la documentación actual.
Los intercambios que no apoyan laexchange.GetOrder()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener orden | Zaif / Coincheck / Bitstamp. ¿ Qué es esto? | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade/Exchange
Elexchange.GetOrders()La función se utiliza para obtener pedidos pendientes.
Elexchange.GetOrders()La función devuelve una matriz de estructuras {@struct/Order Order} si la solicitud de datos tiene éxito, y devuelve valores nulos si la solicitud de datos falla.
{@struct/Order Order} matriz, valor nulo
El cambio.GetOrders ((( intercambio.GetOrders (símbolo)
El parámetrosymbolse utiliza para establecer elsímbolo de la transaccióno bienrango de símbolos de transacciónpara ser interrogado.
Para los objetos de intercambio al contado, si elsymbolSi no se pasa el parámetro, se solicitarán los datos de pedido incompletos de todos los productos al contado.
Para los objetos de cambio de futuros, si elsymbolSi el parámetro no se pasa, el valor predeterminado es solicitar los datos de orden incompletos de todas las variedades en el rango de dimensiones del par de negociación actual y el código del contrato.
el símbolo falsos la cuerda
/*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;
}
Utilice el objeto de intercambio al contado para realizar órdenes de compra para varios pares de operaciones diferentes a la mitad del precio actual y, a continuación, consultar la información de la orden pendiente.
/*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;
}
Utilizar objetos de intercambio de futuros para colocar órdenes para múltiples pares de operaciones diferentes y códigos de contrato.
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);
}
Cuando se llama a laexchange.GetOrders()Función, pasar en elSymbolParámetro para solicitar datos de orden para un par de operaciones específico y código de contrato.
En elGetOrdersFunción, los escenarios de uso del parámetro símbolo se resumen de la siguiente manera:
| Clasificación de objetos de intercambio | símbolo Parámetros | Alcance de la consulta | No obstante, |
|---|---|---|---|
| Punto | No pase el parámetro de símbolo | Consulta todos los pares de operaciones al contado | Para todos los escenarios de llamada, si la interfaz de intercambio no lo admite, se informará un error y se devolverá un valor nulo. |
| Punto | Especificar el tipo de negociación, el parámetro del símbolo es: |
Consultar el par de operaciones BTC_USDT especificado | Para los objetos de intercambio al contado, el formato del parámetro del símbolo es: |
| Los futuros | No pase el parámetro de símbolo | Consultar todos los productos de negociación dentro del rango de dimensiones del par de negociación actual y del código del contrato | Si el par de negociación actual es BTC_USDT y el código del contrato es swap, todos los contratos perpetuos con margen en USDT serán consultados.GetOrders("USDT.swap") |
| Los futuros | Especifique el tipo de negociación, el parámetro del símbolo es: |
Consultar el contrato perpetuo basado en USDT para un BTC especificado | Para los objetos de intercambio de futuros, el formato del símbolo del parámetro es:Pares de negociaciónycódigo del contratodefinidas por la plataforma FMZ, separadas por los caracteres".. |
| Los futuros | Especifique el rango de productos de negociación, el parámetro del símbolo es: |
Consultar todos los contratos perpetuos basados en USDT | - |
| Bolsas de futuros que admiten opciones | No pase el parámetro de símbolo | Consultar todos los contratos de opción dentro del rango de dimensiones del par de operaciones actual | Si el par de operaciones actual es BTC_USDT, el contrato se establece en un contrato de opción, por ejemplo, contrato de opción de Binance: BTC-240108-40000-C |
| Bolsas de futuros que admiten opciones | Especificar los productos comerciales específicos | Consultar el contrato de opción especificado | Por ejemplo, para Binance Futures Exchange, el parámetro del símbolo es: BTC_USDT.BTC-240108-40000-C |
| Bolsas de futuros que admiten opciones | Especifique la gama de productos de negociación, el parámetro del símbolo es: |
Consultar todos los contratos de opciones basados en USDT | - |
En elGetOrdersfunción, la consulta del objeto de intercambio de futuros
el rango de dimensiones se resume de la siguiente manera:
| símbolo Parámetros | Definición del rango de solicitud | No obstante, |
|---|---|---|
| USDT.swap | Los tipos de interés de las entidades de crédito incluidas en el anexo I se determinarán de acuerdo con el método de cálculo de la rentabilidad. | Para |
dimensiones que no sean compatibles con la interfaz de intercambio API, se informará de un error y se devolverá un valor nulo cuando llamando. Un contrato de entrega basado en USDT. USD.swap. Rango de cambio perpetuo basado en moneda Los contratos. USD.futures Rango de entrega basado en moneda Los contratos. Un contrato de opciones basado en USDT. Un contrato de opciones basado en divisas. Conjunto USDT.futures_combo. Rango de combinaciones de CFD. Futures_Deribit Intercambio Un rango de contratos de entrega de margen mixto. Futures_Kraken Intercambio Un conjunto de contratos perpetuos de margen mixto. El futuro es el intercambio Kraken
Cuando la cuenta representada por el objeto de intercambioexchangeno tiene órdenes pendientes dentro de larango de búsquedao bieninstrumentos de negociación específicos(órdenes activas en un estado no cumplido), llamando a esta función devuelve una matriz vacía, es decir:[]¿ Qué pasa?
Los siguientes intercambios requieren que el instrumento pase en el parámetro del instrumento al consultar las órdenes actualmente incompletas. Cuando se llama a la función GetOrders con estos intercambios, si no se pasa el parámetro del instrumento, solo se solicitan las órdenes incompletas del instrumento actual, no las órdenes incompletas de todos los instrumentos (porque la interfaz de intercambio no admite esto).
Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE. Es el único que tiene el nombre de la compañía.
Los intercambios que no apoyan laexchange.GetOrders()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener órdenes | – | El valor de la inversión se calcula a partir del valor de la inversión |
Los datos de las operaciones de compra y venta de los productos de los Estados miembros que se encuentran en el ámbito de aplicación de la presente Directiva son los siguientes: {@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}
Elexchange.GetHistoryOrders()Esta función se utiliza para obtener el par de operaciones actual, las órdenes históricas de los contratos; admite la especificación de variedades de operaciones específicas.
Elexchange.GetHistoryOrders()La función devuelve una matriz de estructuras {@struct/Order Order} si la solicitud de datos tiene éxito, y nula si la solicitud falla.
Las matrices de {@struct/Order Order}, valores nulos
intercambio.GetHistoryOrders (() intercambio.GetHistoryOrders (símbolo) intercambio.GetHistoryOrders (símbolo, desde) intercambio.GetHistoryOrders (símbolo, desde, límite) intercambio.GetHistoryOrders (Desde entonces) intercambio.GetHistoryOrders (desde el límite)
ElsymbolEn el caso de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valoresBTC_USDTEn la actualidad, el mercado de la moneda única se ha convertido en un mercado de valores.exchangees un objeto de intercambio al contado, el formato de parámetro parasymbolesBTC_USDTEn el caso de un objeto de intercambio de futuros, tomando como ejemplo el contrato perpetuo, el formato de parámetro parasymboles:BTC_USDT.swap¿ Qué pasa?
Si usted está consultando los datos de orden de los contratos de opción, establecer el parámetrosymbolEn el"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo).Pares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el carácter
el símbolo
falsos
la cuerda
ElsinceParámetro utilizado para especificar la marca de tiempo de inicio de la consulta en milisegundos.
Desde entonces
falsos
Número
EllimitEl parámetro se utiliza para especificar el número de órdenes a consultar.
el límite
falsos
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, limitSi no se especifican los parámetros, la consulta predeterminada es el par de operaciones actual, las órdenes históricas del contrato.symbolSi se especifica el parámetro, consultar el historial de órdenes para el tipo de operación establecido.sinceParámetro se especifica, consulta en la dirección de la hora actual utilizando elsinceel sello de tiempo como la hora de inicio.limitCuando se especifica un parámetro, la consulta se devuelve después de un número suficiente de entradas.Los intercambios que no apoyan laexchange.GetHistoryOrders()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener órdenes de historial | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | Los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores |
Los datos de las operaciones de compra y de venta de los productos de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros.
exchange.SetPrecision()Función utilizada para establecer la precisión delexchangeobjeto de intercambioprecioyimporte de la orden, después de la configuración, el sistema ignorará el exceso de datos automáticamente.
cambio.ConfiguraciónPrecisión ((precioPrecisión, cantidadPrecisión)
ElpricePrecisionEl parámetro se utiliza para controlar la precisión de los datos de precios.
Precio Precisión
verdadero
Número
ElamountPrecisionEl parámetro se utiliza para controlar la precisión de la cantidad de datos a ordenar.
cantidadPrecisión
verdadero
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);
}
El sistema de backtesting no admite esta función, y la precisión numérica del sistema de backtesting se maneja automáticamente.
En el caso de las empresas de servicios de la Unión Europea, el número de empresas de servicios de servicios de la Unión Europea es el siguiente:
Establecer el tipo de cambio actual del objeto de intercambio.
cambio.Tasa establecida (Tasa)
Elrateel parámetro se utiliza para especificar el tipo de cambio de conversión.
el tipo
verdadero
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);
}
Si se ha fijado un valor de tipo de cambio utilizando elexchange.SetRate()En este caso, la información de precios, como tickers, profundidades, precios de pedido, etc. para el intercambio representado por el actualexchangeel objeto de cambio se convertirá multiplicándolo por el tipo de cambio establecido de 7.exchangees un intercambio con el dólar estadounidense como moneda nominal.exchange.SetRate(7), todos los precios en el mercado en vivo se convertirán a precios cercanos a los precios de los precios de los precios en el mercado en vivo.En el caso de las empresas de servicios de telecomunicaciones:La denominación se multiplica por 7.
¿Por qué no lo haces?
Elexchange.IO()La función se utiliza para otras llamadas de interfaz relacionadas con el objeto de intercambio.
Elexchange.IO()La función llama a otras interfaces relacionadas con el objeto de intercambio, devolviendo los datos de respuesta solicitados en una llamada exitosa y devuelve nulo en una llamada fallida.
cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo soportado por el sistema
exchange.IO(k,...args)
ElkParámetro utilizado para establecer el tipo de llamada, con valores opcionales"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedy así sucesivamente.
el
verdadero
la cuerda
Parámetros ampliados, aprobados de acuerdo con el escenario de llamada específico,argLos parámetros pueden ser pasados a más de uno.exchange.IO()El número y el tipo de parámetros para elexchange.IO()Las funciones son indeterminadas.
el
verdadero
string, number, bool, object, array, null y cualquier otro tipo soportado por el 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 elexchange.IO("api", httpMethod, resource, params, raw)el formulario de convocatoria de laexchange.IO()En este caso, es necesario entender la interfaz API del intercambio y comprobar primero la documentación pertinente. Esto le permitirá ampliar la funcionalidad que no se agrega a la plataforma FMZ.POSTLa solicitud no requiere que se preocupe por cifrar, firmar o verificar los parámetros, que ya son manejados por FMZ en la parte inferior, siempre y cuando complete los parámetros correspondientes.Intercambio OKXlos contratos de futuros, y utilizar el parámetrorawpara pasar los parámetros de orden:
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// Note that both amount.toString() and price.toString() have a ' character on the left and right side
var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
var id = exchange.IO("api", "POST", "/v1/order/new", message)
}
amount = 1
price = 10
basecurrency = "ltc"
def main():
message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
id = exchange.IO("api", "POST", "/v1/order/new", message)
void main() {
auto amount = 1.0;
auto price = 10.0;
auto basecurrency = "ltc";
string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}
Si el valor clave en elparamsParámetro (es decir, parámetro de solicitud HTTP) es una cadena, que necesita ser escrito en comillas (es decir, el símbolo ') alrededor del valor del parámetro para envolver el valor del 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);
}
Apoya el paso de parámetros de url completos que pueden omitir la operación de cambiar la dirección base (llamando elexchange.SetBase()función).
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);
}
Ejemplo de llamada sin el 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());
}
Cambiar el par de negociación del intercambio actual, de modo que cambiará el par de negociación configurado por códigoen la creación de operaciones en vivoo bienen el 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 los intercambios con diferentes direcciones de base para la interfaz de ticker y la interfaz de negociación, por ejemplo, Bitfinex Futures tiene dos direcciones, una para la interfaz de ticker y la otra para la interfaz de negociación.exchange.SetBase("xxx")Los futuros de Bitfinex cambian la dirección de base de la interfaz pública usandoexchange.IO("mbase", "xxx").
I. Para los intercambios centrados en las criptomonedas, otras llamadas de interfaz de API que no estén encapsuladas de manera uniforme, con parámetrokSe establece en"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, etc.URL.Elexchange.IO("api", httpMethod, resource, params, raw)La llamada de la función accederá a la interfaz de intercambio y devolverá null si la llamada falla y se produce un error.
Sólo el comercio real apoya la llamadaexchange.IO("api", httpMethod, resource, params, raw) function.
II. Para el cambio de pares de operaciones, el parámetrokestá configurado para:"currency":
exchange.IO("currency", currency)
moneda: El parámetro es un tipo de cadena con un formato de mayúscula uniforme, utilizando un trazo para separarbaseCurrencydesdequoteCurrency, como por ejemploBTC_USDT.
ETH_BTCsólo puede cambiar aLTC_BTC, no paraLTC_USDT.exchange.IO("currency", currency)para cambiar de par de operaciones.III. Se utiliza para cambiar el modo de cuenta apalancada del objeto de intercambio spot de criptomonedas:
kestá configurado para:"trade_margin"Para realizar órdenes y obtener activos de la cuenta, se accederá a la interfaz de apalancamiento al contado de la bolsa.
Si la bolsa distingue entre el margen total y el margen aislado en el apalancamiento al contado, utilizar:exchange.IO("trade_super_margin")cambiar al margen completo para la cuenta apalancada, yexchange.IO("trade_margin")el cambio a margen aislado para la cuenta apalancada.kestá configurado para:"trade_normal"para volver al modo normal de cuenta al contado.Bolsas al contado que admiten el cambio entre modelos de cuentas apalancadas:
| Los intercambios | Observaciones especiales |
|---|---|
| No hay problema. | Los pares de operaciones en el modo de cuenta apalancada son diferentes de los normales, algunos pares de operaciones pueden no tenerlos.exchange.IO("trade_super_margin")cambiar a posición completa para las cuentas apalancadas y utilizarexchange.IO("trade_margin")para cambiar a posición por posición.trade_normalpara cambiar al modo spot normal.exchange.IO("tdMode", "cross")para especificar directamente el modo de apalancamiento. |
| - ¿ Qué? | Los pares de operaciones de modo de cuenta apalancada son diferentes de los normales, algunos pares de operaciones pueden no tenerlos.trade_marginpara cambiar a la posición de la cuenta de apalancamiento por posición, utilizartrade_super_marginPara cambiar a la posición completa de la cuenta de apalancamiento.trade_normalpara cambiar al modo normal de divisas. |
| Binance | El modo de cuenta apalancada se divide en posición por posición y posición completa, usotrade_marginpara cambiar a posición por posición, utilizartrade_super_marginpara cambiar a posición completa, utilizartrade_normalpara cambiar al modo normal de divisas. |
| Puerta de entrada | El modo de cuenta apalancada se divide en posición por posición y posición completa, usotrade_marginpara cambiar a posición por posición, utilizartrade_super_marginpara cambiar a posición completa, utilizartrade_normalpara cambiar al modo normal de divisas. |
| AscendEx es el nombre de la aplicación. | Utilizaciónexchange.IO("trade_margin")cambiar al modo de cuenta de apalancamiento yexchange.IO("trade_normal")para volver al modo de cuenta normal. |
| ¿ Qué pasa? | Utilizaciónexchange.IO("trade_margin")cambiar al modo de cuenta de apalancamiento yexchange.IO("trade_normal")para volver al modo de cuenta normal. |
| CoinEx también | Utilizaciónexchange.IO("trade_margin")cambiar al modo de cuenta apalancada yexchange.IO("trade_normal")para volver al modo de cuenta normal. |
Otras funciones de conmutación:Mira elexchange.IO()Función paraOtras funciones de conmutaciónen la Guía del usuario.
En el caso de los sistemas operativos, el valor de los valores de los valores de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos.
Elexchange.Log()Cuando se llama, no se colocan órdenes, solo se sacan y registran los registros de transacciones.
cambio.Log ((ordenTipo, precio, importe) cambio.Log ((ordenTipo, precio, importe,...argumentos)
ElorderTypeSe utiliza el parámetro para establecer el tipo de registro de salida, los valores opcionales son {@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}.
ordenTipo
verdadero
Número
ElpriceEl parámetro se utiliza para establecer el precio que se muestra en el registro de salida.
precio
verdadero
Número
ElamountEl parámetro se utiliza para establecer la cantidad de pedidos realizados que se muestran en el registro de salida.
cantidad
verdadero
Número
Parámetros ampliados que pueden producir información de acompañamiento a este registro,argLos parámetros pueden ser pasados más de uno.
el
falsos
cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}
Utilizandoexchange.Log(orderType, price, amount)Uno de los escenarios más comunes es el uso de {@fun/Trade/exchange.IOexchange.IO} para acceder a la interfaz de intercambio para crear órdenes condicionales, pero utilizando elexchange.IO()la función no produce la información del registro de transacciones en el registro de operaciones en vivo.exchange.Log()La función puede utilizarse para complementar el registro de salida con el fin de registrar la información sobre la colocación de pedidos, y lo mismo ocurre con las operaciones de retirada de pedidos.
Cuando elorderTypeel parámetro esLOG_TYPE_CANCEL, elpriceParámetro es el orden Id de la orden retirada, que se utiliza para imprimir el registro de retirada cuando la orden se retira directamente utilizando elexchange.IO()La funciónexchange.Log()La función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}, a diferencia de la función global {@fun/Log Log}.
Los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos.
Elexchange.Encode()La función se utiliza para los cálculos de cifrado de firmas.
Elexchange.Encode()La función devuelve el valor de codificación de hash calculado.
la cuerda
exchange.Encode ((algo, inputFormat, outputFormat, datos) exchange.Encode ((algo, inputFormat, outputFormat, datos, claveFormat, clave)
El parámetroalgoes el algoritmo utilizado para el cálculo de codificación. Los ajustes compatibles son: algoTambién admite: algotambién admite: algopuede escribirse como ed25519.seedel cálculo.
algo
verdadero
la cuerda
Se utiliza para especificar el formato de datos deldatael parámetro.inputFormathexcodificado, base64codificado, y outputFormatParámetro admite los siguientes ajustes: hexcodificado, base64codificado, y dataes los datos a tratar.
datos
verdadero
la cuerda
Se utiliza para especificar el formato de datos delkeyel parámetro.keyhexcodificado, base64codificado, y keyParámetro se utiliza para especificar la clave utilizada en el cálculo de la firma, y se puede utilizar como una cadena de texto plano."{{accesskey}}", "{{secretkey}}"para referirse a laaccessKeyysecretKeyconfigurado en el objeto de intercambio {@var/EXCHANGE exchange}.
llave
falsos
la cuerda
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"];
}
}
}
Ejemplo de empuje de cambio de posición de BitMEX (protocolo wss):
Sólo el comercio real apoya la llamadaexchange.Encode()La función"{{accesskey}}", "{{secretkey}}"Las referencias sólo son válidas cuando elexchange.Encode()La función se utiliza.
¿Qué es lo que está pasando?
Las funciones de soporte asíncrono de múltiples hilos pueden convertir las operaciones de todas las funciones soportadas en una ejecución simultánea asíncrona.
Elexchange.Go()función devuelve un objeto concurrente inmediatamente, y se puede utilizar elwait()método de ese objeto concurrente para obtener el resultado de la solicitud concurrente.
objeto
el método de intercambio. el intercambio.Método Go,...args
ElmethodParámetro se utiliza para especificar el nombre de la función concurrente. Tenga en cuenta que el parámetro es una cadena de nombres de función, no una referencia de función.
Método
verdadero
la cuerda
Parámetros paraEjecutar funciones simultáneamente, puede haber más de un parámetroargTipo y número de parámetrosargdependerá de los parámetros de laFunción de ejecución simultánea¿ Qué pasa?
el
falsos
cadena, número, bool, objeto, matriz, función, nulo y todos los demás tipos compatibles con el 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()ejemplo de uso de la función, para determinarundefinedpara usartypeof(xx) === "undefined", porquenull == undefinedes válido en JavaScript.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
var ret = d.wait()
}
def main():
d = exchange.Go("GetRecords", PERIOD_H1)
records, ok = d.wait()
ret, ok = d.wait()
void main() {
auto d = exchange.Go("GetRecords", PERIOD_H1);
Records records;
d.wait(records);
Records ret;
d.wait(ret);
}
Llamando alwait()El método en un objeto concurrente que ha sido liberado reportará un error:
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);
}
}
Acceso simultáneo a varios tickers de cambio:
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");
}
Convocatorias simultáneas paraexchange.IO("api", ...)Función:
Esta función solo crea tareas de ejecución de múltiples hilos cuando se ejecutan en el comercio real, la prueba posterior no admite la ejecución simultánea de tareas de múltiples hilos (la prueba posterior está disponible, pero aún se ejecuta secuencialmente).
Después de laexchange.Go()función devuelve un objeto, suwait()La función se llama a través de ese objeto para obtener los datos devueltos por el hilo.wait()La función debe ser llamada para obtener los datos antes de que el hilo será liberado automáticamente.wait()El resultado del hilo debe ser obtenido antes de que sea liberado automáticamente (independientemente del éxito o fracaso de la llamada de la interfaz para el acceso concurrente).wait()función independientemente de si la ejecución tiene éxito o no, y el recurso del hilo solicitado por elexchange.Go()La función debe ser liberada automáticamente por el docker.
Elwait()El método admite un parámetro de tiempo de espera:
Sin un parámetro de tiempo de espera, es decir,wait(), o con un parámetro de tiempo de espera de 0, es decir,wait(0)El.wait()Bloques de función y espera hasta que el hilo concurrente haya terminado de ejecutarse, devolviendo el resultado de la ejecución del hilo concurrente.
Establecer el parámetro de tiempo de espera -1, es decirwait(-1)El.wait()función devuelve inmediatamente, con diferentes valores de retorno para diferentes lenguajes de programación, ver esta subsección para un ejemplo de llamada.
Establezca el parámetro de tiempo de espera específico,wait(300), y elwait()La función esperará un máximo de 300 milisegundos antes de regresar.
Si el resultado de vuelta de la finalwait()Si no se obtiene la función, los recursos de hilo no se liberarán automáticamente, lo que dará lugar a la acumulación de hilos solicitados, y más de 2000 reportará un error:"too many routine wait, max is 2000"- ¿ Por qué?
Funciones soportadas:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Todas estas funciones se ejecutan basándose en el objeto de intercambio actual {@var/EXCHANGE exchange} cuando se llama simultáneamente.
La diferencia entre el lenguaje Python y el lenguaje JavaScript es quewait()La función de objetos concurrentes en Python devuelve dos parámetros. El primer parámetro es el resultado devuelto por una llamada de API asíncrona, y el segundo parámetro indica si la llamada asíncrona se ha completado.
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)
¿Qué es lo que está pasando? ¿Qué está pasando?
Elexchange.GetAccount()La función se utiliza para solicitar información de la cuenta de cambio.GetAccount()La función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}.exchangeobjeto sólo está relacionado conexchange, y no se repetirá después de la documentación.
Consultar la información del activo de la cuenta y devolver la estructura {@struct/Account Account} si la consulta tiene éxito o nula si falla. {@struct/Cuenta Cuenta}, valor nulo
El cambio.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"])
}
Configurar pares de negociación, códigos de contrato, y obtener información de la cuenta corriente.
Si el objeto de intercambio está configurado para un intercambio de contratos de futuros de criptomonedas, y cambiado a un contrato conUSDTcomo margen (ver {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType} funciones para cómo cambiar).USDTEn el caso de las empresas de servicios de seguros, el margen se registra en elBalance, FrozenBalancelos atributos de la estructura {@struct/Account Account}.
Si el objeto de intercambio se establece en un intercambio de contratos de futuros de criptomonedas y se cambia a un contrato basado en moneda, el activo está en moneda como margen y se registra en elStocks, FrozenStockslos atributos de la estructura {@struct/Account Account}.
Al utilizar la cuenta unificada de Binance Futures, al llamar a laexchange.GetAccount()La función de solicitud de información de la cuenta, los datos encapsulados es el importe de todos los activos convertidos enUSDSe muestra en elBalanceSi necesita calcular el importe de conversión de otros activos, puede utilizar el importe de conversión en USD dividido por el precio del índice (del activo a convertir) y luego dividido por la tasa de compromiso (del activo a convertir) para calcularlo.
El valor de las operaciones de cambio de divisas se calculará en función de las operaciones de cambio de divisas.
Elexchange.GetAssetsLa función se utiliza para solicitar información sobre activos de la cuenta de cambio.
Elexchange.GetAssets()función devuelve una matriz de {@struct/Asset Asset} estructuras si la solicitud de datos tiene éxito, o nulo si la solicitud falla.
Se trata de un conjunto de datos que contiene los datos de la base de datos.
El cambio.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);
}
Obtener información sobre los activos de una cuenta de intercambio,exchange.GetAssets()devuelve una matriz con elementos de la estructura de activos.
ElGetAssets()la función del objeto de cambio de futuros devuelve los activos de margen del par de operaciones actual (basados en moneda, USDT, USDC, etc.).
Los datos de las operaciones de la entidad se incluirán en la lista de los activos de la entidad.
Elexchange.GetName()La función se utiliza para obtener el nombre del intercambio al que está vinculado el objeto de intercambio actual.
Elexchange.GetName()La función devuelve el nombre de la bolsa definida por la plataforma de comercio de FMZ Quant.
la cuerda
¿ Qué está pasando?
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");
}
Elexchange.GetName()La función se utiliza generalmente para identificar los objetos de intercambio, tales comoexchangeo bienexchanges[1], exchanges[2]Los nombres de los intercambios de contratos de futuros de criptomonedas tienen el prefijo fijoFutures_.
¿Por qué no lo haces?
Elexchange.GetLabel()La función se utiliza para obtener la etiqueta personalizada que se estableció cuando se configuró el objeto de intercambio.
Elexchange.GetLabel()función devuelve la etiqueta personalizada que se estableció cuando se configuró el objeto de intercambio.
la cuerda
¿ Qué es esto?
function main() {
Log("exchange label:", exchange.GetLabel())
}
def main():
Log("exchange label:", exchange.GetLabel())
void main() {
Log("exchange label:", exchange.GetLabel());
}
Objetos de intercambio tales comoexchangeo bienexchanges[1], exchanges[2]en el código de estrategia se identifican mediante la etiqueta de conjunto.
¿Qué es lo que está pasando?
Elexchange.GetCurrency()La función se utiliza para obtener el par de negociación actualmente establecido.
Elexchange.GetCurrency()La función devuelve el par de operaciones establecido por el objeto de intercambio actual {@var/EXCHANGE exchange}.
la cuerda
En cambio.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());
}
El formato del par de operaciones es mayúscula de forma uniforme, utilizando líneas subrayadas para separarbaseCurrencyyquoteCurrency, como por ejemploBTC_USDT.
{@fun/Cuenta/intercambio.SetCurrency cambio.SetCurrency}
Elexchange.SetCurrency()La función se utiliza para cambiar el par de operaciones actual del objeto de intercambio {@var/EXCHANGE exchange}.
cambio.Configuración de la moneda
ElcurrencyEl formato del par de operaciones es mayúscula uniformemente, utilizando un punto de referencia para separarbaseCurrencydesdequoteCurrency, como por ejemploBTC_USDT- ¿ Por qué?
moneda
verdadero
la cuerda
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 cambio, por favor consulte {@funexcahnge.IO}.BTC_USDTpuede ser cambiado aLTC_USDT, no paraLTC_BTC.BTC_USDT, el número deBTCes 3, el número deUSDTEn este momento, cambia aLTC_USDTEn el caso de las monedas de cambio, el número de monedas de negociación es 0 inmediatamente después del cambio, es decir, el número deLTC_USDTen la cuenta es 0, es decir, el número deLTCen la cuenta es 0, y el par de operaciones cambiado comparte el número deUSDT, que es 10 000.¿Por qué no lo haces?
Elexchange.GetQuoteCurrency()la función se utiliza para obtener el nombre de la moneda denominada del par de operaciones actual, es decir,quoteCurrency.
Elexchange.GetQuoteCurrency()la función devuelve el nombre de la moneda denominada del par de operaciones actual.
la cuerda
En cambio.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 ejemplo: {@var/EXCHANGE exchange} el par de transacciones actual del objeto de intercambio esBTC_USDT, elexchange.GetQuoteCurrency()La función devuelveUSDT. Si el par de operaciones actual esETH_BTC, elexchange.GetQuoteCurrency()La función devuelveBTC.
En el caso de las operaciones de cambio de divisas, las operaciones de cambio de divisas deben realizarse en el momento en que se establezcan las condiciones de cambio de divisas.
Elexchange.GetPositions()La función se utiliza para obtener la información de posición;GetPositions()La función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}.GetPositions()La función obtiene la información de posición de la cuenta de intercambio vinculada al objeto de intercambioexchangeEl objetivo de las funciones (métodos) de los miembros de laexchangeobjeto sólo está relacionado conexchangey no se repetirá aquí.
Elexchange.GetPositions()La función devuelve una matriz de estructuras {@struct/Position Position} si la solicitud de datos tiene éxito, y devuelve un valor nulo si la solicitud de datos falla.
Las matrices de {@struct/Position Position}, valores nulos
El cambio.GetPositions ((() intercambio.GetPositions (símbolo)
El parámetrosymbolse utiliza para establecer elsímbolo comercialo bienrango de símbolos de negociaciónpara ser interrogado.
Si elsymbolSi el parámetro no se pasa, por defecto se solicitan los datos de posición de todos los símbolos en el rango de dimensiones del par de negociación actual y el código del contrato.
el símbolo falsos la cuerda
/*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;
}
Utilizar objetos de intercambio de futuros para colocar órdenes de mercado para múltiples pares comerciales diferentes y códigos de contrato.
Los contratos de futuros de criptomonedas son diferentes de los contratos spot de criptomonedas, que solo tienen el concepto lógico de una posición.Pares de negociación, código del contratoPor favor, consulte las funciones {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}.
En elGetPositionsFunción, los escenarios de uso del parámetro símbolo se resumen de la siguiente manera:
| Clasificación de objetos de intercambio | símbolo Parámetros | Alcance de la consulta | No obstante, |
|---|---|---|---|
| Los futuros | No pase el parámetro de símbolo | Consultar todos los productos de negociación dentro del rango de dimensiones del par de negociación actual y del código del contrato | Si el par de negociación actual es BTC_USDT y el código del contrato es swap, todos los contratos perpetuos basados en USDT serán consultados.GetPositions("USDT.swap") |
| Los futuros | Especifique el producto de negociación, el parámetro del símbolo es: |
Consultar el contrato perpetuo basado en USDT de un BTC especificado | Para los objetos de cambio de futuros, el formato del símbolo del parámetro es:Pares de negociaciónycódigo del contratodefinidas por la plataforma FMZ, separadas por los caracteres".. |
| Los futuros | Especifique el rango de productos de negociación, el parámetro del símbolo es: |
Consultar todos los contratos perpetuos basados en USDT | - |
| Bolsas de futuros que admiten opciones | No pase el parámetro de símbolo | Consultar todos los contratos de opción dentro del rango de dimensiones del par de operaciones actual | Si el par de operaciones actual es BTC_USDT, el contrato se establece en un contrato de opción, por ejemplo, contrato de opción de Binance: BTC-240108-40000-C |
| Bolsas de futuros que admiten opciones | Especificar el producto comercial específico | Consultar el contrato de opción especificado | Por ejemplo, para Binance Futures Exchange, el parámetro del símbolo es: BTC_USDT.BTC-240108-40000-C |
| Bolsas de futuros que admiten opciones | Especifique la gama de productos de negociación, el parámetro del símbolo es: |
Consultar todos los contratos de opciones basados en USDT | - |
En elGetPositionsfunción, el objeto del intercambio de futuros
el rango de dimensiones de la consulta se resume de la siguiente manera:
| símbolo Parámetros | Definición del ámbito de aplicación de la solicitud | No obstante, |
|---|---|---|
| USDT.swap | Los tipos de interés de las entidades de crédito incluidas en el anexo I se determinarán de acuerdo con el método de cálculo de la rentabilidad. | Para |
dimensiones que no sean compatibles con la interfaz de API de intercambio, se informará de un error y se devolverá un valor nulo cuando llamando.
Un contrato de entrega basado en USDT.
USD.swap. El alcance de la moneda basada en el cambio perpetuo Los contratos.
USD.futures. Espejo de entrega basada en moneda Los contratos.
Un contrato de opciones basado en USDT.
La opción USD. Opciones basadas en divisas.
Conjunto USDT.futures_combo. Rango de combinaciones de CFD. Futures_Deribit Intercambio
USD.futures_ff. alcance de los contratos de entrega de margen mixto. Futures_Kraken Intercambio
USD.swap_pf Rango de contrato perpetuo de margen mixto. Futures_Kraken Intercambio
Compatible conexchange.GetPosition()llamada,GetPositiones exactamente lo mismo queGetPositions.
Cuando la cuenta representada por el objeto de intercambioexchangeno tiene posiciones en elrango de búsquedao bieninstrumentos de negociación específicos, elexchange.GetPositions()función devuelve una matriz vacía, por ejemplo:[].
El valor de las operaciones de cambio de divisas se calculará en función de las posiciones de cambio de divisas de la entidad.
Elexchange.SetMarginLevel()la función se utiliza para establecer el valor de apalancamiento del par de operaciones o contrato especificado por elsymbolParámetro Compatible con sólo pasar en el parámetromarginLevelpara establecer el valor de apalancamiento del par de operaciones o contrato actual del objeto de intercambio {@var/EXCHANGE exchange}.
En el caso de las operaciones de intercambio, el valor de las operaciones de intercambio es el valor de las operaciones de intercambio.SetMarginLevel ((símbolo, MarginLevel) En el caso de las operaciones de intercambio, el nivel de margen se establece en el siguiente orden:
ElsymbolEl parámetro se utiliza para especificar el par o contrato de negociación para el que debe ajustarse el valor del apalancamiento.symbolParámetro delSetMarginLevel()La función es coherente con el formato de lasymbolParámetro delGetTicker()la función.
el símbolo
falsos
la cuerda
ElmarginLevelEl parámetro se utiliza para establecer el valor de apalancamiento, que generalmente es un número entero para los intercambios y también admite la configuración del valor de apalancamiento de punto flotante para algunos intercambios.
Margen y nivel
verdadero
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);
}
Elexchange.SetMarginLevel()El sistema de backtesting admite llamar a los objetos de intercambio de contratos de futuros de criptomonedas solamente.exchange.SetMarginLevel()función para establecer el valor de apalancamiento.
Para los contratos de futuros de criptomonedas, el mecanismo de apalancamiento no es uniforme debido a los intercambios de contratos de futuros de criptomonedas.exchange.SetMarginLevel()La función no genera una solicitud de red, sino que solo establece la variable de apalancamiento en el sistema FMZ subyacente (utilizado para transmitir parámetros en la interfaz de colocación de órdenes). El valor de apalancamiento de algunos contratos de futuros de intercambio es un ajuste del intercambio, que debe establecerse en la página del sitio web del intercambio o utilizando la interfaz API.exchange.SetMarginLevel()Puede haber muchas razones para esto, por ejemplo: hay una posición actual o una orden pendiente, lo que hace imposible establecer un nuevo valor de apalancamiento para este par o contrato de negociación.
Los intercambios que no apoyan elexchange.SetMarginLevel()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Establecer el nivel de margen | – | Los valores de los instrumentos de inversión de los Estados miembros que no cumplen los requisitos de la letra a) del presente artículo serán considerados como derivados de los instrumentos de inversión de los Estados miembros. |
¿Qué es lo que está pasando?
Elexchange.SetDirection()La función se utiliza para establecer la dirección de la orden de la función {@fun/Trade/exchange.Buy exchange.Buy}, la función {@fun/Trade/exchange.Sell exchange.Sell} cuando se realizan órdenes para contratos de futuros.
cambio.Configurar Dirección (dirección)
Eldirectionel parámetro se utiliza para establecer la dirección del contrato de futuros cuando se realiza la orden."buy", "closesell", "sell", "closebuy"- ¿ Por qué?
dirección
verdadero
la cuerda
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);
}
Elexchange.SetDirection()la función establece la correspondencia entre la dirección de la operación del contrato de futuros y la función de colocación de órdenes:
| Funciones de colocación de pedidos | La dirección establecida por los parámetros de la función SetDirection | Las observaciones |
|---|---|---|
| exchange.Buy | Comprar y abrir posiciones largas | |
| exchange.Buy | Comprar y cerrar posiciones cortas | |
| exchange.Sell | Vender y abrir posiciones cortas | |
| exchange.Sell | Vender y cerrar posiciones largas |
En el caso de las empresas de servicios de la Unión Europea, el número de empresas de servicios de servicios de la Unión Europea es el siguiente:
Elexchange.SetContractType()La función se utiliza para establecer el código del contrato actual del objeto de intercambio {@var/EXCHANGE exchange}.
Elexchange.SetContractType()La función devuelve una estructura que contiene el código del contrato de intercambio correspondiente al código del contrato actual.quarter, y la estructura de valor de retorno de esta función es:{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}- ¿ Por qué?
Objeto
el símbolo de intercambio.SetContractType
Elsymbolel parámetro se utiliza para establecer el código del contrato, los valores opcionales son:"this_week", "next_week", "quarter", "next_quarter", "swap", etc.
Contratos futuros de criptomonedascontrato de entregalos códigos, si no se especifican, generalmente tienen:
this_week: el contrato de la semana en curso.next_weekEl contrato de la próxima semana.quarter: contrato trimestral.next_quarter: el siguiente contrato trimestral.Contratos permanenteslos códigos en los contratos de futuros de criptomonedas, si no se especifican, generalmente tienen:swapContrato perpetuo.el símbolo verdadero la cuerda
function main() {
// Set to this week contract
exchange.SetContractType("this_week")
}
def main():
exchange.SetContractType("this_week")
void main() {
exchange.SetContractType("this_week");
}
Establezca el contrato actual como el contrato de la semana actual:
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());
}
Cuando se establece un contrato conUSDTcomo margen, debe cambiar el par de operaciones en el código (también puede establecer el par de operaciones directamente al agregar el objeto de intercambio):
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 el valor de retorno delexchange.SetContractType()Función:
En la estrategia del contrato de futuros de criptomonedas, tome un ejemplo de cambiar a laBTC_USDTPares de negociación: Cuando se cambian de pares de negociación utilizando elexchange.SetCurrency("BTC_USDT")o bienexchange.IO("currency", "BTC_USDT")Funciones, después de cambiar, usted necesita utilizar elexchange.SetContractType()La función de restablecimiento del contrato para determinar el contrato actual que se operará con el nuevo par de operaciones.contrato estándar de divisaso unaContrato estándar en USDTPor ejemplo, si un par de operaciones está configurado paraBTC_USDT, utilizar elexchange.SetContractType("swap")función para establecer el código del contrato aswapEn este punto, está configurado paraBTCpara elEl estándar USDTSi el par de negociación esBTC_USD, utilizar elexchange.SetContractType("swap")función para establecer el código del contrato aswapEn este punto, está configurado paraBTC¿ Qué?norma de divisascontrato perpetuo.
Detalles de los intercambios de contratos de futuros de criptomonedas compatibles, con los nombres de los contratos de cada intercambio como sigue:
Los futuros_OKCoin (OKX)
Se establece en contratos perpetuos:exchange.SetContractType("swap")En el contrato de esta semana:exchange.SetContractType("this_week")Con el contrato de la próxima semana:exchange.SetContractType("next_week")Contrato mensual:exchange.SetContractType("month")Contrato para el próximo mes:exchange.SetContractType("next_month")Con arreglo a los contratos trimestrales:exchange.SetContractType("quarter")Contrato para el próximo trimestre:exchange.SetContractType("next_quarter")
OKX tiene contratos de negociación previos al mercado: la fecha de entrega del contrato es una hora fija.HMSTR-USDT-250207Establezca el par de operaciones enHMSTR_USDTen la plataforma FMZ, y luego utilizarexchange.SetContractType("HMSTR-USDT-250207")para establecer el contrato.
Para las funciones que soportan elsymbolParámetro, por ejemplo:exchange.GetTicker(), exchange.CreateOrder(), etc. Se puede especificar elsymbolParámetro como:HMSTR_USDT.HMSTR-USDT-250207para obtener los datos de mercado del presente contrato o realizar un pedido.
Los futuros de las entidades de crédito se clasifican en el modelo de referencia.
En el contrato de esta semana:exchange.SetContractType("this_week")- ¿ Por qué?
Con el contrato de la próxima semana:exchange.SetContractType("next_week")- ¿ Por qué?
Con arreglo a los contratos trimestrales:exchange.SetContractType("quarter")¿ Qué pasa?
Contrato para el próximo trimestre:exchange.SetContractType("next_quarter")- ¿ Por qué?
Se establece en contratos perpetuos:exchange.SetContractType("swap")- ¿ Por qué?
Apoya los contratos conUSDTcomo margen, tomarBTCContrato como ejemplo: usoexchange.IO("currency", "BTC_USDT")para cambiar a un contrato que utilizaUSDTcomo margen.
O ajustar el par de operaciones actual aBTC_USDTDespués de cambiar los pares de negociación, usted necesita llamarexchange.SetContractType()La función de nuevo para establecer el contrato.
Los valores de los derivados de las operaciones de inversión de los bancos centrales de los Estados miembros se calcularán en función de los tipos de interés.
Se establece en contratos perpetuos:exchange.SetContractType("swap")¿ Qué pasa?
Los contratos de entrega de futuros de BitMEX son contratos mensuales con los siguientes códigos de contrato (de enero a diciembre):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Establecimiento de contratos de entrega:exchange.SetContractType("December")Por ejemplo, cuando el par de operaciones está configurado paraXBT_USDT, elexchange.SetContractType("December")La función se llama para establecer el contrato para la entrega de diciembre en USDT basado en BTC (correspondiente al código del contrato real deXBTUSDTZ23).
Resumen de la información sobre el contrato de futuros_BitMEX
| Código del contrato definido por Futures_BitMEX | El par de operaciones correspondiente en FMZ | El código del contrato correspondiente en FMZ | No obstante, |
|---|---|---|---|
| El DOGEUSD | El valor de las acciones de la entidad | cambio | denominado en USD, XBT se liquida. XBT es BTC. |
| En el caso de las personas que no sean miembros de la familia | No se puede utilizar. | cambio | denominado en USDT, liquidado en USDT. |
| XBTETH | Se trata de un sistema de transferencia de datos. | cambio | ETH denominado, XBT resuelto. |
| XBTEUR | El valor de las transferencias | cambio | denominados en euros y liquidados en XBT. |
| USDTUSDC | USDT_USDC | cambio | denominado en USDC, liquidado en XBT. |
| ETHUSD_ETH | En el caso de las entidades financieras, el importe de las pérdidas se calculará de acuerdo con el método de cálculo de las pérdidas. | cambio | denominado en USD y liquidado en ETH. |
| Se trata de la XBTH24 | El valor de la transacción será el valor de la transacción | Marzo | Fecha de vencimiento: 24 de marzo, código del mes es: H; denominado en USD, liquidado en XBT. |
| El valor de las pérdidas | ETH_USD | Diciembre | Fecha de vencimiento: 23 de diciembre, código del mes es: Z; denominado en USD, liquidado en XBT. |
| XBTUSDTZ23 | El valor de las transferencias | Diciembre | Fecha de vencimiento: 23 de diciembre. El código del mes es: Z ; denominado en USDT, liquidado en USDT. |
| ADAZ23 | ADA_XBT | Diciembre | Fecha de vencimiento: 23 de diciembre, el código del mes es: Z ; facturación en XBT, liquidación en XBT. |
| P_XBTETFX23 | USDT_XXX | P_XBTETFX23 | Expiración: 23/11/23; denominado en porcentaje y liquidado en USDT. |
Los futuros_GateIO
En el contrato de esta semana:exchange.SetContractType("this_week")- ¿ Por qué?
Con el contrato de la próxima semana:exchange.SetContractType("next_week")- ¿ Por qué?
Con arreglo a los contratos trimestrales:exchange.SetContractType("quarter")¿ Qué pasa?
Contrato para el próximo trimestre:exchange.SetContractType("next_quarter")- ¿ Por qué?
Se establece en contratos perpetuos:exchange.SetContractType("swap")- ¿ Por qué?
Apoya los contratos conUSDTcomo margen, tomarBTCContrato como ejemplo: usoexchange.IO("currency", "BTC_USDT")para cambiar a un contrato que utilizaUSDTcomo margen.
O ajustar el par de operaciones actual aBTC_USDTDespués de cambiar los pares de negociación, usted necesita llamarexchange.SetContractType()La función de nuevo para establecer el contrato.
Los futuros_Deribit
Se establece en contratos perpetuos:exchange.SetContractType("swap")- ¿ Por qué?
Es compatible con DeribitUSDCel contrato.
Los contratos de entrega son los siguientes:"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"- ¿ Por qué?
En el caso de las entidades financieras, el valor de los derivados de las operaciones de inversión se calcula en función de los tipos de interés de los derivados."this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", hay muchas combinaciones.
Para los contratos de opción, debe introducir el código específico del contrato de opción definido por la bolsa, véase el sitio web de Deribit para obtener más detalles.
Los futuros_KuCoin
Por ejemplo, si el par de operaciones está configurado paraBTC_USDy el código del contrato está establecido, se trata de un contrato basado en moneda:
Establecido en contratos perpetuos:exchange.SetContractType("swap")- ¿ Por qué?
Con arreglo a los contratos trimestrales:exchange.SetContractType("quarter")¿ Qué pasa?
Contrato para el próximo trimestre:exchange.SetContractType("next_quarter").
USDT como contrato de margen:
Por ejemplo, si el par de operaciones está configurado paraBTC_USDT, y luego establecer el código del contrato, es un contrato con USDT como margen.
Establecido en contratos perpetuos:exchange.SetContractType("swap").
Los futuros de Binance
Binance Futures Exchange impone el contrato perpetuo del par de operaciones actual, código del contrato:swap- ¿ Por qué?
Se establece en contratos perpetuos:exchange.SetContractType("swap"), los contratos perpetuos de Binance tienen contratos que utilizanUSDTcomo margen.USDTcontrato perpetuo estándar deBTCel valor de la transacción se puede utilizar como un contrato de margen, y el par de operaciones está configurado paraBTC_USDTBinance también admite contratos perpetuos que usan monedas como margen, por ejemplo,BTCEs el contrato perpetuo estándar de Binance, con el par de operaciones configurado paraBTC_USD- ¿ Por qué?
Con arreglo a los contratos trimestrales:exchange.SetContractType("quarter"), el contrato de entrega tiene un contrato estándar en moneda (es decir, utilizando monedas como margen), por ejemplo,BTCEn el contrato trimestral, el par de operaciones está establecido para:BTC_USDy luego fijar el contratoexchange.SetContractType("quarter"), está configurado paraBTCcontrato trimestral con un contrato tipo de moneda.
Contrato para el próximo trimestre:exchange.SetContractType("next_quarter"), por ejemplo,BTCdel contrato trimestral tipo de divisas, el par de operaciones fijado a:BTC_USD, y luego fijar el contratoexchange.SetContractType("next_quarter")- ¿ Por qué?
Binance admite el uso parcialUSDTcomo contrato de entrega de margen, tomarBTCcomo ejemplo, establecer el par de negociación aBTC_USDT, luego establece el código del contrato.
Apoyo para los contratos de opciones de Binance:
El formato del código del contrato de opción se basa en el código del contrato de opción definido por la bolsa:BTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-PTome el código del contrato de opciones de Binance.BTC-241227-15000-PPor ejemplo: BTC es el código de moneda de la opción, 241227 es la fecha de ejercicio, 15000 es el precio de ejercicio, P representa una opción de venta y C una opción de compra.
Para obtener más detalles sobre el tipo de opción, ya sea una opción europea o una opción estadounidense, consulte la información pertinente del contrato de opción de la bolsa.
El intercambio puede restringir a los vendedores de opciones y requerir que soliciten calificaciones por separado.
El valor de la inversión se calcula a partir del valor de la inversión
Código del contrato para los contratos perpetuos de Bibox:swap- ¿ Por qué?
Se establece en contratos perpetuos:exchange.SetContractType("swap").
Las acciones de la entidad
El valor de las pérdidas de valor se calcula en función de las pérdidas de valor de las pérdidas de valor.swap- ¿ Por qué?
Código del contrato de esta semana:this_week- ¿ Por qué?
Código del contrato de la próxima semana:next_week- ¿ Por qué?
Código del contrato de la tercera semana:third_week- ¿ Por qué?
Código del contrato mensual:month- ¿ Por qué?
Código del contrato del próximo mes:next_month¿ Qué pasa?
Código del contrato trimestral:quarter¿ Qué pasa?
Código del contrato del próximo trimestre:next_quarter- ¿ Por qué?
Código del contrato del tercer trimestre:third_quarter.
Los futuros_Kraken
El valor de la opción de compra y venta es el valor de la opción de compra y venta de la opción de venta.swap.
swapContrato perpetuo.month: contrato del mes en curso.quarter: contrato trimestral.next_quarterEl próximo trimestre.swap_pf: Contrato perpetuo de margen mixto.quarter_ff: Contrato trimestral de margen mixto.month_ff: Contrato de margen mixto del mes en curso.next_quarter_ffContrato de margen mixto para el próximo trimestre.
Los futuros de Bitfinex
El valor de las pérdidas de valor de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés.swap.
Los futuros_Bitget
El valor de las pérdidas de valor de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés de las operaciones de tipo de interés.swap- ¿ Por qué?
El par de operaciones está configurado paraBTC_USDpara los contratos estándar de divisas, y el par de negociación está configurado paraBTC_USDTpara los contratos liquidados porUSDTLos contratos de demostración pueden establecerse con pares de operaciones comoSBTC_USD, BTC_SUSDT.
Los futuros_dYdX
Código del contrato para los contratos perpetuos dYdX:swap- ¿ Por qué?
Se establece en contratos perpetuos:exchange.SetContractType("swap"), dYdX sólo tiene contratos estándar en USDT.
Los futuros_MEXC
Código del contrato para los contratos perpetuos del MEXC:swap- ¿ Por qué?
Se establece en contratos perpetuos:exchange.SetContractType("swap"). Establecer el par de negociación aBTC_USD, que es un contrato estándar de divisas, y establecer el par de negociación paraBTC_USDT, que esUSDT- Contrato resuelto.
El valor de las acciones de la entidad
Fichas en una cuenta en elcrypto.comEl valor de los activos de cambio puede convertirse en créditos denominados en USD para utilizarlos como margen para la negociación de contratos.
Se ha establecido un contrato perpetuo:exchange.SetContractType("swap"). Ejemplo de llamar a laexchange.SetContractType("swap")función para establecer un contrato perpetuo para BTC cuando el par de operaciones está configurado paraBTC_USD- ¿ Por qué?
Elcrypto.comLos contratos de entrega de cambio son contratos mensuales con los siguientes códigos de contrato (de enero a diciembre):
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
Establecer el contrato de entrega:exchange.SetContractType("October")Por ejemplo, cuando el par de operaciones está configurado paraBTC_USD, llamar a la funciónexchange.SetContractType("October")para establecer el contrato de entrega de octubre para BTC.
El código del contrato correspondiente en el momento actual es:BTCUSD-231027.
Los futuros
Los instrumentos financieros de tipo de interés de las entidades de crédito incluidos en el modelo 060USDTLos contratos basados en un código de contrato perpetuo deswapPor ejemplo, cuando el par de operaciones está configurado paraBTC_USDT, la funciónexchange.SetContractType("swap")se llama a establecer el contrato actual para ser un contrato perpetuo basado en USDT para BTC.
El valor de las transacciones se calculará en función de la cantidad de transacciones que se realizan en el mercado.
Elexchange.GetContractType()La función se utiliza para obtener el código del contrato para la configuración actual del objeto de intercambio {@var/EXCHANGE exchange}.
Elexchange.GetContractType()La función devuelve el código del contrato definido por la plataforma FMZ, por ejemplo:this_week, swap, etc.
la cuerda
el tipo de contrato.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());
}
En el caso de las empresas de seguros, las empresas de seguros deben tener en cuenta los siguientes factores:
Elexchange.GetFundings()La función se utiliza para obtener los datos de las tasas de financiación del período en curso.
Elexchange.GetFundings()función devuelve un conjunto de estructuras {@struct/Funding Funding} cuando la solicitud de datos es exitosa, y devuelve un valor nulo cuando la solicitud de datos falla.
{@struct/Funding Funding} matriz, valor nulo
En cambio.GetFundings ((() intercambio.GetFundings (símbolo)
El parámetrosymbolse utiliza para establecer elsímbolo de la transaccióno bienrango de símbolos de transacciónEn el caso de lossymbolSi el parámetro no se pasa, se solicitarán por defecto los datos de la tasa de financiación actual de todos los instrumentos en el rango de dimensiones del par de negociación actual y el código del contrato.
el símbolo falsos la cuerda
/*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() + "`");
}
Utilice el objeto de intercambio de futuros para llamar a laexchange.GetFundings()Antes de llamar a cualquier función de mercado, GetFundings solo devuelve los datos de financiamiento del par de operaciones por defecto actual. Después de llamar a la función de mercado, devuelve los datos de financiamiento de todas las variedades solicitadas. Puede consultar el siguiente ejemplo de prueba:
Para los intercambios de futuros que no admiten la consulta por lotes de datos de tasas de financiación, si elsymbolel parámetro se especifica como el rango de consulta, por ejemplo:USDT.swapo elsymbolSi el parámetro no se pasa, la interfaz informará un error.GetFundings()función utilizando este tipo de objeto de intercambio de futuros, debe especificar elsymbolParámetro como tipo específico de contrato perpetuo para consultar los datos actuales de tasas de financiación del tipo.
Elexchange.GetFundings()La función soporta sistemas reales de trading y backtesting.
Intercambios que no admiten la adquisición por lotes de datos de tasas de financiación: Futures_Bitget, Futures_OKX, Futures_MEXC, Futures_Deribit, Futures_Crypto.symbolParámetro con el código de símbolo específico, por ejemplo:ETH_USDT.swap.
Los intercambios que no apoyan laexchange.GetFundings()Función:
| Nombre de la función | Intercambios al contado sin soporte | Exchanges de futuros no respaldados |
|---|---|---|
| Obtener fondos | – | Los futuros_DigiFinex |
¿Qué es lo que está pasando?
Elexchange.SetBase()La función se utiliza para establecer la dirección de base de la interfaz API de intercambio configurada en el objeto de intercambio {@var/EXCHANGE exchange}.
En el caso de los sistemas de control de velocidad,
ElsEl parámetro se utiliza para especificar la dirección de base de la interfaz API de intercambio.
el
verdadero
la cuerda
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());
}
Cambiar la dirección de base de la API de intercambio no es compatible en el sistema de backtesting, porque el sistema de backtesting es un entorno de simulación de sandbox y no accede realmente a la interfaz de la API de intercambio.
{@fun/Trade/exchange.IO exchange.IO}
Elexchange.GetBase()La función se utiliza para obtener la dirección de base de la interfaz API de intercambio actual.
La dirección de base de la interfaz API de intercambio actual. la cuerda
¿ Qué pasa?
function main() {
Log(exchange.GetBase())
}
def main():
Log(exchange.GetBase())
void main() {
Log(exchange.GetBase());
}
¿Por qué no lo haces?
Elexchange.SetProxy()La función se utiliza para establecer la configuración de proxy del objeto de intercambio {@var/EXCHANGE exchange}.
- ¿Qué quieres decir con eso?
ElproxyEl parámetro se utiliza para especificar la configuración del proxy.
Proxy (procurador)
verdadero
la cuerda
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 el objeto de intercambio {@var/EXCHANGE exchange}socks5Proxy: el nombre de la persona
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();
}
Además deespecificación globalde la dirección IP de la solicitud del objeto de intercambio {@var/EXCHANGE exchange}, también se admite la especificación de una dirección IP basada en {@var/EXCHANGE exchange}:
Si la configuración de proxy falla, elexchange.SetProxy()La función devuelve null cuando se llama.exchange.SetProxy()función establece el proxy para elrestUn proxy se puede configurar para cada objeto de intercambio {@var/EXCHANGE exchange}, y el acceso a la interfaz de intercambio vinculada al objeto de intercambio {@var/EXCHANGE exchange} después de configurar el proxy se accederá a través del proxy.
Apoyo para el ajustesocks5Proxy, tomando el primer objeto de intercambio añadido {@var/EXCHANGE exchange} es decir:exchanges[0]Por ejemplo:
exchange.SetProxy("socks5://127.0.0.1:8889").exchange.SetProxy("socks5://username:password@127.0.0.1:8889"). usernamees el nombre de usuario ypasswordes la contraseña.exchange.SetProxy("").Apoya la configuración de la dirección IP de la solicitud desde el objeto de intercambio {@var/EXCHANGE exchange},especificado globalmente.
¿Qué es lo que está pasando?
Elexchange.SetTimeout()La función de tiempo de espera se utiliza para establecer el tiempo de espera delrestsolicitud para el objeto de intercambio {@var/EXCHANGE exchange}.
En cambio. SetTimeout ((tiempo fuera)
Eltimeoutel parámetro se utiliza para especificar el número de milisegundos para la configuración de tiempo de espera.
tiempo de espera
verdadero
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());
}
El parámetrotimeoutes un valor de milisegundos, 1000 milisegundos es igual a 1 segundo.restsólo protocolo, utilizado para establecer el tiempo de espera enrestlas solicitudes, tiene efecto si se establece una sola vez.exchange.SetTimeout(3000), establece elrestel tiempo de espera para elexchangeLlamando funciones con solicitudes de red tales comoexchange.GetTicker()que no reciben una respuesta por más de 3 segundos se desactiva, y las llamadas de funciones que hacen el tiempo de espera devolverá valores nulos.SetTimeout()no es una función global, es un método del objeto de intercambio {@var/EXCHANGE exchange}.
¿Qué es lo que está pasando?
La plataforma de negociación de FMZ Quant realmente admite la función de múltiples hilos de laJavaScriptLa estrategia de lenguaje desde abajo del sistema, y pone en práctica los siguientes objetivos:
| Objetos | Direcciones | Las observaciones |
|---|---|---|
| el hilo | Objeto global con múltiples hilos | Funciones de los miembros:Thread, getThread, mainThread, etc. |
| El hilo | Objeto de hilo | Funciones de los miembros:peekMessage, postMessage, join, etc. |
| Enlace de hilo | Objeto de bloqueo de hilo | Funciones de los miembros:acquire, releaseSe pueden pasar al entorno de hilo como parámetros de la función de ejecución de hilo. |
| Enlace Evento | Objeto de evento | Funciones de los miembros:set, clear, wait, isSetSe pueden pasar al entorno de hilo como un parámetro de la función de ejecución de hilo. |
| ThreadCondition (Condición del hilo) | Objeto de condición | Funciones de los miembros:notify, notifyAll, wait, acquire, releaseSe pueden pasar al entorno de hilo como un parámetro de la función de ejecución de hilo. |
| ThreadDict es el nombre de la serie | Objeto del diccionario | Funciones de los miembros:get, setSe pueden pasar al entorno de hilo como parámetros de la función de ejecución de hilo. |
ElthreadingObject es una herramienta global de gestión multithreading que proporciona funciones tales como la creación de hilos concurrentes, bloqueos de hilos y objetos de condición.threadingEste objeto sólo es compatible con elJavaScriptestrategia lingüística.
ElThread()La función se utiliza para crear hilos concurrentes.
ElThread()La función devuelve aThreadobjeto, que se utiliza para gestionar los hilos creados simultáneamente, la comunicación de hilos, etc.
Threadobjetos
El hilo ((func,...args) Enlace (... elementos)
El parámetrofunces una función para ejecución simultánea (pasada por referencia), y admite el paso de funciones anónimas.funcpuede aceptar múltiples parámetros, que se transmitirán a través de...argsPor lo tanto, la lista de parámetros defuncdebe ser coherente con...args.
Función
verdadero
Función
El parámetroarges el parámetro real pasado afunc(es decir, la función de ejecución de hilo concurrente) cuando se ejecuta la devolución de llamada; puede haber múltiples parámetrosarg, y la lista de parámetros defuncdebe ser coherente con...args.
el
falsos
cadena, número, bool, objeto, matriz, función, valor nulo y otros tipos compatibles con el sistema
El parámetroitemes una matriz que contiene las referencias de las funciones y sus parámetros a ejecutar simultáneamente.itemLos parámetros se pueden pasar cuando se llama elThread function.
el artículo verdadero el conjunto
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()
}
Crear hilos concurrentes tanto para una función personalizada como para una función 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()
}
Utilice elThread(...items)forma para crear hilos concurrentes y ejecutar múltiples funciones secuencialmente.
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)
}
Soporta el paso de cadenas de funciones y puede importar bibliotecas externas dinámicamente para computación concurrente.
La función del hilofuncPasado en elThread()La función para ejecución simultánea se ejecuta en un entorno aislado, por lo que las variables fuera del hilo no se pueden referenciar directamente, y la compilación fallará cuando se hace referencia. Al mismo tiempo, no se admiten referencias a otras funciones de cierre dentro del hilo. Todas las API proporcionadas por la plataforma se pueden llamar dentro del hilo, pero no se pueden llamar otras funciones definidas por el usuario.
Todas las funciones relacionadas con los hilos concurrentes solo se admiten como compatibilidad de código en el sistema de backtesting y no se ejecutarán realmente por hilos concurrentes, por lo que no se repetirán en este 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}, {@fun/Threads/threading/eventLoop}
ElgetThread()La función se utiliza para obtener el objeto de hilo basado en el ID de hilo especificado.
ElgetThread()Función devuelve elThreadObjeto con el threadId especificado por el parámetro
Threadobjetos
¿Qué es esto?
El parámetrothreadIdObtener el objeto de hilo correspondiente especificando el parámetro.
Enlace verdadero 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())
}
Obtener el objeto de hilo especificado a travésthreadId.
Apoya el sistema de backtesting y el entorno comercial en vivo.
Si el hilo que desea obtener ha sido ejecutado y liberado, no puede utilizarthreading.getThread(threadId)para obtener el objeto del hilo del hilo.
{@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 Loop}
ElmainThread()La función se utiliza para obtener el objeto del hilo del hilo principal, es decir, el hilo donde elmain()la función en la estrategia se encuentra.
ElmainThread()función devuelve el objeto de hilo del hilo principal.
Threadobjetos
El tema principal es:
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
Toma elThreadobjeto del hilo principal y la salida delthreadIddel hilo 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()
}
El objeto de hilo del hilo principal también se puede obtener en hilos concurrentes.
Apoya el sistema de backtesting y el entorno comercial en 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/threading/pending pending}, {@fun/Threads/threading/eventLoop Loop}
ElcurrentThread()La función se utiliza para obtener el objeto de hilo del hilo actual.
ElcurrentThread()función devuelve el objeto de hilo del hilo actual.
Threadobjetos
El hilo actual (((
function test() {
Log("Id of the current thread:", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Toma elThreadobjeto del hilo de corriente y la salida de lathreadIddel hilo actual.
Apoya el sistema de backtesting y el entorno comercial en 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}, {@fun/Threads/threading/eventLoop}
ElLock()La función se utiliza para crear un objeto de bloqueo de hilo.
ElLock()La función devuelve un objeto de bloqueo de hilo.
ThreadLockobjetos
Encierra.
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()
}
Dos hilos concurrentes acceden a un recurso común.
Apoya el sistema de backtesting y el entorno comercial en 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/threading/event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop event Loop}, {@fun/Threads/threads/threads/eventLoop}
ElCondition()La función se utiliza para crear un objeto variable de condición, que se utiliza para lograr la sincronización y la comunicación entre los hilos en un entorno concurrente de múltiples hilos.Condition(), un hilo puede esperar cuando ciertas condiciones no se cumplen hasta que otro hilo le notifique que la condición se ha cumplido.
ElCondition()La función devuelve aThreadCondition object.
ThreadConditionobjetos
Condición
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()
}
Dos hilos concurrentes acceden a un recurso común.
El sistema de backtesting no implementa esta funcionalidad, sólo la 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 Loop}
ElEvent()función se utiliza para crear unevento de hiloobjeto, que se utiliza para la sincronización entre los hilos, permitiendo que un hilo espere la notificación o la señal de otro hilo.
ElEvent()La función devuelve aThreadEvent object.
ThreadEventobjetos
Evento ())
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()
}
Dos hilos concurrentes acceden a un recurso común.
Apoya el sistema de backtesting y el entorno comercial en 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/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop event Loop}
ElDict()La función se utiliza para crear un objeto de diccionario para pasar a hilos concurrentes.
ElDict()La función devuelve aThreadDict object.
ThreadDictobjetos
Dict ((()
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()
}
Pasar un objeto normal a la función de ejecución de hilo concurrente para probar si modificar el valor de clave del objeto causará cambios en el valor de clave del objeto en otros hilos.
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()
}
Pasa elThreadDictobjeto creado por elDict()función a la función de ejecución de hilo concurrente, y probar si modificar el valor de la clave del objeto hará que el valor de la clave del objeto en otros hilos cambie.
Cuando un objeto común se pasa a una función de hilo concurrente, se pasa como una copia profunda.
Apoya el sistema de backtesting y el entorno comercial en 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/Thread Thread}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}
ElpendingLa función se utiliza para obtener el número de hilos concurrentes que se ejecutan en el programa de estrategia actual.
Elpending()función devuelve el número de hilos concurrentes que el programa de estrategia actual está ejecutando.
Número
En trámite
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())
}
Crear dos hilos que se ejecutan simultáneamente y llamar elpending()Funcionan en diferentes puntos de tiempo.
Cuando la estrategiamain()función comienza a ejecutarse, llamando a la funciónpending()directamente devolverá 1, porque el hilo principal donde la estrategiamain()La función está localizada es también un hilo pendiente.
Apoya el sistema de backtesting y el entorno comercial en 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 pueden ser creados o devueltos porthreading.Thread(), threading.getThread(), threading.mainThread(), ythreading.currentThread().
ElpeekMessage()La función se utiliza para obtener un mensaje de un hilo.
ElpeekMessage()función devuelve el mensaje recibido por el hilo asociado con el objeto de hilo actual.
cadena, número, bool, objeto, matriz, valor nulo y otros tipos compatibles con el sistema
PeekMensaje (() PeekMessage ((tiempo muerto)
El parámetrotimeoutes la configuración de tiempo de espera. Bloqueará y esperará el número de milisegundos establecidos por el parámetro y devolverá los datos. Si no hay datos y el tiempo de espera excede el límite, se devolverá un valor nulo. Sitimeoutse establece en 0 o eltimeoutsi el parámetro no se pasa, significa que el proceso bloqueará y esperará hasta que se reciban los datos del canal.timeoutSi se establece en -1, significa que el proceso no bloqueará y devolverá datos de inmediato.
tiempo de espera falsos 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()
}
Envía mensajes al hilo principal desde un hilo concurrente.
Al escribir programas, necesitamos prestar atención a los problemas de cierre de hilo.
{@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}, {@Threads/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop}, {@
ElpostMessage()función se utiliza para enviar un mensaje a un hilo.
El mensaje es:
El parámetromsges el mensaje que se enviará.
mensaje de texto verdadero Cualquier tipo compatible con el sistema, como cadena, número, bool, objeto, matriz, 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 mensajes en hilos simultáneos y usareventLoop()para recibir notificaciones de mensajes.
Cuando una función de ejecución de threadpostMessage()La función para enviar una señal o datos, un evento de mensaje también se genera.eventLoop()Función para recibir notificaciones de mensajes.
{@fun/Threads/Thread/peekMessage peekMessage}, {@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/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}
Eljoin()Función utilizada para esperar a que el hilo salga y reclame recursos del sistema.
ElThreadRetobjetoscontiene datos sobre el resultado de la ejecución.
ThreadRetobjetos
¿Qué quieres decir? Unirse (tiempo muerto)
EltimeoutParámetro se utiliza para establecer el tiempo de espera en milisegundos para esperar a que el hilo para terminar.timeoutel parámetro se establece en 0 o eltimeoutel parámetro no está establecido, eljoin()función bloqueará y esperar hasta que el hilo termine de ejecutar.timeoutel parámetro está establecido en -1, eljoin()La función volverá inmediatamente.
tiempo de espera falsos 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}
}
Prueba eljoin()Función de tiempo de espera y salida del valor de retorno.
Eljoin()Tiempos de salida y retorno de la funciónundefined.
{@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}
Elterminate()La función se utiliza para terminar por la fuerza un hilo y liberar los recursos de hardware utilizados por el hilo creado.
Terminar el contrato
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 la ejecución de un hilo con la fuerza Después de terminar un hilo con la fuerza, no habrá salida de este hilo en el registro.
Para los hilos que se terminan por la fuerza por elterminate()La función, ya no podemos utilizar eljoin()Función para esperar a que terminen.
{@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/Threads/Thread/eventLoop eventLoop}
ElgetData()Los datos son válidos cuando el hilo no ha ejecutado eljoin()Función (en espera de exit exit) y no ha ejecutado elterminate()Función (terminando el hilo por la fuerza).
ElgetData()Función devuelve el valor clave correspondiente a lakeyParámetro en el par clave-valor almacenado en el contexto del hilo actual.
cadena, número, bool, objeto, matriz, valor nulo y otros tipos compatibles con el sistema
- ¿Qué quieres decir? - ¿ Qué pasa?
ElkeyParámetro es el nombre de la clave del par clave-valor almacenado.
llave verdadero la cuerda
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()
}
Registre el valor de la clavecounten el entorno de hilo concurrente, y luego leer el valor clave decounten el hilo 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 name}, {@fun/Threads/Thread/eventLoop eventLoop}
ElsetData()La función se utiliza para almacenar variables en el contexto del hilo.
el conjunto de datos (clave, valor)
ElkeyEl parámetro se utiliza para especificar el nombre de la clave del par clave-valor almacenado.
llave
verdadero
la cuerda
ElvalueEl parámetro se utiliza para especificar el valor de clave del par clave-valor almacenado.
Valor verdadero Cualquier tipo compatible con el sistema, como cadena, número, bool, objeto, matriz, 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()
}
Establezca el par clave-valor en el hilo concurrente y lea el par clave-valor en el hilo principal.
Los datos son válidos cuando el hilo no ha ejecutado eljoin()Función (en espera de exit exit) y no ha ejecutado elterminate()El valor del parámetrovaluedebe ser una variable serializable.
{@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}
Elid()función se utiliza para devolver elthreadIdde la instancia actual de objeto multithreaded.
El valor de retorno de laid()la función esthreadId.
Número
el número de identificación
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.id():`, t1.id())
t1.join()
}
Crear un hilo de ejecución simultánea y la salida de lathreadIdde este hilo concurrente en el hilo 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}
Elname()función se utiliza para devolver el nombre de la instancia de objeto multithreaded actual.
Elname()función devuelve el nombre del hilo concurrente.
la cuerda
nombre ())
function main() {
var t1 = threading.Thread(function() {
threading.currentThread().setData("data", 100)
})
Log(`t1.name():`, t1.name()) // t1.name(): Thread-1
t1.join()
}
Crea un hilo concurrente y saca el nombre del hilo concurrente en el hilo 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}
EleventLoop()La función se utiliza para escuchar los eventos recibidos por el hilo.
EleventLoop()función devuelve la información del evento recibido por el hilo actual.Estructura de la información del evento.
Objeto, valor cero
Loop de acontecimientos EventLoop (tiempo muerto)
El parámetrotimeoutes la configuración de tiempo de espera en milisegundos.timeoutSi el valor de un evento es igual a 0, esperará a que ocurra un evento antes de regresar. Si es mayor que 0, establecerá el tiempo de espera del evento. Si es menor que 0, devolverá el evento más reciente inmediatamente.
tiempo de espera falsos 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()
}
Ejecute tres hilos simultáneamente y saque la información del evento recibida.
El mecanismo de procesamiento de loseventLoop()la función es la misma que la función 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 set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}
Objeto de bloqueo de hilo, utilizado para el procesamiento de sincronización de múltiples hilos.
Elacquire()La función se utiliza para solicitar un bloqueo de hilo (bloqueo).
¿Qué es esto?
Por favor, consulte elthreading.Lock()Sección para ejemplos.
Elacquire()Cuando un hilo llama elacquire()Si el bloqueo no está actualmente sostenido por otro hilo, el hilo que llama adquiere el bloqueo con éxito y continúa la ejecución. Si el bloqueo ya está sostenido por otro hilo, el hilo que llamaacquire()Se bloqueará hasta que el candado sea liberado.
¿Qué es lo que está pasando?
Elrelease()Función utilizada para liberar un bloqueo de hilo (desbloqueo).
liberación
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()
}
Prueba de escenarios de punto muerto
Debe tenerse en cuenta que el uso inadecuado de las cerraduras de hilo puede provocar un estancamiento.
¿Por qué no lo haces?
Objeto de evento, utilizado para notificaciones y señales de eventos de múltiples hilos.
Elset()La función se utiliza para notificar eventos (señales de conjunto).
el conjunto (()
Por favor, consulte elthreading.Event()Sección para ejemplos.
Si la señal se ha configurado utilizandoset()Necesitamos limpiar la señal y volver a establecerla.
{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Elclear()La función se utiliza para eliminar la señal.
Está claro.
Por favor, consulte elthreading.Event()Sección para ejemplos.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}
Elwait()función se utiliza para establecer un evento (señal) espera, y bloqueará antes de que el evento (señal) se establece; admite el establecimiento de un parámetro de tiempo de espera.
Elwait()La función devuelve si el tiempo de espera ha ocurrido. Si es así, devuelve un valor verdadero.
Bool también
Espera un poco. Espera (tiempo muerto)
EltimeoutEl parámetro se utiliza para establecer el tiempo de espera en milisegundos.
tiempo de espera falsos 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()
}
Prueba el valor de retorno delwait() function.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}
ElisSet()La función se utiliza para determinar si se ha establecido un evento (señal).
ElisSet()La función devuelve si el evento (señal) se ha establecido; si el evento (señal) se ha establecido, devuelve un valor verdadero.
Bool también
EsSET (()
Por favor, consulte elthreading.Event()Sección para ejemplos.
{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}
Objeto de condición, utilizado para la sincronización de múltiples hilos.
Elnotify()La función se utiliza para despertar un hilo en espera (si lo hay).wait()El método se despertará.
Se lo 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)
}
}
Utilice elnotify()Función para despertar el hilo de espera.
Elnotify()función despierta un hilo en la cola de espera.
Cuando elnotify()Función despierta un hilo, el hilo recuperará el bloqueo del hilo.
{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
ElnotifyAll()La función despierta todos los hilos en espera.
Notificar a todos
Por favor, consulte elThreadCondition.notify()Sección para ejemplos.
ElnotifyAll()función despierta todos los hilos en espera uno por uno, y los hilos despertados recuperar el cierre de hilo.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
Elwait()Función utilizada para hacer que un hilo espere bajo ciertas condiciones diseñadas.
Espera un poco.
Por favor, consulte elThreadCondition.notify()Sección para ejemplos.
Elwait()La función libera el bloqueo del hilo y recupera el bloqueo del hilo cuando se despierta.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}
Elacquire()La función se utiliza para solicitar un bloqueo de hilo (bloqueo).
¿Qué es esto?
Por favor, consulte elThreadCondition.notify()Sección para ejemplos.
Antes de su usowait(), es necesario solicitar el cierre de hilo (bloqueo) del objeto de condición actual.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}, {@fun/ThreadCondition/ThreadCondition/release release}, {@fun/ThreadCondition/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/ThreadCondition/ThreadCondition/release release}, {@fun/ThreadCondition/thread release}, {@fun/ThreadCondition/threadCondition/release release}
Elrelease()Función utilizada para liberar un bloqueo de hilo (desbloqueo).
liberación
Por favor, consulte elThreadCondition.notify()Sección para ejemplos.
Después de usowait(), necesitamos liberar el cierre de hilo (desbloqueo) del objeto de condición actual.
{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/ThreadCondition/ThreadCondition/acquire}, {@fun/ThreadCondition/ThreadCondition/acquire}, {@fun/Threads/ThreadCondition/acquire}, {@fun/ThreadCondition/ThreadCondition/acquire}, {@fun/ThreadCondition/ThreadCondition/acquire}, {@fun/ThreadCondition/acquire}, {@fun/ThreadCondition/acquire}, {@fun/ThreadCondition/acquire}, {@fun/threadCondition/threadCondition/acquire}, {@fun/
Objeto de diccionario, utilizado para compartir datos.
Elget()La función se utiliza para obtener el valor clave registrado en el objeto del diccionario.
Elget()función devuelve el valor de la clave especificada por elkey parameter.
cadena, número, bool, objeto, matriz, valor nulo y otros tipos compatibles con el sistema
Obtener la llave
ElkeyEl parámetro se utiliza para especificar el nombre de la clave correspondiente a la clave a obtener.
llave verdadero la cuerda
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"))
}
Utilice objetos de eventos para notificar a los hilos para leer y modificar datos.
¿Por qué no lo haces?
Elset()La función se utiliza para establecer un par de valores clave.
el conjunto (clave, valor)
El parámetrokeyse utiliza para establecer el nombre de clave que se modificará.
llave
verdadero
la cuerda
El parámetrovalueSe utiliza para establecer el valor clave que se modifica.
Valor verdadero cadena, número, bool, objeto, matriz, valor nulo y otros tipos compatibles con el sistema
Por favor, consulte elThreadDict.get()Sección para ejemplos.
# # # # # # # # # # # # # # # # # # # # #
En la plataforma de negociación FMZ Quant, implementa principalmente varias funciones, llamadas relacionadas con blockchain a través deexchange.IO()El siguiente documento describe elexchange.IO()El método de llamada del sistema deexchange.IO("abi", ...)la función se utiliza para registrar un ABI.
exchange.IO(k, dirección, abiContenido)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"abi"significa que la función se utiliza para registrarABI- ¿ Por qué?
el
verdadero
la cuerda
EladdressParámetro utilizado para especificar la dirección del contrato inteligente.
Dirección
verdadero
la cuerda
ElabiContentParámetro se utiliza para especificar elABIdel contrato inteligente.
AbiContenido
verdadero
la cuerda
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)
}
No es necesario registrar los métodos de llamada de contratos inteligentes si se trata de métodos ERC20 estándar.
Toma elABIEl contenido del contrato se puede obtener en la siguiente dirección URL, tomando elresultsólo en el campo, por ejemplo:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
El método de llamada deexchange.IO("api", "eth", ...)La función se utiliza para llamar al método Ethereum RPC.
Elexchange.IO("api", "eth", ...)La función devuelve el valor de retorno del método RPC llamado.
cadena, número, bool, objeto, matriz, nulo y todos los demás tipos compatibles con el sistema
exchange.IO(k, cadena de bloques, método rpc)exchange.IO(k, cadena de bloques, método rpc,...args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"api"indica que la función se utiliza para extender la solicitud de llamada.
el
verdadero
la cuerda
ElblockChainParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"eth"indica que la función se utiliza para las llamadas de métodos RPC en la red Ethereum.
el bloqueChain
verdadero
la cuerda
ElrpcMethodParámetro se utiliza para establecer el método RPC a ser llamado por elexchange.IO()la función.
Método rpc
verdadero
la cuerda
ElargParámetro se utiliza para especificar los parámetros del método RPC a ser llamado.argEl tipo y el número deargLos parámetros dependen del método RPC especificado por elrpcMethodel parámetro.
el
falsos
cadena, número, bool, objeto, matriz, función, nulo y todos los demás tipos compatibles con el 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()))
}
Compruebe el saldo de ETH en su billetera:
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 las transferencias de ETH, puede configurar el{gasPrice: 11, gasLimit: 111, nonce: 111}Parámetro, que se establece en el último parámetro delexchange.IO()En el caso de los productos que no se encuentran en la lista de productos, el número de productos que se encuentran en la lista de productos que se encuentran en la lista denoncey utilizar el sistema por defecto, o dejargasLimit/gasPrice/noncedesactivar y utilizar el valor predeterminado del 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)
}
CuestionariogasPrice:
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)
}
Cuestionarioeth_estimateGas:
El segundo parámetro delexchange.IO()Función con"eth"puede llamar directamente a los métodos RPC disponibles para el servidor de nodo Ethereum.
¿Por qué no lo haces?
Elexchange.IO("encode", ...)La función es llamada para codificar datos.
Elexchange.IO("encode", ...)función devuelve los datos codificados.
la cuerda
exchange.IO(k, formato de datos,...args)exchange.IO(k, dirección, formato de datos)exchange.IO(k, dirección, datosFormato,...args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"encode"significa que la función se utiliza para codificar datos.
el
verdadero
la cuerda
EladdressEl parámetro se utiliza para establecer la dirección del contrato inteligente.exchange.IO("encode", ...)función, pasando en eladdressParámetro indica la codificación de la llamada del método en el contrato inteligente.exchange.IO("encode", ...)La función, si eladdresssi el parámetro no se pasa, la función se utiliza para codificar el orden de tipo especificado y es funcionalmente equivalente aabi.encodeEn elSolidity- ¿ Por qué?
Dirección
falsos
la cuerda
EldataFormatParámetro utilizado para especificar el método, el tipo y el orden de los datos codificados.
DatosFormato
verdadero
la cuerda
ElargParámetro se utiliza para especificar el valor de datos específicos que coincide con eldataFormatPuede haber más de unaargParámetro, y el tipo y el número deargLos parámetros dependen de ladataFormatConfiguración de parámetros.
el
falsos
cadena, número, tuple, matriz y todos los otros tipos compatibles con el 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 ejemplo, llamando el método de codificaciónunwrapWETH9:
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
*/
}
Es equivalente al ejemplo de codificación deabi.encodeEn elSolidity:
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)
}
Soporta la codificación de un tuplo o un orden de tipo que contiene un tuplo.
Este tipo de orden consiste en:tuple, bytes, así que cuando llamasexchange.IO()para codificar, usted necesita seguir pasando dos parámetros:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Los parámetros transmitidos deben ser también coherentes con la estructura y el tipo detuple, tal como se define en eltypesParámetro del formulario: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)
}
Apoya la codificación secuencial de matrices o tipos que contienen matrices:
Elexchange.IO()La función encapsula elencodemétodo, que puede devolver el código de llamada de la función ahexPara un uso específico, puede consultar las plataformas disponibles públicamente.
Elexchange.IO("encodePacked", ...)La función se llama de una manera que se utiliza paraencodePacked encoding.
Elexchange.IO("encodePacked", ...)Función devuelve elencodePackeddatos codificados.
la cuerda
exchange.IO(k, formato de datos,...args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"encodePacked"significa que la función se utiliza para datosencodePackedcodificación.
el
verdadero
la cuerda
EldataFormatParámetro se utiliza para especificar el tipo y el orden de laencodePackeddatos codificados.
DatosFormato
verdadero
la cuerda
ElargParámetro se utiliza para especificar el valor de datos específicos que coincide con eldataFormatPuede haber más de unaargParámetro, y el tipo y el número deargLos parámetros dependen de ladataFormatConfiguración de parámetros.
el
verdadero
cadena, número, tuple, matriz y todos los otros tipos compatibles con el 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)
}
Cuando se utilizaUniswap V3, usted necesita para pasar en parámetros como la ruta de intercambio, usted necesita utilizar elencodePackedoperación de codificación:
Elexchange.IO("decode", ...)La función se llama de una manera que se utiliza para la decodificación.
Elexchange.IO("decode", ...)Devuelve una cadena cuando sólo hay un dato especificado por eldataFormatRetorna una matriz cuando hay más de un dato especificado por eldataFormatel parámetro.
la matriz, la cadena
exchange.IO(k, datosFormato, datos)
ElkParámetro se utiliza para establecer la función de laexchange.IO()la función, y la configuración a"decode"significa que la función se utiliza para decodificar datos.
el
verdadero
la cuerda
EldataFormatParámetro utilizado para especificar el tipo y el orden de los datos decodificados.
DatosFormato
verdadero
la cuerda
EldataEl parámetro se utiliza para establecer los datos a descifrar.
datos
verdadero
la cuerda
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)
}
El funcionamiento inverso de laexchange.IO("encode", ...)Función:
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)
}
El siguiente ejemplo realiza primero unaencodePackedLa operación en elpathEl procesamiento de parámetros, porque elexactOutputllamada de método que necesita ser codificado más tarde requierepathcomo un parámetro.encodeElexactOutputmétodo del contrato de ruta, que sólo tiene un parámetro de tipotuple. Nombre del métodoexactOutputestá codificado como:0x09b81346, y utilizando elexchange.IO("decode", ...)método para decodificar el resultadodecodeRaw, coherente con la variabledataTuple.
Para el tratamiento de datos, elexchange.IO()Función soporta no sólo la codificación, sino también la decodificación.
Elexchange.IO("key", ...)La función se llama de una manera para cambiar las claves privadas.
exchange.IO(K, tecla)
El parámetrokse utiliza para establecer la función de laexchange.IO()función, fijada en"key"significa que la función se utiliza para cambiar la clave privada.
el
verdadero
la cuerda
ElkeyEl parámetro se utiliza para establecer la clave privada.
llave
verdadero
la cuerda
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Elexchange.IO()También es posible agregar múltiples objetos de intercambio (ver: {@var/EXCHANGE/exchanges exchanges}) para manipular múltiples direcciones de billetera.
Elexchange.IO("api", ...)La función se llama de una manera que se utiliza para llamar a los métodos del contrato inteligente.
Elexchange.IO("api", ...)La función devuelve el valor de retorno del método llamado contrato inteligente.
cadena, número, bool, objeto, matriz, nulo y todos los demás tipos compatibles con el sistema
exchange.IO(k, dirección, método)exchange.IO(k, dirección, método,...args)exchange.IO(k, dirección, método, valor,... args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"api"indica que la función se utiliza para extender la solicitud de llamada.
el
verdadero
la cuerda
EladdressParámetro utilizado para especificar la dirección del contrato inteligente.
Dirección
verdadero
la cuerda
ElmethodEl parámetro se utiliza para especificar el método del contrato inteligente que se va a llamar.
Método
verdadero
la cuerda
ElvalueEl parámetro se utiliza para establecer la cantidad de ETH a enviar.stateMutabilityel atributo del método de contrato inteligente a ejecutar espayable, luego elvalueEl parámetro debe ser pasado."stateMutability": "payable"Los atributos pueden ser vistos desde el ABI.exchange.IO()La función determinará el parámetro requerido basado en elstateMutabilitySi el atributo en el ABI que se ha registrado.stateMutabilityel atributo esnonpayable, luego elvalueNo es necesario pasar el parámetro.
Valor
falsos
número, cadena
ElargParámetro se utiliza para especificar los parámetros del método del contrato inteligente a ser llamado.argParámetro, y el tipo y el número deargLos parámetros dependen del método del contrato inteligente que se va a llamar.
el
falsos
cadena, número, bool y todos los otros tipos compatibles con el 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
}
Eldecimalsel método es unconstantEl método de ERC20 que no incurre en el consumo de gas y puede consultar los datos de precisión de un token.decimalsEl método no tiene parámetros. Valor de retorno: datos de precisión del 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"))
}
Elallowanceel método es unconstantEl método de ERC20 que no genera consumo de gas y puede consultar la cantidad autorizada de un token para una determinada dirección de contrato.allowanceEl método toma 2 parámetros, el primero es la dirección de la billetera y el segundo es la dirección autorizada.
owner: la dirección de la billetera, el ejemplo se sustituye por la cadena spender: la dirección del contrato autorizado, el ejemplo se sustituye por la cadena 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 || {})
}
ElmulticallEl método es un no-constantmétodo deUniswap V3que genera consumo de gas y se utiliza para canjear fichas de múltiples maneras.
ElmulticallEl método puede tener varias formas de pasar parámetros, puede comprobar el ABI que contiene el método específicamente, debe registrar el ABI antes de llamar al método.
Para ejemplos concretos demulticallEn el caso de las llamadas de método, puede consultar las plataformas accesibles al público.
Algunos detalles se describen aquí usando pseudo-código:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: dirección del router v2 de Uniswap V3.value: la cantidad de ETH a transferir, fijada en 0 si el token de la operación de intercambio no es ETH.deadline: deadlinees el parámetro delmulticallmétodo, que puede establecerse en (new Date().getTime() / 1000) + 3600, lo que indica que es válido durante una hora.data: dataes el parámetro delmulticallel método, los datos de la operación de embalaje que debe realizarse.
Similar aexchange.IO("api", "eth", "send", "toAddress", toAmount), elgasLimit/gasPrice/noncela configuración de la llamada de método puede especificarse al llamar elmulticallel método.
Una vez más, usamos pseudo-código para describir:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
El parámetro{gasPrice: 11, gasLimit: 111, nonce: 111}El valor de la función de control puede ajustarse de acuerdo con las necesidades específicas, que se ajusta al último parámetro de laexchange.IO()la función.
Puede omitir elnoncey utilizar el valor predeterminado del sistema, o dejargasLimit/gasPrice/noncedesactivar y utilizar el valor predeterminado del sistema para todos.
Elexchange.IO("address")la función se llama de tal manera que obtenga la dirección de la billetera configurada por el objeto de intercambio {@var/EXCHANGE exchange}.
Elexchange.IO("address")La función devuelve la dirección de la billetera configurada.
la cuerda
exchange.IO(k) El
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"address"significa que la función se utiliza para obtener la dirección de cartera configurada.
el
verdadero
la cuerda
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Elexchange.IO("base", ...)La función se llama de una manera para establecer la dirección del nodo RPC.
exchange.IO(k, dirección)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"base"significa que la función se utiliza para cambiar los nodos RPC.
el
verdadero
la cuerda
Eladdressel parámetro se utiliza para establecer la dirección del nodo RPC.
Dirección
verdadero
la cuerda
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}
ElTA.MACD()La función se utiliza para calcular elIndicador MACD de diferenciación y similitud suavizada exponencial.
El valor de retorno de laTA.MACD()Función es una matriz bidimensional con la estructura:[DIF, DEA, MACD]- ¿ Por qué?
el conjunto
TA.MACD ((inReal) TA.MACD ((en tiempo real, optInFastPeriod, optInSlowPeriod, optInSignalPeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInFastPeriodEl parámetro se utiliza para establecer el período rápido.
Seleccionar el período de tiempo más rápido
falsos
Número
EloptInSlowPeriodel parámetro se utiliza para establecer el período lento.
optInSlowPeriod (en inglés)
falsos
Número
EloptInSignalPeriodel parámetro se utiliza para establecer el período de la señal.
OptEn el período de señal
falsos
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]);
}
ElTALa biblioteca de indicadores de FMZ Quant, optimizada para algoritmos de indicadores comunes.JavaScript, Python, C++las convocatorias de estrategia lingüística,Código de la biblioteca TA de código abierto- ¿ Por qué?
Los valores predeterminados de laoptInFastPeriod, optInSlowPeriod, yoptInSignalPeriodParámetros de laTA.MACD()Las funciones son:12, 26, y9.
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
ElTA.KDJ()La función se utiliza para calcularIndicadores estocásticos.
El valor de retorno de laTA.KDJ()Función es una matriz bidimensional con la estructura:[K, D, J]- ¿ Por qué?
el conjunto
No hay que hacer nada. TA.KDJ ((en tiempo real, período, kPeriodo, dPeriodo)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
Elperiodel parámetro se utiliza para establecer el período 1.
el período
falsos
Número
ElkPeriodel parámetro se utiliza para establecer el período 2.
Pérodo
falsos
Número
EldPeriodel parámetro se utiliza para establecer el período 3.
dPeriodo
falsos
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]);
}
Los valores predeterminados para elperiod, kPeriod, ydPeriodParámetros de laTA.KDJ()Las funciones son:9, 3, y3.
¿Qué es lo que está pasando? ¿Qué está pasando?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
ElTA.RSI()La función se utiliza para calcular elIndicador de fuerza.
El valor de retorno de laTA.RSI()La función es: una matriz unidimensional.
el conjunto
¿Por qué no lo haces? TA.RSI ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodEl parámetro se utiliza para establecer el período.
OptInTimePeriodo
falsos
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);
}
El valor predeterminado de laoptInTimePeriodParámetro delTA.RSI()su función es:14.
¿Qué es lo que está sucediendo aquí?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
ElTA.ATR()La función se utiliza para calcular elIndicador de volatilidad verdadera media.
El valor de retorno de laTA.ATR()La función es: una matriz unidimensional.
el conjunto
Los precios de los servicios de transporte de mercancías se determinan en función de la situación de los pasajeros. TA.ATR ((en precioHLC, optInTimePeriod)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodEl parámetro se utiliza para establecer el período.
OptInTimePeriodo
falsos
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);
}
El valor predeterminado de laoptInTimePeriodParámetro delTA.ATR()su función es:14.
¿Qué es lo que está sucediendo aquí?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
ElTA.OBV()La función se utiliza para calcular elindicador de marea de energía.
El valor de retorno de laTA.OBV()La función es: una matriz unidimensional.
el conjunto
Los Estados miembros deben tener en cuenta los requisitos de la presente Directiva. TA.OBV ((inReal, inPriceV) el precio de los productos
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
ElinPriceVel parámetro se utiliza para especificar los datos sobre el importe de la transacción.
enPriceV
falsos
{@struct/Record Record} matriz de estructuras
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);
}
¿Qué es lo que está sucediendo aquí?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
ElTA.MA()La función se utiliza para calcular elIndicador MACD.
El valor de retorno de laTA.MA()La función es: una matriz unidimensional.
el conjunto
TA.MA(InReal)TA.MA(inReal, optInTimePeriod) El valor de las acciones de la entidad es el valor de las acciones de la entidad.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodEl parámetro se utiliza para establecer el período.
OptInTimePeriodo
falsos
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);
}
El valor predeterminado de laoptInTimePeriodParámetro delTA.MA()su función es:9.
Los resultados de la evaluación de los resultados de los ensayos se basan en los resultados de los ensayos realizados en los Estados miembros, y se basan en los resultados de los ensayos realizados en los Estados miembros.
ElTA.EMA()La función se utiliza para calcular elIndicador promedio exponencial.
El valor de retorno de laTA.EMA()La función es: una matriz unidimensional.
el conjunto
El trabajo de la Comisión es el siguiente: TA.EMA ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodEl parámetro se utiliza para establecer el período.
OptInTimePeriodo
falsos
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);
}
}
El valor predeterminado de laoptInTimePeriodParámetro delTA.EMA()su función es:9.
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MA¿Qué es lo que está sucediendo? ¿Qué está pasando?
ElTA.BOLL()La función se utiliza para calcular elIndicador de la banda de Bollinger.
El valor de retorno de laTA.BOLL()Función es una matriz bidimensional con la estructura:[upLine, midLine, downLine]- ¿ Por qué?
el conjunto
¿Por qué no lo haces? TA.BOLL ((inReal, punto, multiplicador)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
ElperiodEl parámetro se utiliza para establecer el período.
el período
falsos
Número
Elmultiplierel parámetro se utiliza para establecer el multiplicador.
el multiplicador
falsos
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);
}
}
Los valores predeterminados para elperiodymultiplierParámetros de laTA.BOLL()Las funciones son:20y2.
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
ElTA.Alligator()La función se utiliza para calcular elIndicador de cocodrilo.
El valor de retorno de laTA.Alligator()Función es una matriz bidimensional con la estructura:[jawLine, teethLine, lipsLine]- ¿ Por qué?
el conjunto
TA. Alligator ((inReal) TA.Alligator ((enReal, mandíbulaDuración, dientesDuración, labiosDuración)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EljawLengthParámetro utilizado para establecer el período de mandíbula.
el largo de la mandíbula
falsos
Número
ElteethLengthse utiliza el parámetro para establecer el período de los dientes.
DientesDuración
falsos
Número
EllipsLengthel parámetro se utiliza para establecer el período del labio superior.
Los labiosDuración
falsos
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]);
}
Los valores predeterminados de lajawLength, teethLength, ylipsLengthParámetros de laTA.Alligator()Las funciones son:13, 8, y5.
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MA¿Por qué no lo haces? ¿Por qué no lo haces?
ElTA.CMF()La función se utiliza para calcular elIndicador de flujo de caja de Chaikin.
El valor de retorno de laTA.CMF()La función es: una matriz unidimensional.
el conjunto
El objetivo de la política de seguridad es garantizar la seguridad de los trabajadores. TA.CMF ((inReal, inPriceV) el precio de los productos en el mercado
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
ElinPriceVse utiliza para especificar los datos de volumen.
enPriceV
falsos
{@struct/Record Record} matriz de estructuras
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);
}
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MA¿Por qué no lo haces? ¿Por qué no lo haces?
ElTA.Highest()La función se utiliza para calcular elprecio más alto del período.
ElTA.Highest()función devuelve el valor máximo de un atributo en el último período determinado, excluyendo el Bar actual.
Número
TA.El más alto ((enReal) TA.Más alto (en real, punto, atr)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
ElperiodEl parámetro se utiliza para establecer el período.
el período
falsos
Número
ElattrParámetro se utiliza para establecer los atributos, opcionalmente:Open, Close, Low, High, Volume, OpenInterest- ¿ Por qué?
el mismo
falsos
la cuerda
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 ejemplo, si elTA.Highest(records, 30, "High")La función se llama, si el parámetro de períodoperiodestá configurado para:0, significa calcular todos losBarsde los datos de la línea K transmitidos por elinRealParámetro; si el parámetro de atributoattrno se especifica, los datos de línea K transmitidos por elinRealEl parámetro se considera una matriz ordinaria.
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MA¿Qué es lo que está sucediendo? ¿Qué está pasando?
ElTA.Lowest()La función se utiliza para calcular elprecio más bajo del período.
ElTA.Lowest()función devuelve el valor mínimo de un atributo en el último período determinado, excluyendo el Bar actual.
Número
TA.Lowerest ((enReal) TA.Más bajo (en real, punto, atr)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
ElperiodEl parámetro se utiliza para establecer el período.
el período
falsos
Número
ElattrParámetro se utiliza para establecer los atributos, opcionalmente:Open, Close, Low, High, Volume, OpenInterest- ¿ Por qué?
el mismo
falsos
la cuerda
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 ejemplo, si elTA.Lowest(records, 30, "Low")La función se llama, si el parámetro de períodoperiodestá configurado para:0, significa calcular todos losBarsde los datos de la línea K transmitidos por elinRealParámetro; si el parámetro de atributoattrno se especifica, los datos de línea K transmitidos por elinRealEl parámetro se considera una matriz ordinaria.
El uso de laTA.Highest()yTA.Lowest()las funciones en elC++La estrategia debe tenerse en cuenta que elHighest()yLowest()Cada función tiene sólo 2 parámetros.
Y el primer parámetro pasado en no son los datos de la línea Krobtenido cuando la funciónauto r = exchange.GetRecords()fue llamado.
Tienes que llamar a larEl método y pasar en los datos de atributos específicos.r.Close()datos de los precios de cierre.Close, High, Low, Open, Volumecomo en elr.Close()método de llamada.
Ejemplo de ensayo deC++Estrategia lingüí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);
}
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MA¿Qué es lo que está sucediendo? ¿Qué está pasando?
ElTA.SMA()La función se utiliza para calcular elIndicador de promedio móvil simple.
El valor de retorno de laTA.SMA()La función es: una matriz unidimensional.
el conjunto
El trabajo de la Comisión es el de la Comisión. TA.SMA ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodEl parámetro se utiliza para establecer el período.
OptInTimePeriodo
falsos
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);
}
El valor predeterminado de laoptInTimePeriodParámetro delTA.SMA()su función es:9.
¿Qué es lo que está sucediendo? ¿Qué está pasando?TA.MANo, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no, no.
Eltalib.CDL2CROWS()La función se utiliza para calcularDos Cuervos (gráfico de línea K - Dos Cuervos).
El valor de retorno de latalib.CDL2CROWS()La función es una matriz unidimensional.
el conjunto
Talib.CDL2CROWS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL2CROWS()La función se describe en la documentación de la biblioteca talib como:CDL2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)Para las llamadas en elPythonlenguaje, los parámetros de transmisión son diferentes y deben basarse en la descripción anterior:Records[Open,High,Low,Close].
Ejemplo de división de una variablerecords(es decir, parámetroinPriceOHLC, escriba {@struct/Record Record} matriz de estructuras) en:Openlista: escrito en Python comorecords.Open.
Highlista: escrito comorecords.Highen Python.Lowlista: escrito en Python comorecords.Low.
Closelista: escrito en Python comorecords.Close.
Llamado en el código de estrategia de Python:
talib.CDL2CROWS(records.Open, records.High, records.Low, records.Close)
El otrotalibLos indicadores se describen de la misma manera y no se repetirán.
Eltalib.CDL3BLACKCROWS()La función se utiliza para calcularTres cuervos negros (gráfico de línea K - Tres cuervos negros).
El valor de retorno de latalib.CDL3BLACKCROWS()La función es: una matriz unidimensional.
el conjunto
Talib.CDL3BLACKCROWS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL3BLACKCROWS()La función se describe en la documentación de la biblioteca talib como:CDL3BLACKCROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDL3INSIDE()La función se utiliza para calcularTres dentro hacia arriba/abajo (gráfico de líneas K: Tres dentro hacia arriba/abajo).
El valor de retorno de latalib.CDL3INSIDE()La función es: una matriz unidimensional.
el conjunto
Talib.CDL3 INSIDE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL3INSIDE()La función se describe en la documentación de la biblioteca talib como:CDL3INSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDL3LINESTRIKE()La función se utiliza para calcular elHuelga de tres líneas (gráfico de líneas K: Huelga de tres líneas).
El valor de retorno de latalib.CDL3LINESTRIKE()La función es: una matriz unidimensional.
el conjunto
Talib.CDL3LINESTRIKE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL3LINESTRIKE()La función se describe en la documentación de la biblioteca talib como:CDL3LINESTRIKE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDL3OUTSIDE()La función se utiliza para calcularTres fuera hacia arriba/abajo (gráfico de línea K: Tres fuera hacia arriba/abajo).
El valor de retorno de latalib.CDL3OUTSIDE()La función es: una matriz unidimensional.
el conjunto
Talib.CDL3OUTSIDE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL3OUTSIDE()La función se describe en la documentación de la biblioteca talib como:CDL3OUTSIDE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDL3STARSINSOUTH()La función se utiliza para calcularTres estrellas en el sur (gráfico de línea K: Tres estrellas en el sur).
El valor de retorno de latalib.CDL3STARSINSOUTH()La función es: una matriz unidimensional.
el conjunto
Talib.CDL3STARSINSOUTH ((en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL3STARSINSOUTH()La función se describe en la documentación de la biblioteca talib como:CDL3STARSINSOUTH(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDL3WHITESOLDIERS()La función se utiliza para calcularTres soldados blancos avanzando (gráfico de línea K: Tres soldados blancos avanzando).
El valor de retorno de latalib.CDL3WHITESOLDIERS()La función es: una matriz unidimensional.
el conjunto
Talib.CDL3BLANCOSOLDADOS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDL3WHITESOLDIERS()La función se describe en la documentación de la biblioteca talib como:CDL3WHITESOLDIERS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLABANDONEDBABY()La función se utiliza para calcularNiño abandonado (gráfico de línea K: Niño abandonado).
El valor de retorno de latalib.CDLABANDONEDBABY()La función es: una matriz unidimensional.
el conjunto
Talib.CDLABANDONEDBABY ((en el precio de OHLC) Talib.CDLABANDONEDBABY ((en el precio OHLC, optInPenetration)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro se utiliza para establecer la penetración, el valor predeterminado es 0,3.
- ¿ Qué pasa?
falsos
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);
}
ElCDLABANDONEDBABY()La función se describe en la documentación de la biblioteca talib como:CDLABANDONEDBABY(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Eltalib.CDLADVANCEBLOCK()La función se utiliza para calcular elBloque de adelanto (gráfico de líneas K: adelanto).
El valor de retorno de latalib.CDLADVANCEBLOCK()La función es una matriz unidimensional.
el conjunto
Talib.CDLADVANCEBLOCK ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLADVANCEBLOCK()La función se describe en la documentación de la biblioteca talib como:CDLADVANCEBLOCK(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLBELTHOLD()La función se utiliza para calcular elSe aplicará el método de ensayo de la velocidad..
El valor de retorno de latalib.CDLBELTHOLD()La función es: una matriz unidimensional.
el conjunto
Talib.CDLBELTHOLD ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLBELTHOLD()La función se describe en la documentación de la biblioteca talib como:CDLBELTHOLD(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLBREAKAWAY()La función se utiliza para calcular elBreakaway (gráfico de línea K: Breakaway).
El valor de retorno de latalib.CDLBREAKAWAY()La función es: una matriz unidimensional.
el conjunto
Talib.CDLBREAKAWAY ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
function main() {
var records = exchange.GetRecords()
var ret = talib.CDLBREAKAWAY(records)
Log(ret)
}
import talib
def main():
records = exchange.GetRecords()
ret = talib.CDLBREAKAWAY(records.Open, records.High, records.Low, records.Close)
Log(ret)
void main() {
auto records = exchange.GetRecords();
auto ret = talib.CDLBREAKAWAY(records);
Log(ret);
}
CDLBREAKAWAY()La función se describe en la documentación de la biblioteca talib como:CDLBREAKAWAY(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLCLOSINGMARUBOZU()La función se utiliza para calcularCierre de Marubozu (gráfico de línea K: cierre descalzo y descalzo).
El valor de retorno de latalib.CDLCLOSINGMARUBOZU()La función es: una matriz unidimensional.
el conjunto
Talib.CDLCLOSINGMARUBOZU ((en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLCLOSINGMARUBOZU()La función se describe en la documentación de la biblioteca talib como:CDLCLOSINGMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLCONCEALBABYSWALL()La función se utiliza para calcular elOcultando la golondrina bebé (gráfico de línea K: patrón de ocultación de la golondrina bebé).
El valor de retorno de latalib.CDLCONCEALBABYSWALL()La función es: una matriz unidimensional.
el conjunto
Talib.CDLCONCEALBABYSWALL (en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLCONCEALBABYSWALL()La función se describe en la documentación de la biblioteca talib como:CDLCONCEALBABYSWALL(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLCOUNTERATTACK()La función se utiliza para calcularContraataque (gráfico de líneas K: Contraataque).
El valor de retorno de latalib.CDLCOUNTERATTACK()La función es una matriz unidimensional.
el conjunto
Talib.CDLContraataque ((enPriceOHLC) el año pasado)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLCOUNTERATTACK()La función se describe en la documentación de la biblioteca talib como:CDLCOUNTERATTACK(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLDARKCLOUDCOVER()La función se utiliza para calcularCubierta de nubes oscuras (gráfico de línea K: cubierta de nubes oscuras).
El valor de retorno de latalib.CDLDARKCLOUDCOVER()La función es una matriz unidimensional.
el conjunto
Talib.CDDARKCLOUDCOVER ((en el precio OHLC) Talib.CDLDARKCLOUDCOVER ((en el precio OHLC, optInPenetration)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro se utiliza para establecer la penetración, el valor predeterminado es 0,5.
- ¿ Qué pasa?
falsos
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);
}
ElCDLDARKCLOUDCOVER()La función se describe en la documentación de la biblioteca talib como:CDLDARKCLOUDCOVER(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Eltalib.CDLDOJI()La función se utiliza para calcularDoji (gráfico de líneas K: Doji).
El valor de retorno de latalib.CDLDOJI()La función es: una matriz unidimensional.
el conjunto
Talib.CDLDOJI (en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLDOJI()La función se describe en la documentación de la biblioteca talib como:CDLDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLDOJISTAR()La función se utiliza para calcular elEstrella Doji (gráfico de línea K: Estrella Doji).
El valor de retorno de latalib.CDLDOJISTAR()La función es: una matriz unidimensional.
el conjunto
Talib.CDLDOJISTAR ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLDOJISTAR()La función se describe en la documentación de la biblioteca talib como:CDLDOJISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLDRAGONFLYDOJI()La función se utiliza para calcularDragonfly Doji (gráfico de línea K: Dragonfly Doji).
El valor de retorno de latalib.CDLDRAGONFLYDOJI()La función es: una matriz unidimensional.
el conjunto
Talib.CDLDRAGONFLYDOJI ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLDRAGONFLYDOJI()La función se describe en la documentación de la biblioteca talib como:CDLDRAGONFLYDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLENGULFING()La función se utiliza para calcular elPatrón de engulfing (gráfico de línea K: engulfing).
El valor de retorno de latalib.CDLENGULFING()La función es una matriz unidimensional.
el conjunto
Talib.CDLENGULFING ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLENGULFING()La función se describe en la documentación de la biblioteca talib como:CDLENGULFING(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLEVENINGDOJISTAR()La función se utiliza para calcular elEstrella de la Noche Doji (gráfico de línea K: Estrella de la Noche Doji).
El valor de retorno de latalib.CDLEVENINGDOJISTAR()La función es: una matriz unidimensional.
el conjunto
Talib.CDLEVENINGDOJISTAR ((en el precio de la OLC) Talib.CDLEVENINGDOJISTAR ((enPriceOHLC, optInPenetration) y también en el sitio web de la compañía.
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro se utiliza para establecer la penetración, el valor predeterminado es 0,3.
- ¿ Qué pasa?
falsos
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);
}
ElCDLEVENINGDOJISTAR()La función se describe en la documentación de la biblioteca talib como:CDLEVENINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Eltalib.CDLEVENINGSTAR()La función se utiliza para calcular elEstrella vespertina (gráfico de línea K: Estrella vespertina).
El valor de retorno de latalib.CDLEVENINGSTAR()La función es: una matriz unidimensional.
el conjunto
Talib.CDLEVENINGSTAR ((en el precio de OHLC) Talib.CDLEVENINGSTAR ((enPriceOHLC, optInPenetration) y también en el sitio web de la compañía.
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro se utiliza para establecer la penetración, el valor predeterminado es 0,3.
- ¿ Qué pasa?
falsos
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);
}
ElCDLEVENINGSTAR()La función se describe en la documentación de la biblioteca talib como:CDLEVENINGSTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Eltalib.CDLGAPSIDESIDEWHITE()La función se utiliza para calcularLíneas blancas recíprocas de la brecha ascendente/descendiente (gráfico de líneas K: líneas blancas recíprocas de la brecha ascendente/descendiente).
El valor de retorno de latalib.CDLGAPSIDESIDEWHITE()La función es: una matriz unidimensional.
el conjunto
Talib.CDLGAPSIDESIDEWHITE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLGAPSIDESIDEWHITE()La función se describe en la documentación de la biblioteca talib como:CDLGAPSIDESIDEWHITE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLGRAVESTONEDOJI()La función se utiliza para calcular elGravestone Doji (gráfico de líneas K: Gravestone Doji).
El valor de retorno de latalib.CDLGRAVESTONEDOJI()La función es: una matriz unidimensional.
el conjunto
Talib.CDLGRAVESTONEDOJI ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLGRAVESTONEDOJI()La función se describe en la documentación de la biblioteca talib como:CDLGRAVESTONEDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHAMMER()La función se utiliza para calcularMartillo (gráfico de línea K: Martillo).
El valor de retorno de latalib.CDLHAMMER()La función es: una matriz unidimensional.
el conjunto
Talib.CDLHAMMER ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHAMMER()La función se describe en la documentación de la biblioteca talib como:CDLHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHANGINGMAN()La función se utiliza para calcularHombre colgado (gráfico de línea K: Hombre colgado).
El valor de retorno de latalib.CDLHANGINGMAN()La función es una matriz unidimensional.
el conjunto
Talib.CDLHANGINGMAN ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHANGINGMAN()La función se describe en la documentación de la biblioteca talib como:CDLHANGINGMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHARAMI()La función se utiliza para calcular elPatrón Harami (gráfico de líneas K: líneas negativas y positivas).
El valor de retorno de latalib.CDLHARAMI()La función es una matriz unidimensional.
el conjunto
Talib.CDLHARAMI ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHARAMI()La función se describe en la documentación de la biblioteca talib como:CDLHARAMI(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHARAMICROSS()La función se utiliza para calcular elPatrón cruzado de Harami (gráfico de líneas K: líneas negativas y positivas cruzadas).
El valor de retorno de latalib.CDLHARAMICROSS()La función es: una matriz unidimensional.
el conjunto
Talib.CDLHARAMICROSS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHARAMICROSS()La función se describe en la documentación de la biblioteca talib como:CDLHARAMICROSS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHIGHWAVE()La función se utiliza para calcular elCandela de alta onda (gráfico de línea K: Cruz de piernas largas).
El valor de retorno de latalib.CDLHIGHWAVE()La función es una matriz unidimensional.
el conjunto
Talib.CDLHIGHWAVE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHIGHWAVE()La función se describe en la documentación de la biblioteca talib como:CDLHIGHWAVE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHIKKAKE()La función se utiliza para calcular elPatrón de Hikkake (gráfico de línea K: trampa).
El valor de retorno de latalib.CDLHIKKAKE()La función es una matriz unidimensional.
el conjunto
Talib.CDLHIKKAKE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHIKKAKE()La función se describe en la documentación de la biblioteca talib como:CDLHIKKAKE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHIKKAKEMOD()La función se utiliza para calcular elPatrón de Hikkake modificado (gráfico de línea K: Trampa modificada).
El valor de retorno de latalib.CDLHIKKAKEMOD()La función es: una matriz unidimensional.
el conjunto
Talib.CDLHIKKAKEMOD ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHIKKAKEMOD()La función se describe en la documentación de la biblioteca talib como:CDLHIKKAKEMOD(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLHOMINGPIGEON()La función se utiliza para calcular elPaloma que se desplaza (gráfico de líneas K: Paloma).
El valor de retorno de latalib.CDLHOMINGPIGEON()La función es: una matriz unidimensional.
el conjunto
Talib.CDLHOMINGPIGEON ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLHOMINGPIGEON()La función se describe en la documentación de la biblioteca talib como:CDLHOMINGPIGEON(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLIDENTICAL3CROWS()La función se utiliza para calcularTres cuervos idénticos (gráfico de línea K: tres cuervos iguales).
El valor de retorno de latalib.CDLIDENTICAL3CROWS()La función es: una matriz unidimensional.
el conjunto
Talib.CDLIDENTICAL3CROWS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLIDENTICAL3CROWS()La función se describe en la documentación de la biblioteca talib como:CDLIDENTICAL3CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLINNECK()La función se utiliza para calcular elPatrón en el cuello (gráfico de línea K: escote).
El valor de retorno de latalib.CDLINNECK()La función es: una matriz unidimensional.
el conjunto
Talib.CDLINNECK ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLINNECK()La función se describe en la documentación de la biblioteca talib como:CDLINNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLINVERTEDHAMMER()La función se utiliza para calcular elMartillo invertido (gráfico de línea K: Martillo invertido).
El valor de retorno de latalib.CDLINVERTEDHAMMER()La función es: una matriz unidimensional.
el conjunto
Talib.CDLINVERTEDHAMMER ((en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLINVERTEDHAMMER()La función se describe en la documentación de la biblioteca talib como:CDLINVERTEDHAMMER(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLKICKING()La función se utiliza para calcularPulsando (gráfico de línea K: pateando).
El valor de retorno de latalib.CDLKICKING()La función es una matriz unidimensional.
el conjunto
Talib.CDLKICKING ((enPriceOHLC) el precio de las cosas
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLKICKING()La función se describe en la documentación de la biblioteca talib como:CDLKICKING(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLKICKINGBYLENGTH()La función se utiliza para calcular elpatada - toro/oso determinado por el Marubozu más largo (gráfico de línea K: toro/oso patada).
El valor de retorno de latalib.CDLKICKINGBYLENGTH()La función es: una matriz unidimensional.
el conjunto
Talib.CDLKICKINGBYLENGTH ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLKICKINGBYLENGTH()La función se describe en la documentación de la biblioteca talib como:CDLKICKINGBYLENGTH(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLLADDERBOTTOM()La función se utiliza para calcular elBajo de la escalera (gráfico de línea K: Bajo de la escalera).
El valor de retorno de latalib.CDLLADDERBOTTOM()La función es: una matriz unidimensional.
el conjunto
Talib.CDLLADDERBOTTOM ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLLADDERBOTTOM()La función se describe en la documentación de la biblioteca talib como:CDLLADDERBOTTOM(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLLONGLEGGEDDOJI()La función se utiliza para calcular elDoji de patas largas (gráfico de línea K: Doji de patas largas).
El valor de retorno de latalib.CDLLONGLEGGEDDOJI()La función es: una matriz unidimensional.
el conjunto
Talib.CDLLONGLEGGEDDOJI (en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLLONGLEGGEDDOJI()La función se describe en la documentación de la biblioteca talib como:CDLLONGLEGGEDDOJI(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLLONGLINE()La función se utiliza para calcular elCandela de línea larga (gráfico de línea K: línea larga).
El valor de retorno de latalib.CDLLONGLINE()La función es: una matriz unidimensional.
el conjunto
Talib.CDLLONGLINE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLLONGLINE()La función se describe en la documentación de la biblioteca talib como:CDLLONGLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLMARUBOZU()La función se utiliza para calcular elMarubozu (gráfico de línea K: cabeza y pie desnudos).
El valor de retorno de latalib.CDLMARUBOZU()La función es una matriz unidimensional.
el conjunto
Talib.CDLMARUBOZU ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLMARUBOZU()La función se describe en la documentación de la biblioteca talib como:CDLMARUBOZU(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLMATCHINGLOW()La función se utiliza para calcularBajo de coincidencia (gráfico de líneas K: Bajo de coincidencia).
El valor de retorno de latalib.CDLMATCHINGLOW()La función es: una matriz unidimensional.
el conjunto
Talib.CDLMATCHINGLOW ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLMATCHINGLOW()La función se describe en la documentación de la biblioteca talib como:CDLMATCHINGLOW(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLMATHOLD()La función se utiliza para calcularMantener el tapete (gráfico de línea K: Mantener el tapete).
El valor de retorno de latalib.CDLMATHOLD()La función es: una matriz unidimensional.
el conjunto
Talib.CDLMATHOLD ((en el precio OHLC) Talib.CDLMATHOLD ((inPriceOHLC, optInPenetration) y el nombre de la página web de la empresa.
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro es opcional y se utiliza para especificar el porcentaje del ancho de la línea de tendencia ascendente/abajante, el valor predeterminado es 0,5.
- ¿ Qué pasa?
falsos
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);
}
ElCDLMATHOLD()La función se describe en la documentación de la biblioteca talib como:CDLMATHOLD(Records[Open,High,Low,Close],Penetration = 0.5) = Array(outInteger)
Eltalib.CDLMORNINGDOJISTAR()La función se utiliza para calcular elEstrella del Doji de la mañana (gráfico de línea K: Estrella del Doji de la mañana).
El valor de retorno de latalib.CDLMORNINGDOJISTAR()La función es: una matriz unidimensional.
el conjunto
Talib.CDLMORNINGDOJISTAR (en el precio de OHLC) Talib.CDLMORNINGDOJISTAR ((enPriceOHLC, optInPenetration) (en inglés y en inglés)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro se utiliza para especificar el grado de superposición entre el precio de apertura de la validación y la parte sólida, el valor predeterminado es 0,3.
- ¿ Qué pasa?
falsos
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);
}
ElCDLMORNINGDOJISTAR()La función se describe en la documentación de la biblioteca talib como:CDLMORNINGDOJISTAR(Records[Open,High,Low,Close],Penetration = 0.3) = Array(outInteger)
Eltalib.CDLMORNINGSTAR()La función se utiliza para calcularEstrella de la mañana (gráfico de línea K: Estrella de la mañana).
El valor de retorno de latalib.CDLMORNINGSTAR()La función es: una matriz unidimensional.
el conjunto
Talib.CDLMORNINGSTAR ((en el precio OHLC) Talib.CDLMORNINGSTAR ((enPriceOHLC, optInPenetration) y también en el sitio web de la compañía.
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInPenetrationel parámetro es el umbral del porcentaje de fluctuación de precios requerido para la confirmación de la tendencia y toma un valor en el intervalo [0,1], con un valor predeterminado de 0,3.
- ¿ Qué pasa?
falsos
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);
}
ElCDLMORNINGSTAR()La función se describe en la documentación de la biblioteca talib como:CDLMORNINGSTAR(Records[Open,High,Low,Close],Penetration=0.3) = Array(outInteger)
Eltalib.CDLONNECK()La función se utiliza para calcular elPatrón en el cuello (gráfico de línea K: Patrón en el cuello).
El valor de retorno de latalib.CDLONNECK()La función es una matriz unidimensional.
el conjunto
Talib.CDLONNECK ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLONNECK()La función se describe en la documentación de la biblioteca talib como:CDLONNECK(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLPIERCING()La función se utiliza para calcular elPatrón de perforación (gráfico de línea K: Patrón de perforación).
El valor de retorno de latalib.CDLPIERCING()La función es una matriz unidimensional.
el conjunto
Talib.CDLPIERCING ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLPIERCING()La función se describe en la documentación de la biblioteca talib como:CDLPIERCING(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLRICKSHAWMAN()La función se utiliza para calcularHombre de Rickshaw (gráfico de línea K: Hombre de Rickshaw).
El valor de retorno de latalib.CDLRICKSHAWMAN()La función es: una matriz unidimensional.
el conjunto
Talib.CDLRICKSHAWMAN ((en el precio de OHLC)
ElinPriceOHLCel parámetro se utiliza para especificar los datos de línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLRICKSHAWMAN()La función se describe en la documentación de la biblioteca talib como:CDLRICKSHAWMAN(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLRISEFALL3METHODS()La función se utiliza para calcularTres métodos de subida/baja (gráfico de líneas K: tres métodos de subida/baja).
El valor de retorno de latalib.CDLRISEFALL3METHODS()La función es: una matriz unidimensional.
el conjunto
Talib.CDLRISEFALL3METHODS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLRISEFALL3METHODS()La función se describe en la documentación de la biblioteca talib como:CDLRISEFALL3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLSEPARATINGLINES()La función se utiliza para calcularLíneas de separación (gráfico de K-línea: Líneas de separación).
El valor de retorno de latalib.CDLSEPARATINGLINES()La función es una matriz unidimensional.
el conjunto
Talib.CDLSEPARATINGLINES (en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLSEPARATINGLINES()La función se describe en la documentación de la biblioteca talib como:CDLSEPARATINGLINES(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLSHOOTINGSTAR()La función se utiliza para calcular elEstrella Fuego (gráfico de línea K: Estrella Fuego).
El valor de retorno de latalib.CDLSHOOTINGSTAR()La función es una matriz unidimensional.
el conjunto
Talib.CDLSHOOTINGSTAR ((en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLSHOOTINGSTAR()La función se describe en la documentación de la biblioteca talib como:CDLSHOOTINGSTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLSHORTLINE()La función se utiliza para calcular elCandela de línea corta (gráfico de línea K: línea corta).
El valor de retorno de latalib.CDLSHORTLINE()La función es: una matriz unidimensional.
el conjunto
Talib.CDLSSORTLINE ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLSHORTLINE()La función se describe en la documentación de la biblioteca talib como:CDLSHORTLINE(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLSPINNINGTOP()La función se utiliza para calcularSpinning Top (gráfico de líneas en K: Spinning Top).
El valor de retorno de latalib.CDLSPINNINGTOP()La función es: una matriz unidimensional.
el conjunto
Talib.CDLSPINNINGTOP ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLSPINNINGTOP()La función se describe en la documentación de la biblioteca talib como:CDLSPINNINGTOP(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLSTALLEDPATTERN()La función se utiliza para calcularPatrón estancado (gráfico de línea K: Patrón estancado).
El valor de retorno de latalib.CDLSTALLEDPATTERN()La función es: una matriz unidimensional.
el conjunto
Talib.CDLSTALLEDPATTERN ((enPriceOHLC) el nombre de la página donde se encuentra el código
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLSTALLEDPATTERN()La función se describe en la documentación de la biblioteca talib como:CDLSTALLEDPATTERN(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLSTICKSANDWICH()La función se utiliza para calcular elSándwich del palo (gráfico de línea K: Sándwich del palo).
El valor de retorno de latalib.CDLSTICKSANDWICH()La función es una matriz unidimensional.
el conjunto
Talib.CDLSTIKSANDWICH ((enPriceOHLC) el nombre de la película es el mismo que el nombre de la película
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLSTICKSANDWICH()La función se describe en la documentación de la biblioteca talib como:CDLSTICKSANDWICH(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLTAKURI()La función se utiliza para calcularTakuri (doji de la mosca dragón con una línea de sombra inferior muy larga) (gráfico de líneas en K: Takuri).
El valor de retorno de latalib.CDLTAKURI()La función es una matriz unidimensional.
el conjunto
Talib.CDLTAKURI ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLTAKURI()La función se describe en la documentación de la biblioteca talib como:CDLTAKURI(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLTASUKIGAP()La función se utiliza para calcular elLa brecha de Tasuki (gráfico de línea K: Brecha de Tasuki).
El valor de retorno de latalib.CDLTASUKIGAP()La función es una matriz unidimensional.
el conjunto
Talib.CDLTASUKIGAP ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLTASUKIGAP()La función se describe en la documentación de la biblioteca talib como:CDLTASUKIGAP(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLTHRUSTING()La función se utiliza para calcular elPatrón de empuje (gráfico de línea K: Patrón de empuje).
El valor de retorno de latalib.CDLTHRUSTING()La función es: una matriz unidimensional.
el conjunto
Talib.CDLTHRUSTING ((enPriceOHLC) el nombre de la compañía en la que trabaja
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLTHRUSTING()La función se describe en la documentación de la biblioteca talib como:CDLTHRUSTING(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLTRISTAR()La función se utiliza para calcular elPatrón Tristar (gráfico de línea K: Patrón Tristar).
El valor de retorno de latalib.CDLTRISTAR()La función es: una matriz unidimensional.
el conjunto
Talib.CDLTRISTAR ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLTRISTAR()La función se describe en la documentación de la biblioteca talib como:CDLTRISTAR(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLUNIQUE3RIVER()La función se utiliza para calcular elUnique 3 River (gráfico de línea K: Unique 3 River).
El valor de retorno de latalib.CDLUNIQUE3RIVER()La función es: una matriz unidimensional.
el conjunto
Talib.CDLUNIQUE3RIVER ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLUNIQUE3RIVER()La función se describe en la documentación de la biblioteca talib como:CDLUNIQUE3RIVER(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLUPSIDEGAP2CROWS()La función se utiliza para calcularDesfase al alza dos cuervos (gráfico de línea K: Desfase al alza dos cuervos).
El valor de retorno de latalib.CDLUPSIDEGAP2CROWS()La función es: una matriz unidimensional.
el conjunto
Talib.CDLUPSIDEGAP2CROWS ((en el precio de OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLUPSIDEGAP2CROWS()La función se describe en la documentación de la biblioteca talib como:CDLUPSIDEGAP2CROWS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.CDLXSIDEGAP3METHODS()La función se utiliza para calcularTres métodos para la diferencia al alza/a la baja (gráfico de líneas K: Tres métodos para la diferencia al alza/a la baja).
El valor de retorno de latalib.CDLXSIDEGAP3METHODS()La función es: una matriz unidimensional.
el conjunto
Talib.CDLXSIDEGAP3METHODS ((en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElCDLXSIDEGAP3METHODS()La función se describe en la documentación de la biblioteca talib como:CDLXSIDEGAP3METHODS(Records[Open,High,Low,Close]) = Array(outInteger)
Eltalib.AD()La función se utiliza para calcular elLínea A/D de Chaikin (indicador estocástico de línea).
El valor de retorno de latalib.AD()La función es: una matriz unidimensional.
el conjunto
talib.AD(en el precio HLCV)
ElinPriceHLCVse utiliza para especificar los datos de la línea K.
enPriceHLCV
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElAD()La función se describe en la documentación de la biblioteca talib como:AD(Records[High,Low,Close,Volume]) = Array(outReal)
Eltalib.ADOSC()La función se utiliza para calcular elLos valores de las emisiones de gases de efecto invernadero y de gases de efecto invernadero se calcularán en función de los valores de las emisiones de gases de efecto invernadero y de las emisiones de gases de efecto invernadero..
El valor de retorno de latalib.ADOSC()La función es una matriz unidimensional.
el conjunto
Talib.ADOSC ((en el precioHLCV) Talib.ADOSC ((enPriceHLCV, optInFastPeriod, optInSlowPeriod) el precio de los productos en el mercado
ElinPriceHLCVse utiliza para especificar los datos de la línea K.
enPriceHLCV
verdadero
{@struct/Record Record} matriz de estructuras
EloptInFastPeriodEl parámetro se utiliza para establecer el período rápido.
Seleccionar el período de tiempo más rápido
falsos
Número
EloptInSlowPeriodel parámetro se utiliza para establecer el período lento.
optInSlowPeriod (en inglés)
falsos
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);
}
ElADOSC()La función se describe en la documentación de la biblioteca talib como:ADOSC(Records[High,Low,Close,Volume],Fast Period = 3,Slow Period = 10) = Array(outReal)
Eltalib.OBV()La función se utiliza para calcularSobre el volumen del balance (marea de energía).
El valor de retorno de latalib.OBV()La función es una matriz unidimensional.
el conjunto
Talib.OBV ((inReal) Talib.OBV ((enReal, enPriceV)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
ElinPriceVse utiliza para especificar los datos de la línea K.
enPriceV
falsos
{@struct/Record Record} matriz de estructuras
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);
}
ElOBV()La función se describe en la documentación de la biblioteca talib como:OBV(Records[Close],Records[Volume]) = Array(outReal)
Eltalib.ACOS()La función se utiliza para calcularVector trigonométrico ACos (función inversa del coseno).
El valor de retorno de latalib.ACOS()La función es una matriz unidimensional.
el conjunto
Talib.ACOS ((enReal)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElACOS()La función se describe en la documentación de la biblioteca talib como:ACOS(Records[Close]) = Array(outReal)
Eltalib.ASIN()La función se utiliza para calcular elAsin trigonométrico vectorial (función seno inversa).
El valor de retorno de latalib.ASIN()La función es una matriz unidimensional.
el conjunto
Talib.ASIN ((InReal)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElASIN()La función se describe en la documentación de la biblioteca talib como:ASIN(Records[Close]) = Array(outReal)
Eltalib.ATAN()La función se utiliza para calcular elVector trigonométrico ATan (función de tangente inversa).
El valor de retorno de latalib.ATAN()La función es: una matriz unidimensional.
el conjunto
Talib.ATAN (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElATAN()La función se describe en la documentación de la biblioteca talib como:ATAN(Records[Close]) = Array(outReal)
Eltalib.CEIL()La función se utiliza para calcularCubierto vectorial (función de redondeo).
El valor de retorno de latalib.CEIL()La función es una matriz unidimensional.
el conjunto
Talib.CEIL (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElCEIL()La función se describe en la documentación de la biblioteca talib como:CEIL(Records[Close]) = Array(outReal)
Eltalib.COS()La función se utiliza para calcular elVector trigonométrico Cos (función coseno).
El valor de retorno de latalib.COS()La función es: una matriz unidimensional.
el conjunto
Talib.COS (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElCOS()La función se describe en la documentación de la biblioteca talib como:COS(Records[Close]) = Array(outReal)
Eltalib.COSH()La función se utiliza para calcularCosh trigonométrico vectorial (valor del coseno hiperbólico).
El valor de retorno de latalib.COSH()La función es una matriz unidimensional.
el conjunto
Talib.COSH (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElCOSH()La función se describe en la documentación de la biblioteca talib como:COSH(Records[Close]) = Array(outReal)
Eltalib.EXP()La función se utiliza para calcular elAritmética vectorial Exp (función exponencial).
El valor de retorno de latalib.EXP()La función es: una matriz unidimensional.
el conjunto
Talib.EXP (en verdad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElEXP()La función se describe en la documentación de la biblioteca talib como:EXP(Records[Close]) = Array(outReal)
Eltalib.FLOOR()La función se utiliza para calcular elBajo del vector (redondeado a la baja).
El valor de retorno de latalib.FLOOR()La función es una matriz unidimensional.
el conjunto
Talib.FLOOR (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElFLOOR()La función se describe en la documentación de la biblioteca talib como:FLOOR(Records[Close]) = Array(outReal)
Eltalib.LN()La función se utiliza para calcular elVector Log Natural (logaritmo natural).
El valor de retorno de latalib.LN()La función es una matriz unidimensional.
el conjunto
Talib.LN ((inReal)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElLN()La función se describe en la documentación de la biblioteca talib como:LN(Records[Close]) = Array(outReal)
Eltalib.LOG10()La función se utiliza para calcularVector Log10 (función logarítmica).
El valor de retorno de latalib.LOG10()La función es una matriz unidimensional.
el conjunto
Talib.LOG10 ((inReal)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElLOG10()La función se describe en la documentación de la biblioteca talib como:LOG10(Records[Close]) = Array(outReal)
Eltalib.SIN()La función se utiliza para calcularVector trigonométrico Sin (valor seno).
El valor de retorno de latalib.SIN()La función es una matriz unidimensional.
el conjunto
Talib.SIN (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElSIN()La función se describe en la documentación de la biblioteca talib como:SIN(Records[Close]) = Array(outReal)
Eltalib.SINH()La función se utiliza para calcular elVector Trigonométrico Sin (función seno hiperbólica).
El valor de retorno de latalib.SINH()La función es: una matriz unidimensional.
el conjunto
Talib.SINH (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElSINH()La función se describe en la documentación de la biblioteca talib como:SINH(Records[Close]) = Array(outReal)
Eltalib.SQRT()La función se utiliza para calcular elVector Raíz cuadrada (raíz cuadrada).
El valor de retorno de latalib.SQRT()La función es: una matriz unidimensional.
el conjunto
Talib.SQRT (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElSQRT()La función se describe en la documentación de la biblioteca talib como:SQRT(Records[Close]) = Array(outReal)
Eltalib.TAN()La función se utiliza para calcular elVector Trigonométrico Tan (tangente).
El valor de retorno de latalib.TAN()La función es una matriz unidimensional.
el conjunto
Talib.TAN (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElTAN()La función se describe en la documentación de la biblioteca talib como:TAN(Records[Close]) = Array(outReal)
Eltalib.TANH()La función se utiliza para calcular elTrigonometría vectorial Tanh (función de tangente hiperbólica).
El valor de retorno de latalib.TANH()La función es: una matriz unidimensional.
el conjunto
Talib.TANH (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElTANH()La función se describe en la documentación de la biblioteca talib como:TANH(Records[Close]) = Array(outReal)
Eltalib.MAX()La función se utiliza para calcular el valor más alto (máximo) para unperíodo específico.
El valor de retorno de latalib.MAX()La función es: una matriz unidimensional.
el conjunto
Talib.MAX (en realidad) Talib.MAX ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElMAX()La función se describe en la documentación de la biblioteca talib como:MAX(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.MAXINDEX()La función se utiliza para calcularel índice del valor más alto en el período especificado (índice máximo).
El valor de retorno de latalib.MAXINDEX()La función es: una matriz unidimensional.
el conjunto
Talib.MAXINDEX ((inReal) es el nombre de una de las compañías de televisión más grandes del mundo. Talib.MAXINDEX ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElMAXINDEX()La función se describe en la documentación de la biblioteca talib como:MAXINDEX(Records[Close],Time Period = 30) = Array(outInteger)
Eltalib.MIN()La función se utiliza para calcular el valor más bajo (valor mínimo)** para el período especificado.
El valor de retorno de latalib.MIN()La función es: una matriz unidimensional.
el conjunto
Talib.MIN ((enReal) Talib.MIN ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElMIN()La función se describe en la documentación de la biblioteca talib como:MIN(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.MININDEX()La función se utiliza para calcularel índice de valor más bajo (índice de valor mínimo)durante el período especificado.
El valor de retorno de latalib.MININDEX()La función es: una matriz unidimensional.
el conjunto
Talib.MININDEX ((inReal) es el nombre de una de las compañías de televisión más grandes del mundo. Talib.MININDEX ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElMININDEX()La función se describe en la documentación de la biblioteca talib como:MININDEX(Records[Close],Time Period = 30) = Array(outInteger)
Eltalib.MINMAX()La función se utiliza para calcularlos valores más bajos y más altos (mínimo y máximo) para el período especificado.
El valor de retorno de latalib.MINMAX()El primer elemento de esta matriz bidimensional es la matriz de valores mínimos, y el segundo elemento es la matriz de valores máximos.
el conjunto
Talib.MINMAX ((InReal) Talib.MINMAX ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElMINMAX()La función se describe en la documentación de la biblioteca talib como:MINMAX(Records[Close],Time Period = 30) = [Array(outMin),Array(outMax)]
Eltalib.MINMAXINDEX()La función se utiliza para calcularel índice de los valores más bajos y más altos (índice mínimo y máximo) en el período especificado.
El valor de retorno de latalib.MINMAXINDEX()El primer elemento de esta matriz bidimensional es la matriz indexada mínima, y el segundo elemento es la matriz indexada máxima.
el conjunto
Talib.MINMAXINDEX ((inReal) es el nombre de una de las dos compañías de la compañía. Talib.MINMAXINDEX ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElMINMAXINDEX()La función se describe en la documentación de la biblioteca talib como:MINMAXINDEX(Records[Close],Time Period = 30) = [Array(outMinIdx),Array(outMaxIdx)]
Eltalib.SUM()La función se utiliza para calcularResumen.
El valor de retorno de latalib.SUM()La función es: una matriz unidimensional.
el conjunto
Talib.SUM (en realidad) Talib.SUM ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElSUM()La función se describe en la documentación de la biblioteca talib como:SUM(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.HT_DCPERIOD()La función se utiliza para calcular elTransformación de Hilbert - período de ciclo dominante (transformación de Hilbert, período dominante).
El valor de retorno de latalib.HT_DCPERIOD()La función es: una matriz unidimensional.
el conjunto
Talib.HT_DCPERIOD ((inReal) es el nombre de un grupo de personas que trabajan en la industria de la información.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElHT_DCPERIOD()La función se describe en la documentación de la biblioteca talib como:HT_DCPERIOD(Records[Close]) = Array(outReal)
Eltalib.HT_DCPHASE()La función se utiliza para calcular elTransformación de Hilbert - Fase del ciclo dominante (Transformación de Hilbert, fase del ciclo dominante).
El valor de retorno de latalib.HT_DCPHASE()La función es: una matriz unidimensional.
el conjunto
Talib.HT_DCPHASE ((en verdad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElHT_DCPHASE()La función se describe en la documentación de la biblioteca talib como:HT_DCPHASE(Records[Close]) = Array(outReal)
Eltalib.HT_PHASOR()La función se utiliza para calcular elTransformación de Hilbert - Componentes del fasor (transformación de Hilbert, componentes de fase).
El valor de retorno de latalib.HT_PHASOR()La función es una matriz bidimensional.
el conjunto
Talib.HT_PHASOR (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElHT_PHASOR()La función se describe en la documentación de la biblioteca talib como:HT_PHASOR(Records[Close]) = [Array(outInPhase),Array(outQuadrature)]
Eltalib.HT_SINE()La función se utiliza para calcular elTransformación de Hilbert - Onda senoidal (Transformación de Hilbert, onda senoidal).
El valor de retorno de latalib.HT_SINE()La función es: una matriz bidimensional.
el conjunto
Talib.HT_SINE (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElHT_SINE()La función se describe en la documentación de la biblioteca talib como:HT_SINE(Records[Close]) = [Array(outSine),Array(outLeadSine)]
Eltalib.HT_TRENDMODE()La función se utiliza para calcular elTransformación de Hilbert - Tendencia y modo de ciclo.
El valor de retorno de latalib.HT_TRENDMODE()La función es: una matriz unidimensional.
el conjunto
Talib.HT_TRENDMODE (en realidad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElHT_TRENDMODE()La función se describe en la documentación de la biblioteca talib como:HT_TRENDMODE(Records[Close]) = Array(outInteger)
Eltalib.ATR()La función se utiliza para calcular elRango verdadero medio.
El valor de retorno de latalib.ATR()La función es una matriz unidimensional.
el conjunto
Talib.ATR (en el precio de HLC) Talib.ATR ((en el precioHLC, optInTimePeriod)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElATR()La función se describe en la documentación de la biblioteca talib como:ATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.NATR()La función se utiliza para calcular elRango verdadero promedio normalizado.
El valor de retorno de latalib.NATR()La función es una matriz unidimensional.
el conjunto
Talib.NATR ((en el precioHLC) Talib.NATR ((en el precioHLC, optInTimePeriod)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElNATR()La función se describe en la documentación de la biblioteca talib como:NATR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.TRANGE()La función se utiliza para calcular elRango verdadero.
El valor de retorno de latalib.TRANGE()La función es: una matriz unidimensional.
el conjunto
Talib.TRANGE ((enPriceHLC) es el nombre de una de las compañías de la compañía.
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElTRANGE()La función se describe en la documentación de la biblioteca talib como:TRANGE(Records[High,Low,Close]) = Array(outReal)
Eltalib.BBANDS()La función se utiliza para calcularLas bandas de Bollinger.
El valor de retorno de latalib.BBANDS()La función es: una matriz bidimensional. La matriz contiene tres elementos que son: la matriz de línea superior, la matriz de línea media y la matriz de línea inferior.
el conjunto
Talib.BBANDS (en realidad) Talib.BBANDS ((en tiempo real, optInTimePeriod) Talib.BBANDS ((en realidad, optInTimePeriod, optInNbDevUp) Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn) El tiempo de tiempo en el que el usuario puede acceder a la información es de un año. Talib.BBANDS ((inReal, optInTimePeriod, optInNbDevUp, optInNbDevDn, optInMAType) El tipo de código es el siguiente:
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 5.
OptInTimePeriodo
falsos
Número
EloptInNbDevUpEl parámetro se utiliza para establecer el multiplicador de línea ascendente, el valor predeterminado es 2.
OptiNbDevUp
falsos
Número
EloptInNbDevDnel parámetro se utiliza para establecer el multiplicador de la línea inferior, el valor predeterminado es 2.
- ¿ Qué pasa?
falsos
Número
EloptInMATypeel parámetro se utiliza para establecer el tipo medio, el valor predeterminado es 0.
Seleccionar el tipo
falsos
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);
}
ElBBANDS()La función se describe en la documentación de la biblioteca talib como:BBANDS(Records[Close],Time Period = 5,Deviations up = 2,Deviations down = 2,MA Type = 0) = [Array(outRealUpperBand),Array(outRealMiddleBand),Array(outRealLowerBand)]
Eltalib.DEMA()La función se utiliza para calcular elPromedio móvil exponencial doble.
El valor de retorno de latalib.DEMA()La función es una matriz unidimensional.
el conjunto
Talib.DEMA ((enReal) Talib.DEMA (en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElDEMA()La función se describe en la documentación de la biblioteca talib como:DEMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.EMA()La función se utiliza para calcular elPromedio móvil exponencial.
El valor de retorno de latalib.EMA()La función es una matriz unidimensional.
el conjunto
Talib.EMA ((enReal) Talib.EMA ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElEMA()La función se describe en la documentación de la biblioteca talib como:EMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.HT_TRENDLINE()La función se utiliza para calcular elTransformación de Hilbert - Línea de tendencia instantánea.
El valor de retorno de latalib.HT_TRENDLINE()La función es: una matriz unidimensional.
el conjunto
Talib.HT_TRENDLINE ((en verdad)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices 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);
}
ElHT_TRENDLINE()La función se describe en la documentación de la biblioteca talib como:HT_TRENDLINE(Records[Close]) = Array(outReal)
Eltalib.KAMA()La función se utiliza para calcular elPromedio móvil adaptativo de Kaufman.
El valor de retorno de latalib.KAMA()La función es: una matriz unidimensional.
el conjunto
Talib.KAMA (en realidad) Talib.KAMA (en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElKAMA()La función se describe en la documentación de la biblioteca talib como:KAMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.MA()La función se utiliza para calcular elPromedio móvil.
El valor de retorno de latalib.MA()La función es: una matriz unidimensional.
el conjunto
talib.MA(InReal)talib.MA(inReal, optInTimePeriod) El valor de las acciones de la entidad es el valor de las acciones de la entidad.talib.MA(inReal, optInTimePeriod, optInMAType) El tipo de información que se puede obtener es el siguiente:
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
Número
EloptInMATypeel parámetro se utiliza para establecer el tipo medio, el valor predeterminado es 0.
Seleccionar el tipo
falsos
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);
}
ElMA()La función se describe en la documentación de la biblioteca talib como:MA(Records[Close],Time Period = 30,MA Type = 0) = Array(outReal)
Eltalib.MAMA()La función se utiliza para calcular elMediana móvil adaptativa de MESA.
El valor de retorno de latalib.MAMA()La función es: una matriz bidimensional.
el conjunto
Talib.MAMA (en realidad) Talib.MAMA ((InReal, optInFastLimit) (en inglés) Talib.MAMA ((inReal, optInFastLimit, optInSlowLimit) Es el nombre de una de las películas de la serie.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInFastLimitel parámetro se utiliza para establecer el límite rápido, el valor predeterminado es 0,5.
¿ Qué es esto?
falsos
Número
EloptInSlowLimitel parámetro se utiliza para establecer el límite lento, el valor predeterminado es 0,05.
Seleccionar el límite
falsos
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);
}
ElMAMA()La función se describe en la documentación de la biblioteca talib como:MAMA(Records[Close],Fast Limit = 0.5,Slow Limit = 0.05) = [Array(outMAMA),Array(outFAMA)]
Eltalib.MIDPOINT()La función se utiliza para calcular elPunto medio del período (punto medio).
El valor de retorno de latalib.MIDPOINT()La función es una matriz unidimensional.
el conjunto
Talib.MIDPOINT (en realidad) Talib.MIDPOINT ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElMIDPOINT()La función se describe en la documentación de la biblioteca talib como:MIDPOINT(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.MIDPRICE()La función se utiliza para calcular elPrecio del punto medio durante el período (precio del punto medio).
El valor de retorno de latalib.MIDPRICE()La función es una matriz unidimensional.
el conjunto
Talib.MIDPRICE ((en el precioHL) Talib.MIDPRICE ((en el precioHL, optInTimePeriod)
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElMIDPRICE()La función se describe en la documentación de la biblioteca talib como:MIDPRICE(Records[High,Low],Time Period = 14) = Array(outReal)
Eltalib.SAR()La función se utiliza para calcular elSAR parabólico.
El valor de retorno de latalib.SAR()La función es: una matriz unidimensional.
el conjunto
Talib.SAR ((en el precioHL) Talib.SAR ((en PrecioHL, optIn Aceleración) Talib.SAR ((inPriceHL, optInAcceleration, optInMaximum) es el nombre que se le da a las personas que se encuentran en el centro de la ciudad.
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInAccelerationel parámetro se utiliza para establecer el factor de aceleración, el valor predeterminado es 0,02.
Opción de aceleración
falsos
Número
EloptInMaximumel parámetro se utiliza para establecer el máximo de AF, el valor predeterminado es 0,2.
OptiInMaximum
falsos
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);
}
ElSAR()La función se describe en la documentación de la biblioteca talib como:SAR(Records[High,Low],Acceleration Factor = 0.02,AF Maximum = 0.2) = Array(outReal)
Eltalib.SAREXT()La función se utiliza para calcular elParabólico SAR - Extendido (dirección parabólica mejorada).
El valor de retorno de latalib.SAREXT()La función es una matriz unidimensional.
el conjunto
Talib.SAREXT ((en el precio deHL) Talib.SAREXT ((inPriceHL, optInStartValue) es el nombre de la página web donde se encuentra el código. Talib.SAREXT ((enPriceHL, optInStartValue, optInOffsetOnReverse) y el valor de las acciones de la empresa en el mercado. Talib.SAREXT ((en el precioHL, optInStartValue, optInOffsetOnReverse, optInaceleraciónEnItLong) Talib.SAREXT ((en el precioHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong) Talib.SAREXT ((enPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong) El valor de la velocidad es el valor máximo de la velocidad en la que se puede obtener la velocidad máxima. talib.SAREXT ((enPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort) El valor de la velocidad es el valor de la velocidad en la que el motor está en movimiento. Talib.SAREXT ((enPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort) El valor de la velocidad de un motor es el valor de la velocidad de un motor. talib.SAREXT ((enPriceHL, optInStartValue, optInOffsetOnReverse, optInAccelerationInitLong, optInAccelerationLong, optInAccelerationMaxLong, optInAccelerationInitShort, optInAccelerationShort, optInAccelerationMaxShort) El valor de la velocidad de un vehículo es el mismo que el valor de la velocidad de un vehículo.
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInStartValueParámetro se utiliza para establecer el valor de inicio, el valor predeterminado es 0.
Seleccionar valor de inicio
falsos
Número
EloptInOffsetOnReverseel parámetro se utiliza para establecer Offset en Reverso, el valor predeterminado es 0.
OptInOffsetOnReverse es el número de vez que se ejecuta
falsos
Número
EloptInAccelerationInitLongel parámetro se utiliza para establecer el AF Init Long, el valor predeterminado es 0,02.
Opción de aceleración en el largo
falsos
Número
EloptInAccelerationLongel parámetro se utiliza para establecer el AF Long, el valor predeterminado es 0,02.
Opción de aceleración
falsos
Número
EloptInAccelerationMaxLongel parámetro se utiliza para establecer el AF Max Long, el valor predeterminado es 0.2.
Seleccionar AceleraciónMaxLong
falsos
Número
EloptInAccelerationInitShortel parámetro se utiliza para establecer AF Init Short, el valor predeterminado es 0.02.
Opción de aceleración en corto.
falsos
Número
EloptInAccelerationShortel parámetro se utiliza para establecer AF corto, el valor predeterminado es 0.02.
OptiInAccelerationCorto
falsos
Número
EloptInAccelerationMaxShortel parámetro se utiliza para configurar AF Max Short, el valor predeterminado es 0.2.
OptiInAccelerationMaxShort (Convertir en Aceleración Máxima y Corto)
falsos
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);
}
ElSAREXT()La función se describe en la documentación de la 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)
Eltalib.SMA()La función se utiliza para calcularPromedio móvil simple.
El valor de retorno de latalib.SMA()La función es: una matriz unidimensional.
el conjunto
Talib.SMA ((enReal) Talib.SMA ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElSMA()La función se describe en la documentación de la biblioteca talib como:SMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.T3()La función se utiliza para calcular elLa media móvil exponencial triple (T3) (media móvil exponencial triple).
El valor de retorno de latalib.T3()La función es una matriz unidimensional.
el conjunto
Talib.T3 ((InReal) Talib.T3 ((inReal, optInTimePeriod) el tiempo de tiempo en el que se produce el cambio. Talib.T3 ((inReal, optInTimePeriod, optInVFactor) el tiempo de tiempo en el que se ha producido el fallo.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 5.
OptInTimePeriodo
falsos
Número
EloptInVFactorel parámetro se utiliza para establecer el factor de volumen, el valor predeterminado es 0,7.
El factor optInV
falsos
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);
}
ElT3()La función se describe en la documentación de la biblioteca talib como:T3(Records[Close],Time Period = 5,Volume Factor = 0.7) = Array(outReal)
Eltalib.TEMA()La función se utiliza para calcularPromedio móvil exponencial triple.
El valor de retorno de latalib.TEMA()La función es una matriz unidimensional.
el conjunto
Talib.TEMA (en realidad) Talib.TEMA ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElTEMA()La función se describe en la documentación de la biblioteca talib como:TEMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.TRIMA()La función se utiliza para calcular elPromedio móvil triangular (promedio móvil triexponencial).
El valor de retorno de latalib.TRIMA()La función es una matriz unidimensional.
el conjunto
Talib.TRIMA (en realidad) Talib.TRIMA (en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElTRIMA()La función se describe en la documentación de la biblioteca talib como:TRIMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.WMA()La función se utiliza para calcular elLa media móvil ponderada (WMA).
El valor de retorno de latalib.WMA()La función es una matriz unidimensional.
el conjunto
Talib.WMA ((inReal) Talib.WMA ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElWMA()La función se describe en la documentación de la biblioteca talib como:WMA(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.LINEARREG()La función se utiliza para calcularRegresión lineal.
El valor de retorno de latalib.LINEARREG()La función es una matriz unidimensional.
el conjunto
Talib.LINEARREG (en realidad) Talib.LINEARREG ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElLINEARREG()La función se describe en la documentación de la biblioteca talib como:LINEARREG(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.LINEARREG_ANGLE()La función se utiliza para calcular elÁngulo de regresión lineal.
El valor de retorno de latalib.LINEARREG_ANGLE()La función es: una matriz unidimensional.
el conjunto
Talib.LINEARREG_ANGLE ((en realidad) Talib.LINEARREG_ANGLE ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElLINEARREG_ANGLE()La función se describe en la documentación de la biblioteca talib como:LINEARREG_ANGLE(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.LINEARREG_INTERCEPT()La función se utiliza para calcular elIntercepción de regresión lineal.
El valor de retorno de latalib.LINEARREG_INTERCEPT()La función es: una matriz unidimensional.
el conjunto
Talib.LINEARREG_INTERCEPT (en realidad) Talib.LINEARREG_INTERCEPT ((en tiempo real, optInTimePeriod) el tiempo en el que se puede obtener el resultado de la búsqueda
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElLINEARREG_INTERCEPT()La función se describe en la documentación de la biblioteca talib como:LINEARREG_INTERCEPT(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.LINEARREG_SLOPE()La función se utiliza para calcular elPendiente de regresión lineal.
El valor de retorno de latalib.LINEARREG_SLOPE()La función es: una matriz unidimensional.
el conjunto
Talib.LINEARREG_SLOPE ((en verdad) Talib.LINEARREG_SLOPE ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElLINEARREG_SLOPE()La función se describe en la documentación de la biblioteca talib como:LINEARREG_SLOPE(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.STDDEV()La función se utiliza para calcularDesviación estándar.
El valor de retorno de latalib.STDDEV()La función es: una matriz unidimensional.
el conjunto
Talib.STDDEV (en realidad) Talib.STDDEV ((en tiempo real, optInTimePeriod) Talib.STDDEV ((enReal, optInTimePeriod, optInNbDev) y también puede ser utilizado para la búsqueda de información.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 5.
OptInTimePeriodo
falsos
Número
EloptInNbDevEl parámetro se utiliza para establecer las desviaciones, el valor predeterminado es 1.
- ¿ Qué quieres decir con eso?
falsos
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);
}
ElSTDDEV()La función se describe en la documentación de la biblioteca talib como:STDDEV(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Eltalib.TSF()La función se utiliza para calcularPronóstico de serie temporal.
El valor de retorno de latalib.TSF()La función es una matriz unidimensional.
el conjunto
Talib.TSF (en realidad) Talib.TSF (en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElTSF()La función se describe en la documentación de la biblioteca talib como:TSF(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.VAR()La función se utiliza para calcularVariación.
El valor de retorno de latalib.VAR()La función es: una matriz unidimensional.
el conjunto
Talib.VAR (en realidad) Talib.VAR ((en tiempo real, optInTimePeriod) Talib.VAR ((enReal, optInTimePeriod, optInNbDev) y también puede ser utilizado para hacer un cambio de dirección.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 5.
OptInTimePeriodo
falsos
Número
EloptInNbDevEl parámetro se utiliza para establecer las desviaciones, el valor predeterminado es 1.
- ¿ Qué quieres decir con eso?
falsos
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);
}
ElVAR()La función se describe en la documentación de la biblioteca talib como:VAR(Records[Close],Time Period = 5,Deviations = 1) = Array(outReal)
Eltalib.ADX()La función se utiliza para calcular elIndice de movimiento direccional medio.
El valor de retorno de latalib.ADX()La función es una matriz unidimensional.
el conjunto
Talib.ADX (en el precio de HLC) Talib.ADX ((inPriceHLC, optInTimePeriod) el precio de las acciones de la compañía
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElADX()La función se describe en la documentación de la biblioteca talib como:ADX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.ADXR()La función se utiliza para calcular elIndice de movimiento direccional medio (índice de evaluación).
El valor de retorno de latalib.ADXR()La función es una matriz unidimensional.
el conjunto
Talib.ADXR ((en el precioHLC) Talib.ADXR ((en el precioHLC, optInTimePeriod)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElADXR()La función se describe en la documentación de la biblioteca talib como:ADXR(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.APO()La función se utiliza para calcular elOscilador de precios absoluto.
El valor de retorno de latalib.APO()La función es: una matriz unidimensional.
el conjunto
Talib.APO ((enReal) Talib.APO ((enReal, optInFastPeriod) (en inglés) Talib.APO ((enReal, optInFastPeriod, optInSlowPeriod) y también en el caso de las personas que se encuentran en el centro de la ciudad. Talib.APO ((enReal, optInFastPeriod, optInSlowPeriod, optInMAType) El tipo de código es el mismo que en el tipo original.
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInFastPeriodel parámetro se utiliza para establecer el período rápido, el valor predeterminado es 12.
OptInFastPeriod
falsos
Número
EloptInSlowPeriodel parámetro se utiliza para establecer el período lento, el valor predeterminado es 26.
optInSlowPeriod (en inglés)
falsos
Número
EloptInMATypeel parámetro se utiliza para establecer el tipo medio, el valor predeterminado es 0.
Seleccionar el tipo
falsos
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);
}
ElAPO()La función se describe en la documentación de la biblioteca talib como:APO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Eltalib.AROON()La función se utiliza para calcular elAroon (indicador de Aroon).
El valor de retorno de latalib.AROON()La función es una matriz bidimensional.
el conjunto
Talib.AROON ((en el precioHL) Talib.AROON ((en el precioHL, optInTimePeriod)
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElAROON()La función se describe en la documentación de la biblioteca talib como:AROON(Records[High,Low],Time Period = 14) = [Array(outAroonDown),Array(outAroonUp)]
Eltalib.AROONOSC()La función se utiliza para calcular elOscilador de Aroon.
El valor de retorno de latalib.AROONOSC()La función es: una matriz unidimensional.
el conjunto
Talib.AROONOSC ((en el precioHL) Talib.AROONOSC ((en el precioHL, optInTimePeriod)
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElAROONOSC()La función se describe en la documentación de la biblioteca talib como:AROONOSC(Records[High,Low],Time Period = 14) = Array(outReal)
Eltalib.BOP()La función se utiliza para calcular elEl equilibrio del poder.
El valor de retorno de latalib.BOP()La función es una matriz unidimensional.
el conjunto
Talib.BOP (en el precio OHLC)
ElinPriceOHLCse utiliza para especificar los datos de la línea K.
enPriceOHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElBOP()La función se describe en la documentación de la biblioteca talib como:BOP(Records[Open,High,Low,Close]) = Array(outReal)
Eltalib.CCI()La función se utiliza para calcular elIndicador de canales de productos básicos (indicador homeopático).
El valor de retorno de latalib.CCI()La función es una matriz unidimensional.
el conjunto
Talib.CCI ((en el precioHLC) Talib.CCI ((enPriceHLC, optInTimePeriod) el año pasado fue el año en el que se produjo la primera operación de este tipo.
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElCCI()La función se describe en la documentación de la biblioteca talib como:CCI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.CMO()La función se utiliza para calcular elLos valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de.
El valor de retorno de latalib.CMO()La función es: una matriz unidimensional.
el conjunto
Talib.CMO ((enReal) Talib.CMO ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElCMO()La función se describe en la documentación de la biblioteca talib como:CMO(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.DX()La función se utiliza para calcular elIndice de movimiento direccional.
El valor de retorno de latalib.DX()La función es: una matriz unidimensional.
el conjunto
Talib.DX (en el precio de HLC) Talib.DX ((inPriceHLC, optInTimePeriod) (en inglés)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElDX()La función se describe en la documentación de la biblioteca talib como:DX(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.MACD()La función se utiliza para calcularLa convergencia/divergencia de la media móvil (media móvil suavizada exponencialmente).
El valor de retorno de latalib.MACD()La función es: una matriz bidimensional.
el conjunto
Talib.MACD (en realidad) Talib.MACD ((enReal, optInFastPeriod) el año pasado Talib.MACD ((enReal, optInFastPeriod, optInSlowPeriod) el tiempo de espera de las personas que se encuentran en el lugar de trabajo. Talib.MACD ((en tiempo real, en tiempo rápido, en tiempo lento, en tiempo de señal)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInFastPeriodel parámetro se utiliza para establecer el período rápido, el valor predeterminado es 12.
OptInFastPeriod
falsos
Número
EloptInSlowPeriodel parámetro se utiliza para establecer el período lento, el valor predeterminado es 26.
optInSlowPeriod (en inglés)
falsos
Número
EloptInSignalPeriodel parámetro se utiliza para establecer el período de señal, el valor predeterminado es 9.
OptEn el período de señal
falsos
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);
}
ElMACD()La función se describe en la documentación de la biblioteca talib como:MACD(Records[Close],Fast Period = 12,Slow Period = 26,Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Eltalib.MACDEXT()La función se utiliza para calcularMACD con tipo de MA controlable.
El valor de retorno de latalib.MACDEXT()La función es una matriz bidimensional.
el conjunto
Talib.MACDEXT (en realidad) Talib.MACDEXT ((enReal, optInFastPeriod) (en inglés) Talib.MACDEXT ((enReal, optInFastPeriod, optInFastMAType) El tipo de código de código es el siguiente: Talib.MACDEXT ((enReal, optInFastPeriod, optInFastMAType, optInSlowPeriod) El tipo de código de código es el siguiente: talib.MACDEXT ((enReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType) El tipo de código que se utiliza es el siguiente: talib.MACDEXT ((enReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod) El tipo de código de código es el siguiente: talib.MACDEXT ((enReal, optInFastPeriod, optInFastMAType, optInSlowPeriod, optInSlowMAType, optInSignalPeriod, optInSignalMAType) El tipo de código de código es el siguiente:
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInFastPeriodel parámetro se utiliza para establecer el período rápido, el valor predeterminado es 12.
OptInFastPeriod
falsos
Número
EloptInFastMATypeel parámetro se utiliza para establecer el tipo de media rápida, el valor predeterminado es 0.
Seleccionar el tipo de código
falsos
Número
EloptInSlowPeriodel parámetro se utiliza para establecer el período lento, el valor predeterminado es 26.
optInSlowPeriod (en inglés)
falsos
Número
EloptInSlowMATypeel parámetro se utiliza para establecer el tipo de media lenta, el valor predeterminado es 0.
Seleccionar el tipo de código
falsos
Número
EloptInSignalPeriodel parámetro se utiliza para establecer el período de señal, el valor predeterminado es 9.
OptEn el período de señal
falsos
Número
EloptInSignalMATypeel parámetro se utiliza para establecer el tipo de media de señal, el valor predeterminado es 0.
OptiSignalMAType
falsos
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);
}
ElMACDEXT()La función se describe en la documentación de la 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)]
Eltalib.MACDFIX()La función se utiliza para calcularMedios móviles de convergencia/divergencia fijación 12/26.
El valor de retorno de latalib.MACDFIX()La función es una matriz bidimensional.
el conjunto
Talib.MACDFIX (en realidad) Talib.MACDFIX ((en verdad, optInSignalPeriodo)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInSignalPeriodel parámetro se utiliza para establecer el período de señal, el valor predeterminado es 9.
OptEn el período de señal
falsos
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);
}
ElMACDFIX()La función se describe en la documentación de la biblioteca talib como:MACDFIX(Records[Close],Signal Period = 9) = [Array(outMACD),Array(outMACDSignal),Array(outMACDHist)]
Eltalib.MFI()La función se utiliza para calcular elÍndice de flujo de dinero.
El valor de retorno de latalib.MFI()La función es una matriz unidimensional.
el conjunto
Talib.FIM ((enPriceHLCV) Talib.IFM ((enPriceHLCV, optInTimePeriod) el año en el que se realizó la operación.
ElinPriceHLCVse utiliza para especificar los datos de la línea K.
enPriceHLCV
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElMFI()La función se describe en la documentación de la biblioteca talib como:MFI(Records[High,Low,Close,Volume],Time Period = 14) = Array(outReal)
Eltalib.MINUS_DI()La función se utiliza para calcular elIndicador de dirección negativo.
El valor de retorno de latalib.MINUS_DI()La función es una matriz unidimensional.
el conjunto
Talib.MINUS_DI ((en el precioHLC) Talib.MINUS_DI ((en el precioHLC, optInTimePeriod)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElMINUS_DI()La función se describe en la documentación de la biblioteca talib como:MINUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.MINUS_DM()La función se utiliza para calcular elMovimiento Direccional menos (movimiento negativo).
El valor de retorno de latalib.MINUS_DM()La función es una matriz unidimensional.
el conjunto
Talib.MINUS_DM (en el precio de la línea) Talib.MINUS_DM ((en el precioHL, optInTimePeriod)
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElMINUS_DM()La función se describe en la documentación de la biblioteca talib como:MINUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Eltalib.MOM()La función se utiliza para calcularImpulso.
El valor de retorno de latalib.MOM()La función es una matriz unidimensional.
el conjunto
Talib.MOM (en realidad) Talib.MOM ((en realidad, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 10.
OptInTimePeriodo
falsos
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);
}
ElMOM()La función se describe en la documentación de la biblioteca talib como:MOM(Records[Close],Time Period = 10) = Array(outReal)
Eltalib.PLUS_DI()La función se utiliza para calcular elIndicador de dirección más.
El valor de retorno de latalib.PLUS_DI()La función es: una matriz unidimensional.
el conjunto
Talib.PLUS_DI ((enPriceHLC) el año pasado) Talib.PLUS_DI ((en el precioHLC, optInTimePeriod)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElPLUS_DI()La función se describe en la documentación de la biblioteca talib como:PLUS_DI(Records[High,Low,Close],Time Period = 14) = Array(outReal)
Eltalib.PLUS_DM()La función se utiliza para calcularMás el movimiento direccional.
El valor de retorno de latalib.PLUS_DM()La función es una matriz unidimensional.
el conjunto
Talib.PLUS_DM ((en el precioHL) Talib.PLUS_DM ((enPriceHL, optInTimePeriod) el precio de las cosas en el mercado
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElPLUS_DM()La función se describe en la documentación de la biblioteca talib como:PLUS_DM(Records[High,Low],Time Period = 14) = Array(outReal)
Eltalib.PPO()La función se utiliza para calcular elOscilador de precios por porcentaje.
El valor de retorno de latalib.PPO()La función es una matriz unidimensional.
el conjunto
Talib.PPO ((enReal) Talib.PPO ((en verdad, optInFastPeriod) Talib.PPO ((enReal, optInFastPeriod, optInSlowPeriod) el tiempo de espera de las personas que están tomando el medicamento. talib.PPO ((enReal, optInFastPeriod, optInSlowPeriod, optInMAType) el tipo de código que se utiliza en el código de código
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInFastPeriodel parámetro se utiliza para establecer el período rápido, el valor predeterminado es 12.
OptInFastPeriod
falsos
Número
EloptInSlowPeriodel parámetro se utiliza para establecer el período lento, el valor predeterminado es 26.
optInSlowPeriod (en inglés)
falsos
Número
EloptInMATypeel parámetro se utiliza para establecer el tipo medio, el valor predeterminado es 0.
Seleccionar el tipo
falsos
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);
}
ElPPO()La función se describe en la documentación de la biblioteca talib como:PPO(Records[Close],Fast Period = 12,Slow Period = 26,MA Type = 0) = Array(outReal)
Eltalib.ROC()La función se utiliza para calcularTasa de cambio: ((precio/previo precio) -1) * 100 (indicador de tasa de cambio).
El valor de retorno de latalib.ROC()La función es una matriz unidimensional.
el conjunto
Talib.ROC ((enReal) Talib.ROC ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 10.
OptInTimePeriodo
falsos
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);
}
ElROC()La función se describe en la documentación de la biblioteca talib como:ROC(Records[Close],Time Period = 10) = Array(outReal)
Eltalib.ROCP()La función se utiliza para calcularTasa de cambio Porcentaje: (precio-previo al precio) /previo al precio (tasa de cambio del precio).
El valor de retorno de latalib.ROCP()La función es: una matriz unidimensional.
el conjunto
Talib.ROCP (en realidad) Talib.ROCP ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 10.
OptInTimePeriodo
falsos
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);
}
ElROCP()La función se describe en la documentación de la biblioteca talib como:ROCP(Records[Close],Time Period = 10) = Array(outReal)
Eltalib.ROCR()La función se utiliza para calcular elRatio de cambio de precio: (precio/previo precio) (ratio de cambio de precio).
El valor de retorno de latalib.ROCR()La función es una matriz unidimensional.
el conjunto
Talib.ROCR (en realidad) Talib.ROCR ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 10.
OptInTimePeriodo
falsos
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);
}
ElROCR()La función se describe en la documentación de la biblioteca talib como:ROCR(Records[Close],Time Period = 10) = Array(outReal)
Eltalib.ROCR100()La función se utiliza para calcularTasa de cambio de la relación 100 escala: (precio/prevPrice) * 100 (ratio de cambio de precios).
El valor de retorno de latalib.ROCR100()La función es: una matriz unidimensional.
el conjunto
Talib.ROCR100 ((inReal) es una empresa de servicios de información y comunicaciones. Talib.ROCR100 ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 10.
OptInTimePeriodo
falsos
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);
}
ElROCR100()La función se describe en la documentación de la biblioteca talib como:ROCR100(Records[Close],Time Period = 10) = Array(outReal)
Eltalib.RSI()La función se utiliza para calcular elIndice de fuerza relativa.
El valor de retorno de latalib.RSI()La función es una matriz unidimensional.
el conjunto
Talib.RSI ((InReal) Talib.RSI (en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElRSI()La función se describe en la documentación de la biblioteca talib como:RSI(Records[Close],Time Period = 14) = Array(outReal)
Eltalib.STOCH()La función se utiliza para calcular elIndicador de las emisiones de CO2.
El valor de retorno de latalib.STOCH()La función es una matriz bidimensional.
el conjunto
Talib.STOCH ((en el precioHLC) Talib.STOCH ((inPriceHLC, optInFastK_Period) El precio de las acciones es el mismo que el precio de las acciones. Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period) El precio de las acciones de la compañía es el mismo que el precio de las acciones de la compañía. Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType) El tipo de código de código es el siguiente: Talib.STOCH ((en el precioHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period) Talib.STOCH ((inPriceHLC, optInFastK_Period, optInSlowK_Period, optInSlowK_MAType, optInSlowD_Period, optInSlowD_MAType) El tipo de código que se puede utilizar para obtener el código de código es el siguiente:
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInFastK_Periodel parámetro se utiliza para establecer el período Fast-K, el valor predeterminado es 5.
Seleccionar el período de tiempo
falsos
Número
EloptInSlowK_Periodel parámetro se utiliza para establecer el período Slow-K, el valor predeterminado es 3.
Seleccionar el tiempo de espera
falsos
Número
EloptInSlowK_MATypeel parámetro se utiliza para establecer el tipo de media Slow-K, el valor predeterminado es 0.
Seleccionar el tipo de código
falsos
Número
EloptInSlowD_Periodel parámetro se utiliza para establecer el período Slow-D, el valor predeterminado es 3.
Seleccionar el período de tiempo
falsos
Número
EloptInSlowD_MATypeel parámetro se utiliza para establecer el tipo de media Slow-D, el valor predeterminado es 0.
Seleccionar el tipo de código
falsos
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);
}
ElSTOCH()La función se describe en la documentación de la 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)]
Eltalib.STOCHF()La función se utiliza para calcular elIndicador de velocidad de las emisiones de CO2.
El valor de retorno de latalib.STOCHF()La función es una matriz bidimensional.
el conjunto
Talib.STOCHF ((en el precioHLC) Talib.STOCHF ((enPriceHLC, optInFastK_Period) el tiempo de espera de las acciones Talib.STOCHF ((inPriceHLC, optInFastK_Period, optInFastD_Period) El precio de las acciones de la compañía es el mismo que el precio de las acciones de la compañía. Talib.STOCHF ((inPriceHLC, optInFastK_Periodo, optInFastD_Periodo, optInFastD_MAType)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInFastK_Periodel parámetro se utiliza para establecer el período Fast-K, el valor predeterminado es 5.
Seleccionar el período de tiempo
falsos
Número
EloptInFastD_Periodel parámetro se utiliza para establecer el período Fast-D, el valor predeterminado es 3.
Selección de tiempo de espera
falsos
Número
EloptInFastD_MATypeel parámetro se utiliza para establecer el tipo de media Fast-D, el valor predeterminado es 0.
Seleccionar el tipo de código
falsos
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);
}
ElSTOCHF()La función se describe en la documentación de la biblioteca talib como:STOCHF(Records[High,Low,Close],Fast-K Period = 5,Fast-D Period = 3,Fast-D MA = 0) = [Array(outFastK),Array(outFastD)]
Eltalib.STOCHRSI()La función se utiliza para calcular elIndice de fuerza relativa estocástico.
El valor de retorno de latalib.STOCHRSI()La función es: una matriz bidimensional.
el conjunto
Talib.STOCHRSI (en realidad) Talib.STOCHRSI ((en tiempo real, optInTimePeriod) Talib.STOCHRSI ((en tiempo real, optInTimePeriod, optInFastK_Period) Talib.STOCHRSI ((inReal, optInTimePeriod, optInFastK_Period, optInFastD_Period) El tiempo en el que se puede obtener el resultado de la búsqueda es de un año. Talib.STOCHRSI ((enReal, optInTimePeriod, optInFastK_Period, optInFastD_Period, optInFastD_MAType) El tipo de código que se utiliza es el siguiente:
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
Número
EloptInFastK_Periodel parámetro se utiliza para establecer el período Fast-K, el valor predeterminado es 5.
Seleccionar el período de tiempo
falsos
Número
EloptInFastD_Periodel parámetro se utiliza para establecer el período Fast-D, el valor predeterminado es 3.
Selección de tiempo de espera
falsos
Número
EloptInFastD_MATypeel parámetro se utiliza para establecer el tipo de media Fast-D, el valor predeterminado es 0.
Seleccionar el tipo de código
falsos
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);
}
ElSTOCHRSI()La función se describe en la documentación de la 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)]
Eltalib.TRIX()La función se utiliza para calcular elLa tasa de cambio de un día (ROC) de una EMA triple lisa.
El valor de retorno de latalib.TRIX()La función es: una matriz unidimensional.
el conjunto
Talib.TRIX ((InReal) Talib.TRIX ((en tiempo real, optInTimePeriod)
ElinRealse utiliza para especificar los datos de la línea K.
En realidad
verdadero
Las matrices de estructuras, matrices numéricas
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 30.
OptInTimePeriodo
falsos
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);
}
ElTRIX()La función se describe en la documentación de la biblioteca talib como:TRIX(Records[Close],Time Period = 30) = Array(outReal)
Eltalib.ULTOSC()La función se utiliza para calcular elOscilador definitivo.
El valor de retorno de latalib.ULTOSC()La función es una matriz unidimensional.
el conjunto
Talib.ULTOSC ((en el precioHLC) Talib.ULTOSC ((enPriceHLC, optInTimePeriod1)) El precio de las acciones de los Estados miembros es el siguiente: Talib.ULTOSC ((enPriceHLC, optInTimePeriod1, optInTimePeriod2)) el precio de las acciones de los clientes de las empresas de servicios de telecomunicaciones. Talib.ULTOSC ((inPriceHLC, optInTimePeriod1, optInTimePeriod2, optInTimePeriod3) y el resto de las aplicaciones.
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriod1el parámetro se utiliza para establecer el primer período, el valor predeterminado es 7.
opInTimePeriodo1
falsos
Número
EloptInTimePeriod2el parámetro se utiliza para establecer el segundo período, el valor predeterminado es 14.
optInTimePeriodo2
falsos
Número
EloptInTimePeriod3el parámetro se utiliza para establecer el tercer período, el valor predeterminado es 28.
optInTimePeriodo3
falsos
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);
}
ElULTOSC()La función se describe en la documentación de la biblioteca talib como:ULTOSC(Records[High,Low,Close],First Period = 7,Second Period = 14,Third Period = 28) = Array(outReal)
Eltalib.WILLR()La función se utiliza para calcularWilliams % R.
El valor de retorno de latalib.WILLR()La función es: una matriz unidimensional.
el conjunto
Talib.WILLR ((enPriceHLC) es el nombre de una de las compañías de la compañía. Talib.WILLR ((enPriceHLC, optInTimePeriod) el tiempo de espera de las personas
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
EloptInTimePeriodel parámetro se utiliza para establecer el período, el valor predeterminado es 14.
OptInTimePeriodo
falsos
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);
}
ElAVGPRICE()La función se describe en la documentación de la biblioteca talib como:AVGPRICE(Records[Open,High,Low,Close]) = Array(outReal)
Eltalib.MEDPRICE()La función se utiliza para calcular elPrecio medio.
El valor de retorno de latalib.MEDPRICE()La función es una matriz unidimensional.
el conjunto
Talib.MEDPRICE ((en el precioHL)
ElinPriceHLse utiliza para especificar los datos de la línea K.
enPriceHL
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElMEDPRICE()La función se describe en la documentación de la biblioteca talib como:MEDPRICE(Records[High,Low]) = Array(outReal)
Eltalib.TYPPRICE()La función se utiliza para calcularPrecio típico.
El valor de retorno de latalib.TYPPRICE()La función es una matriz unidimensional.
el conjunto
Talib.TYPPRICE ((en el precioHLC)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElTYPPRICE()La función se describe en la documentación de la biblioteca talib como:TYPPRICE(Records[High,Low,Close]) = Array(outReal)
Eltalib.WCLPRICE()La función se utiliza para calcular elPrecio de cierre ponderado.
El valor de retorno de latalib.WCLPRICE()La función es una matriz unidimensional.
el conjunto
Talib.WCLPRICE ((en el precioHLC)
ElinPriceHLCse utiliza para especificar los datos de la línea K.
enPriceHLC
verdadero
{@struct/Record Record} matriz de estructuras
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);
}
ElWCLPRICE()La función se describe en la documentación de la biblioteca talib como:WCLPRICE(Records[High,Low,Close]) = Array(outReal)