marcoc/oslib
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
oslib/ose/ose-minion-02-p5-rajada-HFT-1min.mq5
super.admin 07f69c4478 convert
2025-05-30 16:15:18 +02:00

4372 lines
No EOL
495 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| ose-minion-02-p5-rajada-HFT-1min.mq5 |
//| Copyright 2019, OS Corp. |
//| http://www.os.org |
//| |
//| Versao 2.p5 |
//| 1. Fork da versao 2.486 feito em 30/01/2020. |
//| |
//| 02-p5 Melhorias para suportar operacao com mini-dolar e |
//| operacao com mais de um ativo ao mesmo tempo. |
//| |
//| 02-p5 Novo parametro para aguardar xx segundos antes poder |
//| posicoes. (31/01/2020) |
//| |
//| 02-p5 Correcao na funcao refresme, que cancelava ordens de |
//| abertura de posicao, mesmo que o EA estivesse parametri- |
//| zado para nao operar. (31/01/2020) |
//| |
//| 02-p5 Novo parametro indicando o tamanho da rajada. Quantidade |
//| ordens no sentido contrario ao preco atual. |
//| |
//| 02-486 Parametro para gravar sql no log |
//| 02-486 Usa indicar feira 0307 |
//| |
//| 02-186 Eliminado o parametro EA03_FECHAR_RAJADA, pois as rajadas |
//| sempre sao fechadas apos o fechamento da posicao. |
//| |
//| 02-186 Eliminado o parametro EA09_VOLAT_BAIXA, que ainda nao eh |
//| usado. |
//| 02-186 Transformado o parametro EA01_MAX_VOL_EM_RISCO em |
//| constante. |
//| |
//| 02-186 Novo parametro EA_SPREAD_MAXIMO. Se passar desse spread |
//| nao abre novas posicoes. VAlor em ticks. |
//| |
//| 02-186 Novo parametro EA_SHOW_TELA. Se true, mostra variaveis na |
//| tela. Desabilite quando operar no VPS. |
//| |
//| X. Usar indicador feira para saber a volatilidade em funcao do |
//| volume (pendente). |
//| |
//| 02-086 Correcao da saida por qtd EA_STOP_QTD_CONTRAT. |
//| Nao considerava o volume da primeira transacao ao contar as |
//| transacoes da posicao. Aparece sempre que uma das transacoes |
//| da posicao for maior que 1. |
//| |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, OS Corp."
#property link "http://www.os.org"
#property version "2.486"
#include <Indicators\Trend.mqh>
#include <Indicators\Volumes.mqh>
#include <Indicators\Oscilators.mqh>
#include <Generic\Queue.mqh>
#include <Generic\HashMap.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <..\Projects\projetcts\os-ea\ClassMinion-02-com-estatistica.mqh>
#include <oslib\os-lib.mq5>
#include <oslib\osc-ind-minion-feira.mqh>
#include <oslib\osc-estatistic2.mqh>
#include <oslib\osc\osc-minion-trade-03.mqh>
#include <oslib\osc\osc-minion-trade-estatistica.mqh>
#include <oslib\svc\osc-svc.mqh>
#include <oslib\svc\run\cls-run.mqh>
#define SLEEP_PADRAO 50
#define COMPILE_PRODUCAO
enum ENUM_TIPO_ENTRADA_PERMITDA{
ENTRADA_NULA , //ENTRADA_NULA Nao permite abrir posicoes.
ENTRADA_BUY , //ENTRADA_BUY Soh abre posicoes de compra.
ENTRADA_SELL , //ENTRADA_SELL Soh abre posocoes de venda.
ENTRADA_TODAS //ENTRADA_TODAS Abre qualquer tipo de posicao.
};
enum ENUM_TIPO_OPERACAO{
NAO_OPERAR , //NAO_OPERAR EA não abre nem fecha posições, fica apenas atualizando os indicadores.
FECHAR_POSICAO , //FECHAR_POSICAO EA fecha a posição aberta. Usar em caso de emergencia.
FECHAR_POSICAO_POSITIVA , //FECHAR_POSICAO_POSITIVA Igual a anterior, mas aguarda o saldo da posição ficar positivo pra fechar.
NAO_ABRIR_POSICAO , //NAO_ABRIR_POSICAO Pode ser usado para entrar manualmente e deixar o EA sair.
CONTRA_TEND_DURANTE_COMPROMETIMENTO , //CONTRA_TEND_DURANTE_COMPROMETIMENTO Abre posicao, na direcao contraria, se o preco atingir a media de precos do book. Ex: abre posicao de venda de preco atingir a media de ofertas ask.
CONTRA_TEND_APOS_COMPROMETIMENTO , //CONTRA_TEND_APOS_COMPROMETIMENTO Igual ao anterior, mas após o preco romper a media de ofertas do book.
CONTRA_TEND_APOS_ROMPIMENTO_ANTERIOR , //CONTRA_TEND_APOS_ROMPIMENTO_ANTERIOR Abre posicao contraria quando o preço passa o máximo ou mínimo da vela anterior.
HFT_DISTANCIA_PRECO , //DISTANCIA_PRECO Abre posicao contraria, se o preco se afastar X ticks do preço atual.
HFT_MAX_MIN_VOLAT , //MAX_MIN_VOLAT Abre posicao contraria, se o preco ultrapassar o preco maximo ou minimo do ultimo minuto.
HFT_TEND_CCI , //TEND_CCI Abre posicao a favor da tendencia, de acordo com o indicador CCI.
HFT_NA_TENDENCIA , //NA_TENDENCIA Abre posicao a favor da tendencia em funcao da inclinacao do preco medio.
HFT_DESBALANC_BOOK , //DESBALANC_BOOK Abre posicao segundo desbalancemaneto das primeiras filas do book.
HFT_DESBALANC_BOOKNS , //DESBALANC_BOOKNS Abre posicao segundo desbalancemaneto das primeiras filas do book.
HFT_NORTE_SUL , //NORTE_SUL Coloca as ordens de entrata e saida em paralelo.
HFT_MEDIA_TRADE , //MEDIA_TRADE
HFT_ARBITRAGEM_VOLUME , //ARBITRAGEM_VOLUME
HFT_DISTANCIA_DA_MEDIA , //DISTANCIA_DA_MEDIA: abre posicao a qtd_ticks_4_gain da media de trade (29/01/2020)
HFT_HIBRIDO_MAX_MIN_VOL_X_DISTANCIA_PRECO, //HIBRIDO_MAX_MIN_VOL_X_DISTANCIA_PRECO
HFT_FLUXO_ORDENS , //HFT_FLUXO_ORDENS, abre posicao se probabilidade de subir/descer for mais que parametro
HFT_REGIAO_CANAL_ENTRELACA , //REGIAO_CANAL_ENTRELACA Abre posicao contraria, se o preco ultrapassar o preco maximo ou minimo do ultimo minuto.
HFT_BB_NA_TENDENCIA
};
//---------------------------------------------------------------------------------------------
input group "Gerais"
input ENUM_TIPO_OPERACAO EA07_ABRIR_POSICAO = FECHAR_POSICAO ; //EA07_ABRIR_POSICAO:Forma de operacao do EA.
input double EA_SPREAD_MAXIMO = 4 ; //EA_SPREAD_MAXIMO em ticks. Se for maior que o maximo, nao abre novas posicoes.
//
input group "Volume por Segundo"
input int EA_VOLSEG_L1 = 50 ; //VOLSEG_L1 : Vol de contratos por segundo L1.
input int EA_VOLSEG_L2 = 100 ; //VOLSEG_L2 : Vol de contratos por segundo L2.
input int EA_VOLSEG_L3 = 150 ; //VOLSEG_L3 : Vol de contratos por segundo L3.
input int EA_VOLSEG_L4 = 200 ; //VOLSEG_L4 : Vol de contratos por segundo L4
input int EA_VOLSEG_L5 = 250 ; //VOLSEG_L5 : Vol de contratos por segundo L5
input int EA_VOLSEG_ALTO = 400 ; //VOLSEG_ALTO: Vol de contratos por segundo que eh considerado alto.
input int EA_VOLSEG_MAX_ENTRADA_POSIC = 150;//VOLSEG_MAX_ENTRADA_POSIC: vol/seg maximo para entrar na posicao.
//
input group "Volume Aporte"
input double EA_VOL_LOTE_INI_L1 = 1 ; //VOL_LOTE_INI_L1:Vol do lote a ser usado na abertura de posicao qd vol/seg eh L1.
input double EA_VOL_LOTE_RAJ_L1 = 1 ; //VOL_LOTE_RAJ_L1:Vol do lote a ser usado qd vol/seg eh L1.
//input double EA_VOL_LOTE_INI_L2 = 1 ; //VOL_LOTE_INI_L2:Vol do lote a ser usado na abertura de posicao qd vol/seg eh L2.
//input double EA_VOL_LOTE_INI_L3 = 1 ; //VOL_LOTE_INI_L3:Vol do lote a ser usado na abertura de posicao qd vol/seg eh L3.
//input double EA_VOL_LOTE_INI_L4 = 1 ; //VOL_LOTE_INI_L4:Vol do lote a ser usado na abertura de posicao qd vol/seg eh L4.
//input double EA_VOL_LOTE_INI_L5 = 1 ; //VOL_LOTE_INI_L5:Vol do lote a ser usado na abertura de posicao qd vol/seg eh L5.
//input double EA_VOL_LOTE_INI_ALTO = 1 ; //VOL_LOTE_INI_ALTO:Vol do lote a ser usado na abertura de posicao qd vol/seg eh maior que L5.
//
//input group "volume lote rajada"
//input double EA_VOL_LOTE_RAJ_L2 = 1 ; //VOL_LOTE_RAJ_L2:Vol do lote a ser usado qd vol/seg eh L2.
//input double EA_VOL_LOTE_RAJ_L3 = 1 ; //VOL_LOTE_RAJ_L3:Vol do lote a ser usado qd vol/seg eh L3.
//input double EA_VOL_LOTE_RAJ_L4 = 1 ; //VOL_LOTE_RAJ_L4:Vol do lote a ser usado qd vol/seg eh L4.
//input double EA_VOL_LOTE_RAJ_L5 = 1 ; //VOL_LOTE_RAJ_L5:Vol do lote a ser usado qd vol/seg eh L5.
//input double EA_VOL_LOTE_RAJ_ALTO = 1 ; //VOL_LOTE_ALTO:Vol do lote a ser usado qd vol/seg eh maior que L5.
//
input group "Rajada"
input int EA_TAMANHO_RAJADA = 3 ; //TAMANHO_RAJADA;
//input double EA_PASSO_RAJ_L2 = 3 ; //PASSO_RAJ_L2:Incremento de preco, em tick, na direcao contraria a posicao;
//input double EA_PASSO_RAJ_L3 = 3 ; //PASSO_RAJ_L3:Incremento de preco, em tick, na direcao contraria a posicao;
//input double EA_PASSO_RAJ_L4 = 3 ; //PASSO_RAJ_L4:Incremento de preco, em tick, na direcao contraria a posicao;
//input double EA_PASSO_RAJ_L5 = 3 ; //PASSO_RAJ_L5:Incremento de preco, em tick, na direcao contraria a posicao;
//input double EA_PASSO_RAJ_ALTO = 3 ; //PASSO_RAJ_ALTO:Incremento de preco, em tick, na direcao contraria a posicao qd vol/seg eh level 5;
input group "Passo Fixo"
input double EA_PASSO_RAJ_L1 = 3; //PASSO_RAJ_L1:Incremento de preco, em tick, na direcao contraria a posicao;
input int EA_QTD_TICKS_4_GAIN_INI_L1 = 3; //QTD_TICKS_4_GAIN_INI_L1:Qtd ticks para o gain qd vol/seg eh level 1;
input int EA_QTD_TICKS_4_GAIN_RAJ_L1 = 3; //QTD_TICKS_4_GAIN_RAJ_L1:Qtd ticks para o gain qd vol/seg eh level 1;
//input int EA_QTD_TICKS_4_GAIN_INI_L2 = 3 ; //QTD_TICKS_4_GAIN_INI_L2:Qtd ticks para o gain qd vol/seg eh level 2;
//input int EA_QTD_TICKS_4_GAIN_INI_L3 = 3 ; //QTD_TICKS_4_GAIN_INI_L3:Qtd ticks para o gain qd vol/seg eh level 3;
//input int EA_QTD_TICKS_4_GAIN_INI_L4 = 3 ; //QTD_TICKS_4_GAIN_INI_L4:Qtd ticks para o gain qd vol/seg eh level 4;
//input int EA_QTD_TICKS_4_GAIN_INI_L5 = 3 ; //QTD_TICKS_4_GAIN_INI_L5:Qtd ticks para o gain qd vol/seg eh level 5;
//input int EA_QTD_TICKS_4_GAIN_INI_ALTO = 3 ; //QTD_TICKS_4_GAIN_INI_ALTO:Qtd ticks para o gain qd vol/seg eh maior que level 5;
//
//input group "qtd ticks para o gain na RAJADA"
//input int EA_QTD_TICKS_4_GAIN_RAJ_L2 = 3 ; //QTD_TICKS_4_GAIN_RAJ_L2:Qtd ticks para o gain qd vol/seg eh level 2;
//input int EA_QTD_TICKS_4_GAIN_RAJ_L3 = 3 ; //QTD_TICKS_4_GAIN_RAJ_L3:Qtd ticks para o gain qd vol/seg eh level 3;
//input int EA_QTD_TICKS_4_GAIN_RAJ_L4 = 3 ; //QTD_TICKS_4_GAIN_RAJ_L4:Qtd ticks para o gain qd vol/seg eh level 4;
//input int EA_QTD_TICKS_4_GAIN_RAJ_L5 = 3 ; //QTD_TICKS_4_GAIN_RAJ_L5:Qtd ticks para o gain qd vol/seg eh level 5;
//input int EA_QTD_TICKS_4_GAIN_RAJ_ALTO = 3 ; //QTD_TICKS_4_GAIN_RAJ_ALTO:Qtd ticks para o gain qd vol/seg eh maior que level 5;
//
//-------------------------------------------------------------------------------------------
//input group "Run"
//input int EA_MINUTOS_RUN = 300 ; //MINUTOS_RUN:minutos usados no calcula do indice das runs.
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
input group "Passo dinamico"
input bool EA_PASSO_DINAMICO = true; //PASSO_DINAMICO:tamanho do passo muda em funcao da volatilidade
input double EA_PASSO_DINAMICO_PORC_T4G = 1 ; //PASSO_DINAMICO_PORC_TFG: % do TFG para definir o passo.
input int EA_PASSO_DINAMICO_MIN = 1 ; //EA_PASSO_DINAMICO_MIN:menor passo possivel.
input int EA_PASSO_DINAMICO_MAX = 15 ; //PASSO_DINAMICO_MAX:maior passo possivel.
input double EA_PASSO_DINAMICO_PORC_CANAL_ENTRELACA = 0.02; //PASSO_DINAMICO_PORC_CANAL_ENTRELACA
input double EA_PASSO_DINAMICO_STOP_QTD_CONTRAT = 3 ; //PASSO_DINAMICO_STOP_QTD_CONTRAT:A partir dessa qtd contratos totais na posicao, comeca a controlar seu fechamento.
input double EA_PASSO_DINAMICO_STOP_CHUNK = 2 ; //PASSO_DINAMICO_STOP_CHUNK:tamanho do chunk.
input double EA_PASSO_DINAMICO_STOP_PORC_CANAL = 1 ; //PASSO_DINAMICO_STOP_PORC_CANAL:porcentagem do canal, usada para calcular o stop_loss dinamico.
input double EA_PASSO_DINAMICO_STOP_REDUTOR_RISCO = 1 ; //PASSO_DINAMICO_STOP_REDUTOR_RISCO:porcentagem sobre o tamanho do passo para iniciar saida da posicao.
//input bool EA_STOP_PORC_DINAMICO = false; //STOP_PORC_DINAMICO:porcentagem de saida dinamica. Soh funciona se PASSO_DINAMICO eh true.
//input double EA_PORC_PASSO_DINAMICO = 0.25 ; //PORC_PASSO_DINAMICO:porcentagem do tamanho da barra de volatilidade para definir o tamanho do passo.
//input int EA_INTERVALO_PASSO = 2 ; //INTERVALO_PASSO:delta tolerancia para mudanca de passo.
//-------------------------------------------------------------------------------------------
//
input group "Stops"
input int EA_TIPO_CONTROLE_RISCO = 1 ; //TIPO_CONTROLE_RISCO, se 1, controle normal. Se 2, controle por proximidade do breakeven.
input int EA_TICKS_STOP_LOSS = 15 ; //TICKS_STOP_LOSS:Quantidade de ticks usados no stop loss;
input int EA_TICKS_TKPROF = 30 ; //TICKS_TKPROF:Quantidade de ticks usados no take profit;
input double EA_REBAIXAMENTO_MAX = 300 ; //REBAIXAMENTO_MAX:preencha com positivo.
input double EA_OBJETIVO_DIA = 250 ; //OBJETIVO_DIA:para se saldo alcancar objetivo do dia.
input double EA07_STOP_LOSS = -1200 ; //STOP_LOSS:Valor maximo de perda aceitavel;
input double EA_STOP_QTD_CONTRAT = 10 ; //STOP_QTD_CONTRAT:A partir dessa qtd contratos totais na posicao, comeca a controlar seu fechamento.
//input double EA_STOP_PORC_CONTRAT = 0 ; //STOP_PORC_CONTRAT:Porcentagen de contratos pendentes em relacao aos contratos totais para fechar a posicao.
input double EA_STOP_PORC_L1 = 1 ; //STOP_PORC_L1:Porc qtd contratos totais da posicao em reais para a saida;
//input double EA_STOP_L2 = -150 ; //STOP_L2:Se contratos pendentes maior que EA_STOP_QTD_CONTRAT*2, fecha posicao se profit for maior que o informado;
//input double EA_STOP_L3 = -300 ; //STOP_L3:Se contratos pendentes maior que EA_STOP_QTD_CONTRAT*3, fecha posicao se profit for maior que o informado;
//input double EA_STOP_L4 = -600 ; //STOP_L4:Se contratos pendentes maior que EA_STOP_QTD_CONTRAT*4, fecha posicao se profit for maior que o informado;
input long EA_10MINUTOS = 0 ; //10MINUTOS:fecha a posicao aberta a mais de XX segundos, se xx eh dif de zero.
input int EA_TICKS_TOLER_SAIDA = 1 ; //TICKS_TOLER_SAIDA: qtd de ticks a aguardar nas saidas stop;
input bool EA_MARTINGALE = false ; //MARTINGALE: dobra a quantidade de ticks a cada passo.
//
input group "Entrelacamento"
input int EA_ENTRELACA_PERIODO_COEF = 6 ;//ENTRELACA_PERIODO_COEF: periodo p/calc coef entrelacamento.
input double EA_ENTRELACA_COEF_MIN = 0.40;//ENTRELACA_COEF_MIN em porcentagem.
input int EA_ENTRELACA_CANAL_MAX = 30 ;//ENTRELACA_CANAL_MAX: tamanho maximo em ticks do canal de entrelacamento.
input int EA_ENTRELACA_CANAL_STOP = 35 ;//ENTRELACA_CANAL_STOP:StopLoss se canal maior que este parametro.
input double EA_ENTRELACA_REGIAO_BUY_SELL = 0.3 ;//ENTRELACA_REGIAO_BUY_SELL: regiao de compra e venda nas extremidades do canal de entrelacamento.
//
input group "volatilidade e inclinacoes"
input double EA_VOLAT_ALTA = 1.5 ;//VOLAT_ALTA:Volatilidade a considerar alta(%). Calculada a volatilidade como a porcentagem da tamanho da barra atual em relacao ao canal de ofertas;
input double EA_VOLAT4S_ALTA_PORC = 1.0 ;//VOLAT4S_ALTA_PORC:Porcentagem que a volatilidade por segundo pode ser maior que a volatilidade por segundo media abrir posicao.
input double EA_VOLAT4S_STOP_PORC = 1.5 ;//VOLAT4S_STOP_PORC:Porcentagem que a volatilidade por segundo pode ser maior que a volatilidade por segundo media para stopar.
input double EA_VOLAT4S_MIN = 1.5 ;//VOLAT4S_MIN:Acima deste valor, nao abre posicao.
//input double EA_VOLAT4S_MAX = 2.0 ;//VOLAT4S_MAX:Acima deste valor, fecha a posicao.
input double EA_INCL_ALTA = 0.9 ;//INCL_ALTA:Verifique o tipo de entrada pra saber se eh permitido acima dessa inclinacao.
input double EA_INCL_MIN = 0.1 ;//INCL_MIN:Inclinacao minima para entrar no trade.
input int EA_MIN_DELTA_VOL = 10 ;//MIN_DELTA_VOL:%delta vol minimo para entrar na posicao
input int EA_MIN_DELTA_VOL_ACELERACAO = 1 ;//MIN_DELTA_VOL_ACELERACAO:Aceleracao minima da %delta vol para entrar na posicao
//
input group "entrada na posicao"
input int EA_TOLERANCIA_ENTRADA = 1 ;//TOLERANCIA_ENTRADA: algumas estrategias permitem uma tolerancia do preco em ticks para entrada na posicao
//
input group "show_tela"
input bool EA_SHOW_TELA = false; //SHOW_TELA:mostra valor de variaveis na tela;
input uint EA_SHOW_TELA_LINHAS_ACIMA = 0 ; //SHOW_TELA_LINHAS_ACIMA:permite impressao na parte inferior da tela;
input bool EA_SHOW_STR_PERMISSAO_ABRIR_POSICAO = false; //SHOW_STR_PERMISSAO_ABRIR_POSICAO:condicoes p/abrir posicao;
//
input group "diversos"
input bool EA_DEBUG = false ; //DEBUG:se true, grava informacoes de debug no log do EA.
input int EA08_MAGIC = 200102005; //MAGIC: Numero magico desse EA. yymmvvvvv.
//
input group "estrategia distancia do preco"
input int EA_TICKS_ENTRADA_DIST_PRECO = 1 ;//TICKS_ENTRADA_DIST_PRECO:Usado na entrada tipo HFT_DISTANCIA_PRECO. Distancia do preco para entrar na proxima posicao; .
//
input group "estrategia distancia da media"
input int EA_TICKS_ENTRADA_DIST_MEDIA = 2 ;//TICKS_ENTRADA_DIST_MEDIA:Usado na entrada tipo HFT_DISTANCIA_DA_MEDIA. Distancia da media para entrar na proxima posicao; .
//
input group "estrategia HFT_FLUXO_ORDENS"
input double EA_PROB_UPDW = 0.8 ;//PROB_UPDW:probabilidade do preco subir ou descer em funcao do fluxo de ordens;
//
input double EA_DOLAR_TARIFA = 5.0 ;//DOLAR_TARIFA:usado para calcular a tarifa do dolar.
//
input group "estrategia desbalanceamento"
input double EA_DESBALAN_UP0 = 0.8; //DESBALAN_UP0:Desbalanceamento na primeira fila do book para comprar na estrategia de desbalanceamento.
input double EA_DESBALAN_DW0 = 0.2; //DESBALAN_DW0:Desbalanceamento na primeira fila do book para vender na estrategia de desbalanceamento.
input double EA_DESBALAN_UP1 = 0.7; //DESBALAN_UP1:Desbalanceamento na segunda fila do book para comprar na estrategia de desbalanceamento.
input double EA_DESBALAN_DW1 = 0.3; //DESBALAN_DW1:Desbalanceamento na segunda fila do book para vender na estrategia de desbalanceamento.
input double EA_DESBALAN_UP2 = 0.65; //DESBALAN_UP2:Desbalanceamento na terceira fila do book para comprar na estrategia de desbalanceamento.
input double EA_DESBALAN_DW2 = 0.35; //DESBALAN_DW2:Desbalanceamento na terceira fila do book para vender na estrategia de desbalanceamento.
input double EA_DESBALAN_UP3 = 0.6; //DESBALAN_UP3:Desbalanceamento na quarta fila do book para comprar na estrategia de desbalanceamento.
input double EA_DESBALAN_DW3 = 0.4; //DESBALAN_DW3:Desbalanceamento na quarta fila do book para vender na estrategia de desbalanceamento.
//input double EA09_VOLAT_BAIXA = 0.2 ; //Volatilidade a considerar baixa(%).
//input double EA09_VOLAT_MEDIA = 0.7 ; //Volatilidade a considerar media(%).
//input double EA09_INCL_MAX_IN = 0.5 ; //EA09_INCL_MAX_IN:Inclinacao max p/ entrar no trade.
//input double EA04_DX_TRAILLING_STOP = 1.0 ; //EA04_DX_TRAILLING_STOP:% do DX1 para fazer o trailling stop
//input double EA10_DX1 = 0.2 ; //EA10_DX1:Tamanho do DX em relacao a banda em %;
//input double EA01_MAX_VOL_EM_RISCO = 200 ; //EA01_MAX_VOL_EM_RISCO:Qtd max de contratos em risco; Sao os contratos pendentes da posicao.
#define EA01_MAX_VOL_EM_RISCO 200 //EA01_MAX_VOL_EM_RISCO:Qtd max de contratos em risco; Sao os contratos pendentes da posicao.
//#define EA_DEBUG false nn //EA_DEBUG:se true, grava informacoes de debug no log do EA.
#define EA04_DX_TRAILLING_STOP 1.0 //EA04_DX_TRAILLING_STOP:% do DX1 para fazer o trailling stop
#define EA10_DX1 0.2 //EA10_DX1:Tamanho do DX em relacao a banda em %;
//---------------------------------------------------------------------------------------------
// configurando a banda de bollinguer...
input group "indicador banda de bollinguer"
input int BB_QTD_PERIODOS = 21 ; //BB_QTD_PERIODOS.
input int BB_DESVIOS = 2 ; //BB_DESVIOS.
input ENUM_APPLIED_PRICE BB_APLIED_PRICE = PRICE_WEIGHTED; //BB_APLIED_PRICE.
input double EA_LIMITE_ENTRADA_BBM = 10 ; //LIMITE_ENTRADA_BBM
input ENUM_TIPO_ENTRADA_PERMITDA EA_TIPO_ENTRADA_PERMITIDA = ENTRADA_TODAS;//TIPO_ENTRADA_PERMITIDA Tipos de entrada permitidas (sel,buy,ambas e nenhuma)
//---------------------------------------------------------------------------------------------
// configurando a feira...
input group "indicador feira"
//input bool FEIRA01_DEBUG = false ; // se true, grava informacoes de debug no log.
input bool FEIRA02_GERAR_VOLUME = false ; // se true, gera volume baseado nos ticks. Usa em papeis que nao informam volume, tais como o DJ30.
input bool FEIRA03_GERAR_OFERTAS = false ; // se true, gera ofertas baseadas nos ticks. Usa em papeis que nao informam o livro de ofertas.
//input int FEIRA04_QTD_BAR_PROC_HIST = 0 ; // Qtd barras historicas a processar. Em modo DEBUG, convem deixar este valor baixo pra nao sobrecarregar o arquivo de log.
//input double FEIRA05_BOOK_OUT = 0 ; // Porcentagem das extremidades dos precos do book que serão desprezados.
input int FEIRA06_QTD_SEGUNDOS = 60 ; // Quantidade de segundos que serao acumulads para calcular as medias.
input bool FEIRA07_GERAR_SQL_LOG = false ; // Se true grava comandos sql no log para insert do book em tabela postgres.
//input bool FEIRA99_ADD_IND_2_CHART = true ; // Se true apresenta o idicador feira no grafico.
input bool EA_PROCESSAR_BOOK = true ; // se true, processa o book de ofertas.
#define FEIRA01_DEBUG false // se true, grava informacoes de debug no log.
#define FEIRA04_QTD_BAR_PROC_HIST 0 // Qtd barras historicas a processar. Em modo DEBUG, convem deixar este valor baixo pra nao sobrecarregar o arquivo de log.
#define FEIRA05_BOOK_OUT 0 // Porcentagem das extremidades dos precos do book que serão desprezados.
#define FEIRA99_ADD_IND_2_CHART true // Se true apresenta o idicador feira no grafico.
//---------------------------------------------------------------------------------------------
// configurando o horario de inicio e fim da operacao...
input group "horario de operacao"
input int HR_INI_OPERACAO = 09; // Hora de inicio da operacao;
input int MI_INI_OPERACAO = 30; // Minuto de inicio da operacao;
input int HR_FIM_OPERACAO = 18; // Hora de fim da operacao;
input int MI_FIM_OPERACAO = 50; // Minuto de fim da operacao;
//---------------------------------------------------------------------------------------------
//
// group "sleep e timer"
input uint EA_SLEEP_INI_OPER = 60 ;//SLEEP_INI_OPER:Aguarda estes segundos para iniciar abertura de posicoes.
input int EA_SLEEP_ATRASO = 0 ;//SLEEP_TESTE_ONLINE:atraso em milisegundos antes de enviar ordens.
input int EA_QTD_SEG_TIMER = 250;//QTD_SEG_TIMER:Tempo de acionamento do timer.
//---------------------------------------------------------------------------------------------
CiBands* m_ibb;
//CiCCI* m_icci;
CiAD* m_iad;
CiMFI* m_imfi;
CiMA* m_ima;
osc_estatistic2 m_est;
MqlDateTime m_date;
string m_name = "MINION-02-P5-HFT";
CSymbolInfo m_symb ;
CPositionInfo m_posicao ;
CAccountInfo m_cta ;
double m_tick_size ;// alteracao minima de preco.
double m_stopLossOrdens ;// stop loss;
double m_tkprof ;// take profit;
double m_distMediasBook ;// Distancia entre as medias Ask e Bid do book.
osc_minion_trade m_trade;
osc_minion_trade_estatistica m_trade_estatistica;
//osc_ind_minion_feira* m_feira;
int BB_SUPERIOR = 1;
int BB_INFERIOR = -1;
int BB_MEDIA = 0;
int BB_DESCONHECIDA = 2;
int m_ult_toque = BB_DESCONHECIDA; // indica em que banda foi o ultimo toque do preco.
int m_pri_toque = BB_DESCONHECIDA; // indica em que banda estah o primeiro toque de preco; A operacao eh aberta no primeiro toque na banda;
int m_ult_oper = BB_DESCONHECIDA; // indica em que banda foi a ultima operacao;
bool m_comprado = false;
bool m_vendido = false;
//double m_precoPosicao = 0 ; // valor medio de entrada da posicao
double m_posicaoVolumePend = 0; // volume pendente pra fechar a posicao atual
double m_posicaoVolumeTot = 0; // volume total de contratos da posicao, inclusive os que jah foram fechados
long m_positionId = -1;
double m_volComprasNaPosicao = 0; // quantidade de compras na posicao atual;
double m_volVendasNaPosicao = 0; // quantidade de vendas na posicao atual;
double m_capitalInicial = 0; // capital justamente antes de iniciar uma posicao
double m_capitalLiquido = 0; // capital atual durante a posicao.
double m_lucroPosicao = 0; // lucro da posicao atual
double m_lucroPosicao4Gain = 0; // lucro para o gain caso a quantidade de contratos tenha ultrapassado o valor limite.
double m_lucroStops = 0; // lucro acumulado durante stops de quantidade
double m_tstop = 0 ;
string m_positionCommentStr = "0";
long m_positionCommentNumeric = 0 ;
//--- variaveis atualizadas pela funcao refreshMe...
double m_bbMed = 0;//normalizar( m_ibb.Base(0) ); // preco medio das bandas de bollinguer
double m_bbMedDelta = 0;//normalizar( m_ibb.Base(1) ); // preco medio das bandas de bollinguer no periodo anterior
double m_bbInf = 0;//normalizar( m_ibb.Lower(0) ); // preco da banda de bollinger inferior
double m_bbInfDelta = 0;//normalizar( m_ibb.Lower(0) ); // preco da banda de bollinger inferior
double m_bbSup = 0;//normalizar( m_ibb.Upper(0) ); // preco da banda de bollinger superior
double m_bbSupDelta = 0;//normalizar( m_ibb.Upper(0) ); // preco da banda de bollinger superior
double m_bdx = 0;//MathAbs ( sup-med ); // distancia entre as bandas de bollinger e a media, sem sinal;
double m_dx1 = 0;//normalizar( DX1*bdx ); // normalmente 20% da distancia entre a media e uma das bandas.
int m_qtdOrdens = 0;
int m_qtdPosicoes = 0;
double m_posicaoProfit = 0;
int m_min_ult_trade = 0;
double m_ask = 0;
double m_bid = 0;
double m_val_order_4_gain = 0;
double m_max_barra_anterior = 0;
double m_min_barra_anterior = 0;
//--precos medios do book e do timesAndTrades
double m_pmBid = 0;
double m_pmAsk = 0;
double m_pmBok = 0;
double m_pmBuy = 0;
double m_pmSel = 0;
double m_pmTra = 0;
// precos no periodo
double m_phigh = 0; //-- preco maximo no periodo
double m_plow = 0; //-- preco minimo no periodo
double m_comprometimento_up = 0;
double m_comprometimento_dw = 0;
//-- controle das inclinacoes
double m_inclSel = 0;
double m_inclBuy = 0;
double m_inclTra = 0;
double m_inclBok = 0;
double m_inclSelAbs = 0;
double m_inclBuyAbs = 0;
double m_inclTraAbs = 0;
double m_inclEntrada= 0; // inclinacao usada na entrada da operacao.
string m_apmb = "IN" ; //string que identifica ordens de abertura de posicoes na media das ofertas do book.
string m_apmb_sel = "INS"; //string que identifica ordens de abertura de posicoes na media das ofertas do book.
string m_apmb_buy = "INB"; //string que identifica ordens de abertura de posicoes na media das ofertas do book.
string m_apmb_ns = "INN"; //string que identifica ordens de abertura de posicoes na media das ofertas do book.
string m_strRajada = "RJ" ; //string que identifica rajadas de abertura de novas posicoes.
MqlRates m_rates[];
string m_comment_fixo;
string m_comment_var;
double m_razaoVolReal = 0;
double m_razaoVolTick = 0;
int m_qtd_erros = 0;
double m_maior_sld_do_dia = 0;
double m_sld_sessao_atu = 0;
double m_rebaixamento_atu = 0;
int m_day = 0;
bool m_mudou_dia = false;
bool m_acionou_stop_rebaixamento_saldo = false;
int m_spread_maximo_in_points = 0;
int m_ganhos_consecutivos = 0;
int m_perdas_consecutivas = 0;
long m_tempo_posicao_atu = 0;
long m_tempo_posicao_ini = 0;
int m_stop_qtd_contrat = 0; // EA_STOP_QTD_CONTRAT; Eh o tamanho do chunk;
int m_stop_chunk = 0; // EA_STOP_CHUNK; Eh o tamanho do chunk;
double m_stop_porc = 0; // EA_STOP_PORC_L1 ; Eh a porcentagem inicial para o ganho durante o passeio;
int m_qtd_ticks_4_gain_new= 0;
int m_qtd_ticks_4_gain_ini= 0;
int m_qtd_ticks_4_gain_raj= 0;
double m_passo_rajada = 0;
double m_vol_lote_ini = 0;
double m_vol_lote_raj = 0;
// para acelerar a abertura da primeira ordem de fechamento a posicao
double m_val_close_position_sel = 0;
double m_vol_close_position_sel = 0;
double m_val_close_position_buy = 0;
double m_vol_close_position_buy = 0;
// controle de fechamento de posicoes
bool m_fechando_posicao = false;
ulong m_ordem_fechamento_posicao = 0;
// controle de abertura de posicoes
bool m_abrindo_posicao = false;
ulong m_ordem_abertura_posicao_sel = 0;
ulong m_ordem_abertura_posicao_buy = 0;
// controles de apresentacao das variaveis de debug na tela...
string m_str_linhas_acima = "";
string m_release = "[RELEASE TESTE]";
// variaveis usadas nas estrategias de entrada, visando diminuir a quantidade de alteracoes e cancelamentos com posterior criacao de ordens de entrada.
double m_precoUltOrdemInBuy = 0;
double m_precoUltOrdemInSel = 0;
// string com o simbolo sendo operado
string m_symb_str;
// milisegundos que devem ser aguardados antes de iniciar a operacao
int m_aguardar_para_abrir_posicao = 0;
// algumas estrategias permitem uma tolerancia do preco para entrada na posicao...
double m_shift = 0;
datetime m_time_in_seconds_ini_day = TimeCurrent();
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit(){
#ifdef COMPILE_PRODUCAO m_release = "[RELEASE PRODU]";#endif
Print("***** Iniciando " + m_name + ":" + IntegerToString(EA08_MAGIC) + " as " + TimeToString( TimeCurrent() ) +"... ******");
Print(":-| ", m_release);
Print(":-| ", m_release);
Print(":-| ", m_release);
inicializarVariaveisRecebidasPorParametro();
// definindo local da tela onde serao mostradas as variaveis de debug...
m_str_linhas_acima = "";
for( uint i=0; i<EA_SHOW_TELA_LINHAS_ACIMA; i++){
StringAdd(m_str_linhas_acima,"\n");
}
m_symb.Name( Symbol() ); // inicializacao da classe CSymbolInfo
m_symb_str = Symbol();
m_symb.Refresh (); // propriedades do simbolo. Basta executar uma vez.
m_symb.RefreshRates (); // valores do tick. execute uma vez por tick.
m_tick_size = m_symb.TickSize(); //Obtem a alteracao minima de preco
//m_qtd_ticks_4_gain = EA_QTD_TICKS_4_GAIN_L5;
m_stopLossOrdens = m_symb.NormalizePrice(EA_TICKS_STOP_LOSS *m_tick_size);
m_tkprof = m_symb.NormalizePrice(EA_TICKS_TKPROF *m_tick_size);
m_trade.setMagic (EA08_MAGIC);
m_trade.setStopLoss(m_stopLossOrdens);
m_trade.setTakeProf(m_tkprof);
ArraySetAsSeries(m_rates,true);
if(EA_PROCESSAR_BOOK) MarketBookAdd ( m_symb_str );
// estatistica de trade...
m_time_in_seconds_ini_day = StringToTime( TimeToString( TimeCurrent(), TIME_DATE ) );
m_trade_estatistica.initialize();
m_trade_estatistica.setCotacaoMoedaTarifaWDO(EA_DOLAR_TARIFA);
m_est.initialize(FEIRA06_QTD_SEGUNDOS); // quantidade de segundos que serao usados no calculo das medias.
m_est.setSymbolStr( m_symb_str );
m_spread_maximo_in_points = (int)(EA_SPREAD_MAXIMO*m_tick_size);
m_shift = normalizar(EA_TOLERANCIA_ENTRADA*m_tick_size); // tolerancia permitida para entrada em algumas estrategias
m_maior_sld_do_dia = m_cta.Balance(); // saldo da conta no inicio da sessao;
m_sld_sessao_atu = m_cta.Balance();
m_capitalInicial = m_cta.Balance();
m_comment_fixo = "LOGIN:" + DoubleToString(m_cta.Login(),0) +
" TRADEMODE:" + m_cta.TradeModeDescription() +
" MARGINMODE:" + m_cta.MarginModeDescription() +
" " + m_release;
//"alavancagem:" + m_cta.Leverage() + "\n" +
//"stopoutmode:" + m_cta.StopoutModeDescription() + "\n" +
//"max_ord_pend:"+ m_cta.LimitOrders() + "\n" + // max ordens pendentes permitidas
Comment(m_comment_fixo);
m_trade.setVolLote ( m_symb.LotsMin() );
// inicializando a banda de bolinguer...
m_ibb = new CiBands();
if ( !m_ibb.Create(_Symbol , //string string, // Symbol
PERIOD_CURRENT , //Period
BB_QTD_PERIODOS , //int ma_period, // Averaging period
0 , //int ma_shift, // Horizontal shift
BB_DESVIOS , //double deviation // Desvio
PRICE_WEIGHTED //int applied // (máximo + mínimo)/2 (see ENUM_APPLIED_PRICE)
)
){
Print(m_name,": Erro inicializando o indicador BB :-(");
return(1);
}
// inicializando CCI...
//m_icci = new CiCCI();
//if ( !m_icci.Create( _Symbol , //string string, // Symbol
// PERIOD_CURRENT , //ENUM_TIMEFRAMES period, // Period
// 14, //BB_QTD_PERIODO_MA, //int ma_period, // Averaging period
// PRICE_MEDIAN //int applied // (máximo + mínimo)/2 (see ENUM_APPLIED_PRICE)
// )
// ){
// Print(m_name,": Erro inicializando o indicador CCI :-(");
// return(1);
//}
// inicializando a feira...
//m_feira = new osc_ind_minion_feira();
//if( !m_feira.Create( m_symb_str, PERIOD_CURRENT ,
// FEIRA01_DEBUG ,
// FEIRA02_GERAR_VOLUME ,
// FEIRA03_GERAR_OFERTAS ,
// FEIRA04_QTD_BAR_PROC_HIST,
// FEIRA05_BOOK_OUT ,
// FEIRA06_QTD_SEGUNDOS ,
// FEIRA07_GERAR_SQL_LOG ,
// IFEIRA_VERSAO_0307 ) ){
// Print(m_name," :-( Erro inicializando o indicador FEIRA!", GetLastError() );
// return(1);
//}
//
//// adicionando FEIRA ao grafico...
//if( FEIRA99_ADD_IND_2_CHART ){ m_feira.AddToChart(0,0); }
//m_feira.Refresh();
//Print(m_name,":-| Aguardando 5 seg apos colocar o indicador feira no grafico... " );
//Sleep (5000);
m_precoUltOrdemInBuy = 0;
m_precoUltOrdemInSel = 0;
EventSetMillisecondTimer(EA_QTD_SEG_TIMER);
Print(m_name,":-| Expert ", m_name, " Criado Timer de ",EA_QTD_SEG_TIMER," milisegundos !!! " );
Print(m_name,":-) Expert ", m_name, " inicializado !! " );
Print(":-| ", m_release);
Print(":-| ", m_release);
Print(":-| ", m_release);
return(0);
}
double m_len_canal_ofertas = 0; // tamanho do canal de oefertas do book.
double m_len_barra_atual = 0; // tamanho da barra de trades atual.
double m_volatilidade = 0; // calculamos a volatilidade como a porcentagem da tamanho da barra atual em relacao ao canal de ofertas;
double m_volatilidade_4_seg = 0; // volatilidade por segundo.
double m_volatilidade_4_seg_media = 0; // volatilidade por segundo media.
double m_volatilidade_4_seg_qtd = 0; // qtd de registros da volatilidade por segundo. Usado para calcular a volatilidade por segundo media.
double m_volatilidade_4_seg_tot = 0; // soma dos registros da volatilidade por segundo. Usado para calcular a volatilidade por segundo media.
double m_volTradePorSegMedio= 0;
double m_volTradePorSegQtd = 1.0;
double m_volTradePorSegTot = 0;
double m_volTradePorSeg = 0; // volume de agressoes por segundo.
double m_volTradePorSegBuy = 0; // volume de agressoes de compra por segundo.
double m_volTradePorSegSel = 0; // volume de agressoes de venda por segundo.
int m_volTradePorSegDeltaPorc = 0; // % da diferenca do volume por segundo do vencedor. Se for positivo, o vencedor eh buy, se negativo eh sell.
double m_desbUp0 = 0;
double m_desbUp1 = 0;
double m_desbUp2 = 0;
double m_desbUp3 = 0;
ulong m_trefreshMe = 0;
ulong m_trefreshFeira = 0;
ulong m_trefreshCCI = 0;
ulong m_trefreshTela = 0;
ulong m_trefreshRates = 0;
ulong m_tcontarTransacoes = 0;
ulong m_tcloseRajada = 0;
bool m_estou_posicionado = false;
double m_probAskDescer = 0;
double m_probAskSubir = 0;
double m_probBidDescer = 0;
double m_probBidSubir = 0;
MqlTick m_tick_est;
void refreshMe(){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshMe = GetMicrosecondCount(); #endif
m_posicao.Select( m_symb_str );
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshRates = GetMicrosecondCount(); #endif
m_symb.RefreshRates();
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshRates = GetMicrosecondCount()-m_trefreshRates; #endif
//#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshFeira = GetMicrosecondCount(); #endif
//m_feira.Refresh();
//#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshFeira = GetMicrosecondCount()-m_trefreshFeira; #endif
// adicionando o tick ao componente estatistico...
//MqlTick tick;
SymbolInfoTick(m_symb_str,m_tick_est);
m_est.addTick(m_tick_est);
m_probAskDescer = m_est.getPrbAskDescer();
m_probAskSubir = m_est.getPrbAskSubir ();
m_probBidDescer = m_est.getPrbBidDescer();
m_probBidSubir = m_est.getPrbBidSubir ();
m_ibb.Refresh (-1);
//m_ima.Refresh (-1);
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshCCI = GetMicrosecondCount();#endif
//m_icci.Refresh(-1);
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshCCI = GetMicrosecondCount()-m_trefreshCCI;#endif
//m_iad.Refresh (-1);
//m_imfi.Refresh(-1);
m_trade.setStopLoss( m_stopLossOrdens );
m_trade.setTakeProf( m_tkprof );
m_trade.setVolLote ( m_symb.LotsMin() );
m_ask = m_symb.Ask();
m_bid = m_symb.Bid();
m_desbUp0 = m_est.getDesbalanceamentoUP0();// m_feira.getDesbUP0(0);
m_desbUp1 = m_est.getDesbalanceamentoUP1();// m_feira.getDesbUP1(0);
m_desbUp2 = m_est.getDesbalanceamentoUP2();// m_feira.getDesbUP1(0);
m_desbUp3 = m_est.getDesbalanceamentoUP3();// m_feira.getDesbUP1(0);
calcDistPrecoMaxMin();
// atualizando maximo, min e tamnaho das barras anterior de preco atual e anterior...
CopyRates(m_symb_str,_Period,0,2,m_rates);
m_max_barra_anterior = m_rates[1].high;
m_min_barra_anterior = m_rates[1].low ;
m_bbMed = m_ibb.Base (0);//normalizar( m_ibb.Base(0) ); // preco medio das bandas de bollinguer
m_bbMedDelta = m_bbMed-m_ibb.Base (1);//normalizar( m_ibb.Base(0) ); // preco medio das bandas de bollinguer
m_bbInf = m_ibb.Lower(0);//normalizar( m_ibb.Lower(0) ); // preco da banda de bollinger inferior
m_bbInfDelta = m_bbInf-m_ibb.Lower(1);//normalizar( m_ibb.Lower(0) ); // desvio da banda de bollinger inferior. Se negativo, o angulo eh pra baixo.
m_bbSup = m_ibb.Upper(0);//normalizar( m_ibb.Upper(0) ); // preco da banda de bollinger superior
m_bbSupDelta = m_bbSup-m_ibb.Upper(1);//normalizar( m_ibb.Upper(0) ); // desvio da banda de bollinger superior. Se positivo, o angulo eh pra cima.
m_bdx = m_bbSup-m_bbMed; //distancia entre as bandas de bollinger e a media, sem sinal;
m_dx1 = EA10_DX1*m_bdx ; //normalizar( EA10_DX1*m_bdx); // normalmente 20% da distancia entre a media e uma das bandas.
calcCoefEntrelacamentoMedio();
m_qtdOrdens = OrdersTotal();
m_qtdPosicoes = PositionsTotal();
// adminstrando posicao aberta...
if( m_qtdPosicoes > 0 ){
//m_posicaoProfit = 0;
if ( PositionSelect (m_symb_str) ){ // soh funciona em contas hedge
//if ( m_posicao.Select(m_symb.Name()) ){ // soh funciona em contas hedge
if( PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY ){
setCompradoSoft();
}else{
setVendidoSoft();
}
// primeiro refresh apos abertura da posicao...
if( !m_estou_posicionado && !m_fechando_posicao && EA07_ABRIR_POSICAO != NAO_OPERAR ){
//<TODO> chame o closerajada aqui para que nao seja atrasado pelo cancelamento de ordens apmb.
//doCloseRajada(m_passo_rajada, m_vol_lote_raj, m_qtd_ticks_4_gain_ini);
// se tem posicao aberta, cancelamos as ordens apmb que porventura tenham ficado abertas
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb);//<TODO: DESCOMENTE e transforme em parametro>
m_estou_posicionado = true;
// <TODO>: se estah fechando posicao, verifique se ha uma ordem stop dentro da posicao. se tiver, desmarque a flag de fechamento da posicao...
//if( m_fechando_posicao == true ){
// if(EA_DEBUG)Print( __FUNCTION__,":-| Cancelando status de fechamento de posicao, pois nao ha posicao aberta! ticket da ordem de fechamento=", m_ordem_fechamento_posicao );
// m_fechando_posicao = false;
// m_ordem_fechamento_posicao = 0;
//}
// deu ruim...
//if( m_fechando_posicao ){
// #ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print( __FUNCTION__,":-| Cancelando status de fechamento de posicao, pois nao ha posicao aberta! ticket da ordem de fechamento=", m_ordem_fechamento_posicao );#endif
// m_fechando_posicao = false;
// m_ordem_fechamento_posicao = 0;
//}
}
m_posicaoProfit = PositionGetDouble (POSITION_PROFIT );
m_precoPosicao = PositionGetDouble (POSITION_PRICE_OPEN ); // este eh o valor medio de abertura da posicao.
if(m_val_order_4_gain==0) m_val_order_4_gain = m_precoPosicao; // este eh o valor de fato de abertura da posicao.
m_posicaoVolumePend = PositionGetDouble (POSITION_VOLUME );
m_positionId = PositionGetInteger(POSITION_IDENTIFIER );
m_positionCommentStr = PositionGetString (POSITION_COMMENT );
m_positionCommentNumeric = StringToInteger (m_positionCommentStr);
m_capitalLiquido = m_cta.Equity();
m_lucroPosicao = m_capitalLiquido - m_capitalInicial; // voltou versao em 03/02/2020 as 11:50
//m_lucroPosicao = m_posicaoProfit;
// se o comentario da posicao for numerico, precisamos saber pois trata-se de um engano e deveremos fechar a posicao e todas as ordens.
//if( !MathIsValidNumber(m_positionCommentNumeric) ) m_positionCommentNumeric = 0;
if( estouComprado() ) m_posicaoVolumeTot = m_volComprasNaPosicao;
if( estouVendido () ) m_posicaoVolumeTot = m_volVendasNaPosicao ;
m_lucroPosicao4Gain = (m_posicaoVolumeTot*m_stop_porc);
if( m_abrindo_posicao ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) Print(__FUNCTION__, ":-| Cancelando status de abertura de posicao, pois ha posicao aberta! tktSell=", m_ordem_abertura_posicao_sel, " tktBuy=", m_ordem_abertura_posicao_buy ); #endif
m_abrindo_posicao = false;
m_ordem_abertura_posicao_sel = 0;
m_ordem_abertura_posicao_buy = 0;
}
// variaveis usadas para diminuir a quantidade de alteracoes e cancelamentos com posterior criacao de ordens de entrada.
m_precoUltOrdemInBuy = 0;
m_precoUltOrdemInSel = 0;
}else{
// aqui neste bloco, estah garantido que nao ha posicao aberta...
m_qtdPosicoes = 0;
m_capitalInicial = m_cta.Balance(); // se nao estah na posicao, atualizamos o capital inicial da proxima posicao.
m_comprado = false;
m_vendido = false;
m_estou_posicionado = false;
m_lucroPosicao = 0;
m_lucroPosicao4Gain = 0;
m_posicaoVolumePend = 0; //versao 02-085
m_posicaoProfit = 0;
m_posicaoVolumeTot = 0;
m_val_order_4_gain = 0; // zerando o valor da primeira ordem da posicao...
m_tempo_posicao_atu = 0;
m_tempo_posicao_ini = 0;
m_positionId = -1;
m_lucroPosicao4Gain = 0;
}
if( m_fechando_posicao && m_qtdOrdens == 0){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print( __FUNCTION__,":-| Cancelando status de fechamento de posicao, pois nao ha posicao aberta! ticket da ordem de fechamento=", m_ordem_fechamento_posicao );#endif
m_fechando_posicao = false;
m_ordem_fechamento_posicao = 0;
}
}else{
// aqui neste bloco, estah garantido que nao ha posicao aberta...
m_capitalInicial = m_cta.Balance(); // se nao estah na posicao, atualizamos o capital inicial da proxima posicao.
m_comprado = false;
m_vendido = false;
m_estou_posicionado = false;
m_lucroPosicao = 0;
m_lucroPosicao4Gain = 0;
m_posicaoVolumePend = 0; //versao 02-085
m_posicaoProfit = 0;
m_posicaoVolumeTot = 0;
m_val_order_4_gain = 0; // zerando o valor da primeira ordem da posicao...
m_tempo_posicao_atu = 0;
m_tempo_posicao_ini = 0;
m_positionId = -1;
m_lucroPosicao4Gain = 0;
//bool m_ganhou_ultimo_trade = false;
// administrando ganhos e perdas consecutivas...
// primeira passagem apos o encerramento de uma posicao
//if( m_cta.Balance() > m_capitalInicial && m_capitalInicial != 0 ){
// m_ganhos_consecutivos++;
// m_perdas_consecutivas = 0;
// //m_ganhou_ultimo_trade = true;
//}else if(m_cta.Balance() < m_capitalInicial && m_capitalInicial != 0){
// m_perdas_consecutivas++;
// m_ganhos_consecutivos = 0;
// //m_ganhou_ultimo_trade = false;
//}
if( m_fechando_posicao && m_qtdOrdens==0){
if(EA_DEBUG)Print( __FUNCTION__,":-| Cancelando status de fechamento de posicao, pois nao ha posicao aberta! ticket da ordem de fechamento=", m_ordem_fechamento_posicao );
m_fechando_posicao = false;
m_ordem_fechamento_posicao = 0;
}
// Deixando o stop loss de posicao preparado. Quando posicionado, nao altera o stop loss de posicao.
calcStopLossPosicao();
}
//-- precos medios do book
m_pmBid = m_est.getPrecoMedBookBid ();// m_feira.getPrecoMedioBid(0);
m_pmAsk = m_est.getPrecoMedBookAsk ();// m_feira.getPrecoMedioAsk(0);
m_pmBok = m_est.getPrecoMedBook ();// m_feira.getPrecoMedioBok(0);
m_pmSel = m_est.getPrecoMedTradeSel();// m_feira.getPrecoMedioSel(0);
m_pmBuy = m_est.getPrecoMedTradeBuy();// m_feira.getPrecoMedioBuy(0);
m_pmTra = m_est.getPrecoMedTrade ();// m_feira.getPrecoMedioTra(0);
// canal de ofertas no book...
m_len_canal_ofertas = m_pmAsk - m_pmBid;
//-- precos no periodo
m_phigh = m_est.getTradeHigh();// m_feira.getPrecoHigh(0);
m_plow = m_est.getTradeLow ();// m_feira.getPrecoLow(0);
m_len_barra_atual = m_phigh - m_plow;
// calculamos a volatilidade como a porcentagem da tamanho da barra atual em relacao ao canal de ofertas;
if( m_len_canal_ofertas > 0 ) m_volatilidade = m_len_barra_atual / m_len_canal_ofertas;
// calcumado a volatilidade por segundo e a volatilidade por segundo media
m_volatilidade_4_seg = m_len_barra_atual/FEIRA06_QTD_SEGUNDOS;
m_volatilidade_4_seg_qtd++;
m_volatilidade_4_seg_tot += m_volatilidade_4_seg;
m_volatilidade_4_seg_media = m_volatilidade_4_seg_tot/m_volatilidade_4_seg_qtd;
// ticks por segundo. medida de volatilidade e da forca das agressoes de compra evenda...
m_volTradePorSeg = m_est.getVolTradeTotPorSeg() ;// m_feira.getVolTrade (0)/FEIRA06_QTD_SEGUNDOS;
m_volTradePorSegBuy = m_est.getVolTradeBuyPorSeg() ;// m_feira.getVolTradeBuy(0)/FEIRA06_QTD_SEGUNDOS;
m_volTradePorSegSel = m_est.getVolTradeSelPorSeg() ;// m_feira.getVolTradeSel(0)/FEIRA06_QTD_SEGUNDOS;
m_volTradePorSegDeltaPorc = m_volTradePorSeg==0?0:((m_volTradePorSegBuy - m_volTradePorSegSel)/m_volTradePorSeg)*100;
m_volTradePorSegTot += m_volTradePorSeg;
m_volTradePorSegMedio = m_volTradePorSegTot/m_volTradePorSegQtd++;
// aceleracoes de volume
//double m_aceVolTradePorSeg = 0;
//m_aceVolTradePorSeg = m_volTradePorSeg - m_feira.getVolTrade(1)/FEIRA06_QTD_SEGUNDOS
//--inclinacoes dos precos medios de compra e venda...
m_inclSel = m_est.getInclinacaoTradeSel();// m_feira.getInclinacaoSel(0);
m_inclBuy = m_est.getInclinacaoTradeBuy();// m_feira.getInclinacaoBuy(0);
m_inclTra = m_est.getInclinacaoTrade ();// m_feira.getInclinacaoTra(0);
m_inclBok = m_est.getInclinacaoBook ();// m_feira.getInclinacaoBok(0);
m_inclSelAbs = MathAbs(m_inclSel);
m_inclBuyAbs = MathAbs(m_inclBuy);
m_inclTraAbs = MathAbs(m_inclTra);
//-- Informa a maxima ou minima da vela anterior caso tenha havido comprometimento institucional naquela vela.
//m_comprometimento_up = m_feira.getSinalCompromissoUp(1);
//m_comprometimento_dw = m_feira.getSinalCompromissoDw(1);
/*
//-- diminuindo ou aumentando a quantidade de ticks para o ganho, o volume dos lotes e o passo das rajadas, em funcao da volatilidade.
//-- Esperase que a quantidade de ticks para o gain seja maior com o aumento da volatilidade e
//-- o volume seja maior quando a volatilidade for menor.
if( EA_PASSO_DINAMICO ){
//if( !m_estou_posicionado ){ // tentativa de resolver bug que faz abrir muitas ordens no passo dinamico
// com essa condicao, o passo decidido quando abre a posicao, eh mantido durante
// a vida da posicao.
// outra tentativa de resolver o bug que faz abrir muitas ordens no passo dinamico.
// aguarda um intervalo minimo antes de mudar o passo.
//m_qtd_ticks_4_gain_new = (int)((( m_len_barra_atual )*EA_PORC_PASSO_DINAMICO)/m_tick_size);
m_qtd_ticks_4_gain_new = (int)m_volatilidade_4_seg_media; // testando o passo dinamico com a valatilidade por segundo
if( m_qtd_ticks_4_gain_new<EA_PASSO_DINAMICO_MIN ){m_qtd_ticks_4_gain_new=EA_PASSO_DINAMICO_MIN;}
if( m_qtd_ticks_4_gain_new>EA_PASSO_DINAMICO_MAX ){m_qtd_ticks_4_gain_new=EA_PASSO_DINAMICO_MAX;}
if( m_qtd_ticks_4_gain_new > m_qtd_ticks_4_gain_ini + EA_INTERVALO_PASSO ||
m_qtd_ticks_4_gain_new < m_qtd_ticks_4_gain_ini - EA_INTERVALO_PASSO ){
//m_qtd_ticks_4_gain_ini = (int)((( m_len_barra_atual )*EA_PORC_PASSO_DINAMICO)/m_tick_size);
m_qtd_ticks_4_gain_ini = m_qtd_ticks_4_gain_new;
m_qtd_ticks_4_gain_raj = m_qtd_ticks_4_gain_new;
m_passo_rajada = m_qtd_ticks_4_gain_new;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L1;
m_vol_lote_ini = EA_VOL_LOTE_INI_L1;
}
// se EA_STOP_PORC_DINAMICO estiver habilitado, a porcentagem da quantidade de contratos usada para calcular
// a saida da posicao, fica dinamica. Neste caso o parametro EA_STOP_PORC_L1 nao tem efeito.
if( EA_STOP_PORC_DINAMICO ){
m_lucroPosicao4Gain = m_posicaoVolumeTot*m_qtd_ticks_4_gain_ini;
}
}else{
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L1;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L1;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L1;
m_vol_lote_ini = EA_VOL_LOTE_INI_L1;
m_passo_rajada = EA_PASSO_RAJ_L1;
}
*/
/*
}else if(taxaVolumeEstahL1() ){
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L1;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L1;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L1;
m_vol_lote_ini = EA_VOL_LOTE_INI_L1;
m_passo_rajada = EA_PASSO_RAJ_L1;
}else if (taxaVolumeEstahL2() ){
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L2;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L2;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L2;
m_vol_lote_ini = EA_VOL_LOTE_INI_L2;
m_passo_rajada = EA_PASSO_RAJ_L2;
}else if (taxaVolumeEstahL3() ){
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L3;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L3;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L3;
m_vol_lote_ini = EA_VOL_LOTE_INI_L3;
m_passo_rajada = EA_PASSO_RAJ_L3;
}else if (taxaVolumeEstahL4() ){
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L4;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L4;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L4;
m_vol_lote_ini = EA_VOL_LOTE_INI_L4;
m_passo_rajada = EA_PASSO_RAJ_L4;
}else if (taxaVolumeEstahL5() ){
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L5;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L5;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L5;
m_vol_lote_ini = EA_VOL_LOTE_INI_L5;
m_passo_rajada = EA_PASSO_RAJ_L5;
}else{
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_ALTO;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_ALTO;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_ALTO;
m_vol_lote_ini = EA_VOL_LOTE_INI_ALTO;
m_passo_rajada = EA_PASSO_RAJ_ALTO;
}
*/
m_sld_sessao_atu = m_cta.Balance();
if (EA_SHOW_TELA){
#ifndef COMPILE_PRODUCAO if( EA_DEBUG ) m_trefreshTela = GetMicrosecondCount(); #endif
// primeira linha
m_comment_var = " [FECHANDO_POSICAO:" + m_fechando_posicao +"]"+(m_qtdPosicoes==0?"[SEM POSICAO]":estouComprado()?"[COMPRADO]":"[VENDIDO]") +
" ULTORDENS["+ m_precoUltOrdemInBuy +","+ m_precoUltOrdemInSel+"]" + // so pra debug
" PODEABRIRPOS[" + podeAbrirProsicao() + "]" +
//---------------------------
" \nPAS/PAD " + DoubleToString(m_probAskSubir *100.0,0) + "/" +
DoubleToString(m_probAskDescer*100.0,0) +
" DXVELBIDASK/ACEDX:"+IntegerToString(m_volTradePorSegDeltaPorc ) +"/"+
IntegerToString(m_acelVolTradePorSegDeltaPorc) +
" \nPBS/PBD " + DoubleToString(m_probBidSubir *100.0,0) + "/" +
DoubleToString(m_probBidDescer*100.0,0) +
" \nFA/FB " + DoubleToString(m_est.getFluxoAsk() ,0) + "/" +
DoubleToString(m_est.getFluxoBid() ,0) +
" \n------" +
" \npUP3: " + DoubleToString( m_desbUp3*100 ,0) +((m_desbUp3>=EA_DESBALAN_UP3 && EA_DESBALAN_UP3>0)?" *":"") +
" \npUP2: " + DoubleToString( m_desbUp2*100 ,0) +((m_desbUp2>=EA_DESBALAN_UP2 && EA_DESBALAN_UP2>0)?" *":"") +
" \npUP1: " + DoubleToString( m_desbUp1*100 ,0) +((m_desbUp1>=EA_DESBALAN_UP1 && EA_DESBALAN_UP1>0)?" *":"") +
" \npUP0: " + DoubleToString( m_desbUp0*100 ,0) +((m_desbUp0>=EA_DESBALAN_UP0 && EA_DESBALAN_UP0>0)?" *":"") +
" \n------" +
" \npDW0: " + DoubleToString( m_desbUp0*100 ,0) +((m_desbUp0<=EA_DESBALAN_DW0 && EA_DESBALAN_DW0>0)?" *":"") +
" \npDW1: " + DoubleToString( m_desbUp1*100 ,0) +((m_desbUp1<=EA_DESBALAN_DW1 && EA_DESBALAN_DW1>0)?" *":"") +
" \npDW2: " + DoubleToString( m_desbUp2*100 ,0) +((m_desbUp2<=EA_DESBALAN_DW2 && EA_DESBALAN_DW2>0)?" *":"") +
" \npDW3: " + DoubleToString( m_desbUp3*100 ,0) +((m_desbUp3<=EA_DESBALAN_DW3 && EA_DESBALAN_DW3>0)?" *":"") +
" \n------" +
//---------------------------
" \nENTRELAC/DISTANCIA/REGIAO COMPRA/VND LENBARRA: " + DoubleToString(m_coefEntrelaca*100 ,0)+ "/" +
DoubleToString(m_len_canal_entrelacamento ,0)+ "/" +
DoubleToString(m_regiaoPrecoCompra*100,0)+ "/" +
DoubleToString(m_regiaoPrecoVenda *100,0)+ "/ " +
DoubleToString(m_len_barra_atual/m_tick_size, 1)+
" \nVLT/V4S/V4SM/ TFG " + DoubleToString(m_volatilidade ,2)+ "/" +
DoubleToString(m_volatilidade_4_seg ,2)+ "/" +
DoubleToString(m_volatilidade_4_seg_media,2)+ "/ " +
IntegerToString(m_qtd_ticks_4_gain_ini )+
" \nVO4S/VO4SM " + DoubleToString(m_volTradePorSeg ,2)+ "/" +
DoubleToString(m_volTradePorSegMedio ,2)+
" \nProbAcer/PayOut/Kelly " +
DoubleToString(m_trade_estatistica.getProbAcerto () ,2)+"/" +
DoubleToString(m_trade_estatistica.getPayOut () ,2)+"/" +
DoubleToString(m_trade_estatistica.getCoefKelly () ,2)+
" \nPFT PD/TD/PC/PL/VOL WDO " +
DoubleToString(m_trade_estatistica.getProfitDiaWDO () ,2)+"/" +
DoubleToString(m_trade_estatistica.getTarifaDiaWDO () ,2)+"/" +
DoubleToString(m_trade_estatistica.getProfitPorContratoWDO() ,2)+"/" +
DoubleToString(m_trade_estatistica.getProfitDiaLiquidoWDO () ,2)+"/" +
DoubleToString(m_trade_estatistica.getVolumeDiaWDO () ,2)+
" \nPFT PD/TD/PC/PL/VOL WIN " +
DoubleToString(m_trade_estatistica.getProfitDiaWIN () ,2)+"/" +
DoubleToString(m_trade_estatistica.getTarifaDiaWIN () ,2)+"/" +
DoubleToString(m_trade_estatistica.getProfitPorContratoWIN() ,2)+"/" +
DoubleToString(m_trade_estatistica.getProfitDiaLiquidoWIN () ,2)+"/" +
DoubleToString(m_trade_estatistica.getVolumeDiaWIN () ,2)+
" \nPFT PD/TD/PC/PL/VOL XXX " +
DoubleToString(m_trade_estatistica.getProfitDia () ,2)+"/" +
DoubleToString(m_trade_estatistica.getTarifaDia () ,2)+"/" +
DoubleToString(m_trade_estatistica.getProfitPorContrato() ,2)+"/" +
DoubleToString(m_trade_estatistica.getProfitDiaLiquido () ,2)+"/" +
DoubleToString(m_trade_estatistica.getVolumeDia () ,2)+
m_str_linhas_acima +
//" CTA SLD:" + DoubleToString(m_cta.Balance() ,2 ) +
//" CAPLIQ: " + DoubleToString(m_cta.Equity() ,2 ) +
//" VAL_GAIN:" + DoubleToString(m_val_order_4_gain ,_Digits) +
//"\n" + "[POSICIONADO:" + m_estou_posicionado + "] " +(m_qtdPosicoes==0?"SEM POSICAO":estouComprado()?"COMPRADO":"VENDIDO") +
//" m_posicaoProfit: " + DoubleToString(m_posicaoProfit,2)+
//" PROFIT:" + DoubleToString(m_cta.Profit(),2) +
// segunda linha
"\n\nPAS/PFT/OUT/LOS: " + IntegerToString(m_passo_rajada ) +"/"+
DoubleToString(m_lucroPosicao ,0 ) +"/"+
DoubleToString(m_saida_posicao,0 ) +"/"+
//DoubleToString(m_lucroPosicao4Gain,0 ) +"/"+
DoubleToString(m_stopLossPosicao ,0) +
" VOL: " +IntegerToString(porcentagem(m_posicaoVolumePend,m_posicaoVolumeTot,0) ) + "% " +
DoubleToString(m_posicaoVolumePend,_Digits) + "/"+
DoubleToString(m_posicaoVolumeTot ,_Digits) +
" RSLD: " + DoubleToString(m_trade_estatistica.getRebaixamentoSld() ,2) + "/" +
//" RSLD ATU/MAX/MSD: " + DoubleToString(m_rebaixamento_atu ,2 ) + "/" +
DoubleToString(EA_REBAIXAMENTO_MAX,0 ) + "/" +
// DoubleToString(m_maior_sld_do_dia ,2 ) +
" IRUN: " + IntegerToString(m_indRunMenos1*100) + "/" +
IntegerToString(m_indRun *100) + "/" +
IntegerToString(m_indRunMais1 *100) + " "
+ IntegerToString(m_indVarRunMenos1*100) + "/" +
IntegerToString(m_indVarRun *100) + "/" +
IntegerToString(m_indVarRunMais1 *100) +
// terceira linha
"\nQTD_OFERTAS: " + IntegerToString(m_symb.SessionDeals() )+
" OPEN:" + DoubleToString (m_symb.SessionOpen (),_Digits)+
" VWAP:" + DoubleToString (m_symb.SessionAW (),_Digits)+
//" DATA:" + TimeToString (TimeCurrent() )+
" HORA" + TimeToString (TimeCurrent(),TIME_SECONDS )+
" TEMPO_POSICAO:" + IntegerToString(m_tempo_posicao_atu) +
" VOLTOT: " + DoubleToString (m_est.getVolTrade(),2) + //DoubleToString (m_feira.getVolTrade(0),2) +
// "\nABRIR_POSICAO:" + EA07_ABRIR_POSICAO +
// " MAX_VOL_EM_RISCO:" + DoubleToString(EA01_MAX_VOL_EM_RISCO,_Digits) +
// " MAX_REBAIX_SLD:" + DoubleToString(EA_REBAIXAMENTO_MAX ,0 ) +
// " TICKS_STOP_LOSS:" + DoubleToString(EA_TICKS_STOP_LOSS ,0 ) +
// " TICK_SIZE:" + DoubleToString(m_symb.TickSize() ,_Digits ) +
// " TICK_VALUE:" + DoubleToString(m_symb.TickValue(),_Digits ) +
// " POINT:" + DoubleToString(m_symb.Point() ,_Digits ) +
//quarta linha (tiramos)
//"\nposPft/ctaPft: " + DoubleToString(m_posicaoProfit,2)+ "/" +
// DoubleToString(m_cta.Profit(),2) +
//" EA09_INCL_MIN_IN: " + DoubleToString(EA09_INCL_MIN_IN,2)+ // " EA09_INCL_MAX_IN: " + DoubleToString(EA09_INCL_MAX_IN,2)+ "\n" +
///"m_pmBok: " + m_pmBok + "\n" +
///"m_pmTra: " + m_pmTra + "\n" +
///"\n\nm_pmAsk: " + m_pmAsk + " m_ask: " + m_ask + " dist:" + DoubleToString((m_pmAsk-m_ask),_Digits)+ " MAX_ANT " + DoubleToString(m_max_barra_anterior,_Digits) + " COMPROMISSO_UP " + DoubleToString(m_comprometimento_up,_Digits) + " VOLATILIDADE " + DoubleToString(m_volatilidade,2) +
///"\nm_pmBid: " + m_pmBid + " m_bid: " + m_bid + " dist:" + DoubleToString((m_bid-m_pmBid),_Digits)+ " MIN_ANT " + DoubleToString(m_min_barra_anterior,_Digits) + " COMPROMISSO_DW " + DoubleToString(m_comprometimento_dw,_Digits) +
///"VVOL/VMAX/VMIN: " + DoubleToString(m_symb.Volume(),_Digits)+ "/"+ DoubleToString(m_symb.VolumeHigh(),_Digits) + "/"+ DoubleToString(m_symb.VolumeLow(),_Digits) +"\n"+
///"SPREAD: " + DoubleToString(m_symb.Spread(),_Digits) + "\n" + // STOPSLEVEL: " + m_symb.StopsLevel() + " FREEZELEVEL: " + m_symb.FreezeLevel() + "\n" +
///"BID/BHIGH/BLOW: " + DoubleToString(m_symb.Bid(),_Digits) + "/" + DoubleToString(m_symb.BidHigh(),_Digits) +"/"+DoubleToString(m_symb.BidLow(),_Digits) + "\n" +
///"ASK/AHIGH/ALOW: " + DoubleToString(m_symb.Ask(),_Digits) + "/" + DoubleToString(m_symb.AskHigh(),_Digits) +"/"+DoubleToString(m_symb.AskLow(),_Digits) + "\n" +
///"LAS/LHIGH/LLOW: " + DoubleToString(m_symb.Last(),_Digits) + "/" + DoubleToString(m_symb.LastHigh(),_Digits) +"/"+ DoubleToString(m_symb.LastLow(),_Digits) + "\n" +
///////
//"SESSION \n" +
//"QTD_ORD_BUY: " + m_symb.SessionBuyOrders() + "\n" +
//"QTD_ORD_SEL: " + m_symb.SessionSellOrders()+ "\n" +
//"TURNOVER: " + m_symb.SessionTurnover() + "\n" +
//"INTEREST: " + m_symb.SessionInterest() + "\n" +
//"VOL_ORD_BUY: " + m_symb.SessionBuyOrdersVolume() + "\n" +
//"VOL_ORD_SEL: " + m_symb.SessionSellOrdersVolume() + "\n" +
//"\n\nQTD_POS: " + IntegerToString(m_qtdPosicoes) +
// quarta linha
"\nVSEG/BUY/SEL/ALTO/MAX:" + DoubleToString (m_volTradePorSeg ,0 ) + "/" +
DoubleToString (m_volTradePorSegBuy,0 ) + "/" +
DoubleToString (m_volTradePorSegSel,0 ) + "/" +
IntegerToString(EA_VOLSEG_ALTO ) + "/" +
IntegerToString(EA_VOLSEG_MAX_ENTRADA_POSIC ) +
//
//" DBOK:" + DoubleToString (m_desbUp0*100,0) +
" VOLAT/MAX:" + DoubleToString(m_volatilidade ,2 ) + "/" + DoubleToString (EA_VOLAT_ALTA ,2) +
" SPREAD/MAX:"+ DoubleToString(m_symb.Spread() ,_Digits ) +
"/" + IntegerToString(m_spread_maximo_in_points ) +
" INCLI/MAX:"+ DoubleToString(m_inclTra ,2 ) + "/" + DoubleToString(EA_INCL_ALTA ,2) +
//" CCI ANT/ATU/DIF: " + DoubleToString(m_icci.Main(1),2)+"/"+
// DoubleToString(m_icci.Main(0),2)+"/"+
// DoubleToString((m_icci.Main(0)-m_icci.Main(1)),2)+
//
// quinta linha
"\n" + "DELTAVEL/ACED:"+IntegerToString(m_volTradePorSegDeltaPorc ) +"/"+
IntegerToString(m_acelVolTradePorSegDeltaPorc) +
"\n" + strPosicao() +
"\n" + strPermissaoAbrirPosicao();
/*
TimeToStruct(TimeCurrent(),m_date);
int min = (m_date.hour - 9 )*60 +
m_date.min ;
int seg = (min*60) + m_date.sec ;
//if( m_date.min != m_min_ult_trade ) { return true; }
//return true;
int mediaOfertasMin = m_symb.SessionDeals()/min;
int mediaOfertasSeg = m_symb.SessionDeals()/seg;
double tickVolume2 = m_rates[0].tick_volume==0?1:m_rates[0].tick_volume;
double realVolume2 = m_rates[0].real_volume==0?1:m_rates[0].real_volume;
double mediaOfertasSeg2 = mediaOfertasSeg ==0?1:mediaOfertasSeg;
double seg2 = m_date.sec ==0?1:m_date.sec;
double razaoVolReal = realVolume2/(mediaOfertasSeg2*seg2);
double razaoVolTick = tickVolume2/(mediaOfertasSeg2*seg2);
m_razaoVolTick = razaoVolTick;
m_razaoVolReal = razaoVolReal;
string comment_data = "\n QTD_MIN:" + min +
" QTD_SEG:" + seg +
" QTD_OFERTA_MEDIA_MIN:" + mediaOfertasMin +
" QTD_OFERTA_MEDIA_SEG:" + mediaOfertasSeg +
" QTD_OFERTA_JUSTA_NOW:" + mediaOfertasSeg*m_date.sec +
"/" + m_rates[0].real_volume +
" RVOL:" + DoubleToString(razaoVolReal,2) +
" TVOL:" + DoubleToString(razaoVolTick,2);
;
Comment(m_comment_fixo + m_comment_var + comment_data);
*/
Comment(m_comment_fixo + m_comment_var + m_strRun);
//MessageBox( "mensagem de teste", // texto da mensagem
// "Log" // cabeçalho da caixa
// //int flags=0 // define o conjunto de botões na caixa
// );
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_trefreshTela = GetMicrosecondCount()-m_trefreshTela;#endif
}
#ifndef COMPILE_PRODUCAO
if(EA_DEBUG){
m_trefreshMe = GetMicrosecondCount()-m_trefreshMe;
if( m_qtd_print_debug++ % 10 == 0 ){
Print(":-| DEBUG_TIMER:" ,
" m_tcloseRajada=" ,m_tcloseRajada ,
" m_trefreshMe=" ,m_trefreshMe ,
" m_trefreshFeira=" ,m_trefreshFeira ,
//" m_trefreshCCI=" ,m_trefreshCCI ,
" m_trefreshTela=" ,m_trefreshTela ,
" m_trefreshRates=" ,m_trefreshRates );
//" m_tcontarTransacoes=",m_tcontarTransacoes
}
m_trefreshMe = 0;
m_trefreshFeira = 0;
m_trefreshCCI = 0;
m_trefreshTela = 0;
m_trefreshRates = 0;
m_tcontarTransacoes = 0;
m_tcloseRajada = 0;
}
#endif
}
bool passoAutorizado(){
if( EA_PASSO_DINAMICO ){
return m_qtd_ticks_4_gain_new >= EA_PASSO_DINAMICO_MIN && m_qtd_ticks_4_gain_new < EA_PASSO_DINAMICO_MAX;
}
return true;
}
double m_passo_incremento = 0;
void incrementarPasso(){
if( m_passo_incremento == 0) return;
//m_qtd_ticks_4_gain_new += (int)(m_qtd_ticks_4_gain_new*m_passo_incremento);
m_qtd_ticks_4_gain_new += m_passo_incremento;
m_qtd_ticks_4_gain_ini = m_qtd_ticks_4_gain_new;
m_qtd_ticks_4_gain_raj = m_qtd_ticks_4_gain_new;
m_passo_rajada = m_qtd_ticks_4_gain_new;
m_stop_porc = m_stop_porc/m_passo_incremento;
}
void definirPasso(){
if( EA_PASSO_DINAMICO ){
//m_qtd_ticks_4_gain_new = (int)m_volatilidade_4_seg_media; // testando o passo dinamico com a valatilidade por segundo
//<TODO> revise o calculo do passo.
m_qtd_ticks_4_gain_new = (int)(m_passo_dinamico_porc_canal_entrelaca * m_len_canal_entrelacamento ); //<TODO> revise o calculo do passo aqui.
//m_qtd_ticks_4_gain_new = (int)(m_passo_dinamico_porc_canal_entrelaca * (m_len_barra_atual / m_tick_size) ); //<TODO> revise o calculo do passo aqui.
//if( m_qtd_ticks_4_gain_new<EA_PASSO_DINAMICO_MIN ){m_qtd_ticks_4_gain_new=EA_PASSO_DINAMICO_MIN;}
//if( m_qtd_ticks_4_gain_new>EA_PASSO_DINAMICO_MAX ){m_qtd_ticks_4_gain_new=EA_PASSO_DINAMICO_MAX;}
m_qtd_ticks_4_gain_ini = m_qtd_ticks_4_gain_new;
m_qtd_ticks_4_gain_raj = m_qtd_ticks_4_gain_new;
m_passo_rajada = normalizar(m_qtd_ticks_4_gain_new*EA_PASSO_DINAMICO_PORC_T4G);
if( m_passo_rajada < EA_PASSO_DINAMICO_MIN ) m_passo_rajada = EA_PASSO_DINAMICO_MIN;
//EA_STOP_QTD_CONTRAT
//EA_STOP_PORC_L1
m_stop_qtd_contrat = EA_PASSO_DINAMICO_STOP_QTD_CONTRAT;
m_stop_chunk = EA_PASSO_DINAMICO_STOP_CHUNK;
m_stop_porc = m_qtd_ticks_4_gain_new*EA_PASSO_DINAMICO_STOP_REDUTOR_RISCO;
/*
switch(m_qtd_ticks_4_gain_new){
case 1: {m_stop_qtd_contrat = 24; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 2: {m_stop_qtd_contrat = 12; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 3: {m_stop_qtd_contrat = 8 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 4: {m_stop_qtd_contrat = 6 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 5: {m_stop_qtd_contrat = 5 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 25 ticks por chunk; passeio de 250 ticks;
case 6: {m_stop_qtd_contrat = 4 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 7: {m_stop_qtd_contrat = 4 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 28 ticks por chunk; passeio de 280 ticks;
case 8: {m_stop_qtd_contrat = 3 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 9: {m_stop_qtd_contrat = 3 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 27 ticks por chunk; passeio de 240 ticks;
case 10: {m_stop_qtd_contrat = 2 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 20 ticks por chunk; passeio de 240 ticks;
case 11: {m_stop_qtd_contrat = 2 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 22 ticks por chunk; passeio de 240 ticks;
case 12: {m_stop_qtd_contrat = 2 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 24 ticks por chunk; passeio de 240 ticks;
case 13: {m_stop_qtd_contrat = 2 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 26 ticks por chunk; passeio de 240 ticks;
case 14: {m_stop_qtd_contrat = 2 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 28 ticks por chunk; passeio de 240 ticks;
case 15: {m_stop_qtd_contrat = 2 ; m_stop_porc = m_qtd_ticks_4_gain_new; break;} // 30 ticks por chunk; passeio de 240 ticks;
}
*/
}
}
double m_passo_dinamico_porc_canal_entrelaca = 0;
double m_volat4s_alta_porc = 0;
double m_volat4s_stop_porc = 0;
double m_stopLossPosicao = 0;
void inicializarVariaveisRecebidasPorParametro(){
// stop loss da posicao
m_stopLossPosicao = EA07_STOP_LOSS;
// O quanto a volatilidade por segundo deve ser maior que a volatilidade por segundo media para ser considerada alta.
// Volatilidade por segundo eh o tamanho do canal de transacoes dividido pela quantidade de segundos do indicador feira.
m_volat4s_alta_porc = EA_VOLAT4S_ALTA_PORC;
// O quanto a volatilidade por segundo deve ser maior que a volatilidade por segundo media para acionar o stop.
// Volatilidade por segundo eh o tamanho do canal de transacoes dividido pela quantidade de segundos do indicador feira.
m_volat4s_stop_porc = EA_VOLAT4S_STOP_PORC;
// porcentagem do canal de entrelacamento usada para definir o passo quando em modo de passo dinamico.
m_passo_dinamico_porc_canal_entrelaca = EA_PASSO_DINAMICO_PORC_CANAL_ENTRELACA;
// quantidade de periodos usados para calcular o coeficiente de entrelacamento.
m_qtdPeriodoCoefEntrelaca = EA_ENTRELACA_PERIODO_COEF;
// coeficiente de entrecamento minimo para permitir entrada na operacao.
m_entrelacaMinParaOperar = EA_ENTRELACA_COEF_MIN;
// regiao nas extremidades do canal de entrelacamento com boa probabilidade do preco retornar para o interior do canal.
// tambem definida como regiao de compra ou venda.
// definida em % do canal. ex: 0.2 significa que a estrategia:
// vende se o preco estah ateh 20% abaixo do topo do canal
// compra se o preco estah ateh 20% acima do topo do canal
m_porcRegiaoOperacaoEntrelaca = EA_ENTRELACA_REGIAO_BUY_SELL;
// tamanho maximo em ticks do canal de entrelacamento.
m_maxDistanciaEntrelacaParaOperar = EA_ENTRELACA_CANAL_MAX;
// se o canal de entrelamento ficar maior que esta distancia em ticks, eh acionado o stop loss.
m_stpDistanciaEntrelacamento = EA_ENTRELACA_CANAL_STOP;
// aguarda esta quantidade de segundos antes de abrir as primeiras posicoes. Isto possibilita:
// 1. que os indicadores estejam estabilizados antes da abertura da primeira posicao.
// 2. que as transferencias de operacao para os VPSs sejam mais suaves.
m_aguardar_para_abrir_posicao = EA_SLEEP_INI_OPER*1000;
// variaveis de controle do stop...
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI_L1;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_RAJ_L1;
m_vol_lote_raj = EA_VOL_LOTE_RAJ_L1;
m_vol_lote_ini = EA_VOL_LOTE_INI_L1;
m_passo_rajada = EA_PASSO_RAJ_L1;
m_stop_qtd_contrat = EA_STOP_QTD_CONTRAT;
m_stop_chunk = EA_STOP_QTD_CONTRAT;
m_stop_porc = EA_STOP_PORC_L1;
}
// retorna a porcentagem como um numero inteiro.
int porcentagem( double parte, double tot, int seTotZero){
if( tot==0 ){ return seTotZero ; }
return (m_posicaoVolumePend/m_posicaoVolumeTot)*100;
}
int m_qtd_print_debug = 0;
void fecharTudo(string descr){ fecharTudo(descr,""); }
void fecharTudo(string descr, string strLog, int qtdTicksDeslocamento=0){
if(m_qtdPosicoes>0){
fecharPosicao2(descr, strLog, qtdTicksDeslocamento);
}
if( m_qtdPosicoes == 0 ){
m_trade.cancelarOrdens(descr);
m_precoUltOrdemInBuy = 0;
m_precoUltOrdemInSel = 0;
}
/*
// se tem posicao ou ordem aberta, fecha, exceto as stops.
if( m_qtdOrdens > 0 ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_FECHAR_TUDO_ORDENS: ", strLog, strPosicao()); #endif
//m_val_close_position_sel = 0;
//m_vol_close_position_sel = 0;
//m_val_close_position_buy = 0;
//m_vol_close_position_buy = 0;
//m_trade.cancelarOrdensExcetoComTxt("STOP",descr); // estava comentado. Descomentado em 03/02/2020 as 15:40
// comentado novamente as 16:40. Estava executando varias vezes o cancelamento,
// nao permitindo abrir nova posicao
//m_trade.trazerOrdensComComentarioNumerico2valorPresente(m_symb_str,qtdTicksDeslocamento);
m_trade.trazerOrdensComComentarioNumerico2valorPresente(m_symb_str,EA_TICKS_TOLER_SAIDA);
// Era 2000. Passou pra 500 em 03/02/2020.
//Sleep(500); //<TODO> transforme em parametro
// Era 500. Passou pra 250 em 18/04/2020.
Sleep(250); //<TODO> transforme em parametro
// se nao tem posicao aberta, cancela todas as ordens pendentes...
if( m_qtdPosicoes == 0 ){
m_trade.cancelarOrdens(descr);
m_precoUltOrdemInBuy = 0;
m_precoUltOrdemInSel = 0;
}
}
*/
}
void fecharPosicao2(string descr, string strLog, int qtdTicksDeslocamento=0){
//1. providenciando ordens de fechamento que porventura faltem na posicao...
doCloseRajada(m_passo_rajada, m_vol_lote_raj, m_qtd_ticks_4_gain_raj);
//3. trazendo ordens de fechamento a valor presente...
m_trade.trazerOrdensComComentarioNumerico2valorPresente(m_symb_str,EA_TICKS_TOLER_SAIDA);
//2. cancelando rajadas que ainda nao entraram na posicao...
cancelarOrdensRajada();
//3. trazendo ordens de fechamento a valor presente...
//m_trade.trazerOrdensComComentarioNumerico2valorPresente(m_symb_str,EA_TICKS_TOLER_SAIDA);
//4. aguardando a execucao das ordens de fechamento...
Sleep(50); //<TODO> transforme em parametro
//5. refresh pra saber a situacao atual...
refreshMe();
//6. se ainda estamos posicionados, realiza todos os passos novamente...
if( m_qtdPosicoes > 0 ){ fecharPosicao2(descr, strLog, qtdTicksDeslocamento); }
//7. cancelando outras ordens pendentes...
m_trade.cancelarOrdens(descr);
m_precoUltOrdemInBuy = 0;
m_precoUltOrdemInSel = 0;
// Nao conseguiu fechar a posicao. Pode ser que falte ordem de fechamento.
// Neste caso, chamamos o close rajada para providenciar a ordem de fechamento se necessario.
// Em seguida, trazemos as ordens de fechamento a valor presente
}
void cancelarOrdensRajada(){ m_trade.cancelarOrdensComentadas(m_symb_str, m_strRajada);}
int m_tamanhoBook = 0;
void OnBookEvent(const string &symbol){
//Print("OnbookEvent disparado!!! Symbol=", symbol, " m_symb_str=",m_symb_str);
if(symbol!=m_symb_str) return; // garantindo que nao estamos processando o book de outro simbolo,
MqlBookInfo book[];
MarketBookGet(symbol, book);
//ArrayPrint(book);
//if(m_tamanhoBook==0){ m_tamanhoBook=ArraySize(book); }
m_tamanhoBook=ArraySize(book);
if(m_tamanhoBook == 0) { Print(":-( ",__FUNCTION__, " ERRO tamanho do book zero=",m_tamanhoBook ); return;}
m_est.addBook( m_time_in_seconds_atu, book, m_tamanhoBook, 0, m_tick_size );
m_probAskDescer = m_est.getPrbAskDescer();
m_probAskSubir = m_est.getPrbAskSubir ();
m_probBidDescer = m_est.getPrbBidDescer();
m_probBidSubir = m_est.getPrbBidSubir ();
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick(){
refreshMe();
// Esta opcao NAO_OPERAR nao interfere nas ordens...
if( EA07_ABRIR_POSICAO == NAO_OPERAR ) return;
//if(m_fechando_posicao){
// fecharTudo("FECHANDO_POSICAO");
// return;
//}
if ( m_qtdPosicoes > 0 ) {
if(m_fechando_posicao){ fecharTudo("STOP_FECHANDO_POSIC"); return; }
// abrindo ordens pra fechar a posicao...
doCloseRajada(m_passo_rajada, m_vol_lote_raj, m_qtd_ticks_4_gain_raj );
// se controlarRiscoDaPosicao() retornar true, significa que acionou um stop, entao retornamos daqui.
if( controlarRiscoDaPosicao() ){ return; }
if( emLeilao() )return;
doOpenRajada(m_passo_rajada, EA01_MAX_VOL_EM_RISCO, m_vol_lote_raj , m_qtd_ticks_4_gain_raj); // abrindo rajada...
//doCloseRajada(EA_PASSO_RAJ, EA05_VOLUME_LOTE_RAJ , m_qtd_ticks_4_gain, false ); // acionando saida rapida...
}else{
if( m_qtdOrdens > 0 ){
if( m_acionou_stop_rebaixamento_saldo ){ fecharTudo("STOP_REBAIXAMENTO_DE_CAPITAL"); return;}
// Esta opcao FECHAR_POSICAO fecha todas as posicoes e ordens...
if( EA07_ABRIR_POSICAO == FECHAR_POSICAO ){ fecharTudo("OPCAO_FECHAR_POSICAO" , "OPCAO_FECHAR_POSICAO" ); return; }
if( EA07_ABRIR_POSICAO == FECHAR_POSICAO_POSITIVA ){ fecharTudo("OPCAO_FECHAR_POSICAO_POSITIVA", "OPCAO_FECHAR_POSICAO_POSITIVA"); return; }
// cancela as ordens existentes e nao abre novas ordens se o spread for maior que maximo.
if( spreadMaiorQueMaximoPermitido() ){ fecharTudo("SPREAD_ALTO_" + m_symb.Spread(), "SPREAD_ALTO_"+m_symb.Spread()); return; }
// cancelando todas as ordens que nao sejam de abertura de posicao...
// trecho comentado em 03/02/2020. Como os cancelamentos sao por alteracao das ordens, nao precisa mais esta verificacao.
m_trade.cancelarOrdensExcetoComTxt(m_apmb,"CANC_NOT_APMB");
// nao estah no intervalo de negociacao, tem ordens abertas e nao tem posicao aberta, entao cancelamos todas as ordens.
if( !m_estah_no_intervalo_de_negociacao ){ m_trade.cancelarOrdens("INTERVALO_NEGOCIACAO");}
//apmb(nunca fechar), vazio(nunca fechar), numero(sempre fechar, pois soh pode ter ordem com comentario numerico se tiver posicao aberta)...
//m_trade.cancelarOrdensComComentarioNumerico(_Symbol); // sao as ordens de fechamento de rajada.
// se tiver ordens RAJADA sem posicao aberta fecha elas...
//m_trade.cancelarOrdensComentadas(m_strRajada);
// Parada apos os cancelamentos visando evitar atropelos...
//Sleep(SLEEP_PADRAO);
// se tiver ordem sem stop, coloca agora...
//m_trade.colocarStopEmTodasAsOrdens(m_stopLossOrdens);
}
// nao abrir posicao se o indicador feira estiver com problemas...
//if( m_pmTra == 0 ){
// m_qtd_erros++;
// if(m_qtd_erros>1000){
// Print(":-( MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Indicador feira com preco medio do trade zerado... VERIFIQUE!", strPosicao());
// m_qtd_erros=0;
// }
//}
// fora do intervalo de negociacao nao abrimos novas ordens...
// <TODO> Verifique porque esta chamada estah antes da checagem de rebaixamento de saldo. Acho que deveria ficar imediatamente antes das chamadas de abertura de novas posicoes.
if( !m_estah_no_intervalo_de_negociacao ) return;
/////////////////////////////////////////////////////////////////////////////////////
// mudou o dia, atualizamos o saldo da sessao...
if( m_mudou_dia ){
Print( ":-| MUDOU O DIA! Zerando rebaixamento de saldo...");
m_mudou_dia = false ;
m_acionou_stop_rebaixamento_saldo = false ;
m_maior_sld_do_dia = m_cta.Balance();
m_rebaixamento_atu = 0 ;
m_time_in_seconds_ini_day = StringToTime( TimeToString( TimeCurrent(), TIME_DATE ) );
}
// saldo da conta subiu, atualizamos o saldo da sessao pra controle do rebaixamento maximo do dia.
if( m_sld_sessao_atu > m_maior_sld_do_dia ){
m_maior_sld_do_dia = m_sld_sessao_atu;
m_rebaixamento_atu = 0;
}else{
m_rebaixamento_atu = m_maior_sld_do_dia - m_sld_sessao_atu; // se houver rebaixamento, esse numero fica positivo;
}
// saldo da conta rebaixou mais que o permitido pra sessao.
//if ( m_rebaixamento_atu != 0 &&
// EA_REBAIXAMENTO_MAX != 0 &&
// EA_REBAIXAMENTO_MAX < m_rebaixamento_atu ){
//if ( EA_REBAIXAMENTO_MAX != 0 &&
// m_trade_estatistica.getRebaixamentoSld() < -EA_REBAIXAMENTO_MAX ){
//if( saldoRebaixouMaisQuePermitidoNoDia() ){
// if( !m_acionou_stop_rebaixamento_saldo ){ // eh pra nao fical escrevendo no log ateh a sessao seguinte caso rebaixe o saldo.
// Print(":-( Acionando STOP_REBAIXAMENTO_DE_CAPITAL. ", strPosicao() );
// fecharTudo("STOP_REBAIXAMENTO_DE_CAPITAL");
// m_acionou_stop_rebaixamento_saldo = true;
// }
// return;
//}
/////////////////////////////////////////////////////////////////////////////////////
definirPasso();
// verificando proibicoes de operar
// if( m_fechando_posicao ||
// //volatilidadeEstahAlta() ||
// !entrelacamentoPermiteAbrirPosicao() ||
// !distaciaEntrelacamentoPermiteOperar()||
// volatilidade4segEstahAlta() ||
// !volat4sPermiteAbrirPosicao() || // acima desta volatilidade por segundo, nao abre posicao
// !taxaVolPermiteAbrirPosicao() ||
// emLeilao() || //<TODO> voltar e descomentar
// spreadMaiorQueMaximoPermitido() ||
// saldoRebaixouMaisQuePermitidoNoDia() ||
// saldoAtingiuObjetivoDoDia() ||
// !passoAutorizado() // passo deve estar na faixa de passos autorizados para abrir posicao
// )
if (! podeAbrirProsicao() ) {
m_trade.cancelarOrdensExcetoComTxt("STOP","NAO_PODE_ABRIR_POSICAO");
m_precoUltOrdemInBuy = 0;
m_precoUltOrdemInSel = 0;
m_val_close_position_sel = 0;
m_vol_close_position_sel = 0;
m_val_close_position_buy = 0;
m_vol_close_position_buy = 0;
return;
}
// soh abre novas posicoes apos zerar a penalidade...
if( m_aguardar_para_abrir_posicao > 0 ) return;
switch(EA07_ABRIR_POSICAO){
case CONTRA_TEND_DURANTE_COMPROMETIMENTO : abrirPosicaoDuranteComprometimentoInstitucional(); break;
case CONTRA_TEND_APOS_COMPROMETIMENTO : abrirPosicaoAposComprometimentoInstitucional (); break;
case CONTRA_TEND_APOS_ROMPIMENTO_ANTERIOR: abrirPosicaoAposMaxMinBarraAnterior (); break;
case HFT_DISTANCIA_PRECO : abrirPosicaoHFTdistanciaDoPreco (); break;
case HFT_MAX_MIN_VOLAT : abrirPosMaxMinVolatContraTend (); break;
//case HFT_TEND_CCI : abrirPosicaoCCINaTendencia (); break;
case HFT_NA_TENDENCIA : abrirPosicaoHFTnaTendencia (); break;
case HFT_NORTE_SUL : abrirPosicaoHFTnorteSul (); break;
case HFT_DESBALANC_BOOK : abrirPosicaoHFTDesbalancBook (); break;
case HFT_DESBALANC_BOOKNS : abrirPosicaoHFTDesbalancBookNorteSul (); break;
case HFT_MEDIA_TRADE : abrirPosicaoHFTNaMediaTrade (); break;
case HFT_ARBITRAGEM_VOLUME : abrirPosicaoArbitragemVolume (); break;
case HFT_HIBRIDO_MAX_MIN_VOL_X_DISTANCIA_PRECO:abrirPosHibridaMaxMinVolatDistanciaPreco (); break;
case HFT_BB_NA_TENDENCIA : abrirPosicaoNaBBNaTendencia (); break;
case HFT_DISTANCIA_DA_MEDIA : abrirPosicaoHFTdistanciaDaMedia (); break;
case HFT_FLUXO_ORDENS : abrirPosicaoHFTfluxoOrdens (); break;
case HFT_REGIAO_CANAL_ENTRELACA : abrirPosRegiaoCanalEntrelaca (); break;
//case NAO_ABRIR_POSICAO : break;
}
return;
}
return;
}//+------------------------------------------------------------------+
bool podeAbrirProsicao(){
return ( !m_fechando_posicao &&
//!volatilidadeEstahAlta() &&
entrelacamentoPermiteAbrirPosicao() &&
distaciaEntrelacamentoPermiteOperar()&&
!volatilidade4segEstahAlta() &&
volat4sPermiteAbrirPosicao() && // acima desta volatilidade por segundo, nao abre posicao
taxaVolPermiteAbrirPosicao() &&
!emLeilao() && //<TODO> voltar e descomentar
!spreadMaiorQueMaximoPermitido() &&
!saldoRebaixouMaisQuePermitidoNoDia() &&
!saldoAtingiuObjetivoDoDia() &&
passoAutorizado() // passo deve estar na faixa de passos autorizados para abrir posicao
);
}
string strPermissaoAbrirPosicao(){
if( !EA_SHOW_STR_PERMISSAO_ABRIR_POSICAO ){ return "";}
return "!m_fechando_posicao " + !m_fechando_posicao + "\n" +
//"!volatilidadeEstahAlta " + !volatilidadeEstahAlta() + "\n" +
" entrelacamentoPermiteAbrirPosicao " + entrelacamentoPermiteAbrirPosicao() + "\n" +
" distaciaEntrelacamentoPermiteOperar " + distaciaEntrelacamentoPermiteOperar()+ "\n" +
"!volatilidade4segEstahAlta " + !volatilidade4segEstahAlta() + "\n" +
" volat4sPermiteAbrirPosicao " + volat4sPermiteAbrirPosicao() + "\n" + // acima desta volatilidade por segundo, nao abre posicao
" taxaVolPermiteAbrirPosicao " + taxaVolPermiteAbrirPosicao() + "\n" +
"!emLeilao " + !emLeilao() + "\n" + //<TODO> voltar e descomentar
"!spreadMaiorQueMaximoPermitido " + !spreadMaiorQueMaximoPermitido() + "\n" +
"!saldoRebaixouMaisQuePermitidoNoDia " + !saldoRebaixouMaisQuePermitidoNoDia() + "\n" +
"!saldoAtingiuObjetivoDoDia " + !saldoAtingiuObjetivoDoDia() + "\n" +
" passoAutorizado " + passoAutorizado() // passo deve estar na faixa de passos autorizados para abrir posicao
;
}
bool saldoRebaixouMaisQuePermitidoNoDia(){ return ( EA_REBAIXAMENTO_MAX != 0 && m_trade_estatistica.getRebaixamentoSld () > EA_REBAIXAMENTO_MAX ); }
bool saldoAtingiuObjetivoDoDia (){ return ( EA_OBJETIVO_DIA != 0 && m_trade_estatistica.getProfitDiaLiquido() > EA_OBJETIVO_DIA ); }
//bool controlarRiscoDaPosicao(){
// if( EA_TIPO_CONTROLE_RISCO == 1) return controlarRiscoDaPosicao1();
// return controlarRiscoDaPosicao2();
//}
double m_precoPosicao = 0; // valor medio de entrada da posicao
double m_precoPosicaoAnt = 0;
double m_precoSaidaPosicao = 0;
double m_precoSaidaPosicaoAnt = 0;
void controlarRiscoDaPosicao2(){
// 1. se preco de entrada da posicao nao mudou, entao nao fazemos nada...
if(m_precoPosicao==m_precoPosicaoAnt) return;
m_precoPosicaoAnt = m_precoPosicao;
// 2. calcule o preco de saida...
if( estouComprado() ){
m_precoSaidaPosicao = normalizar( m_precoPosicao + m_qtd_ticks_4_gain_ini*m_tick_size );
if( m_precoSaidaPosicao < m_precoPosicao){
m_precoSaidaPosicao = normalizar(m_precoSaidaPosicao + m_qtd_ticks_4_gain_ini*m_tick_size);
}
}else{
m_precoSaidaPosicao = normalizar( m_precoPosicao - m_qtd_ticks_4_gain_ini*m_tick_size );
if( m_precoSaidaPosicao > m_precoPosicao){
m_precoSaidaPosicao = normalizar(m_precoSaidaPosicao - m_qtd_ticks_4_gain_ini*m_tick_size);
}
}
// 3. se o preco de saida eh igual ao anterior, retorne sem fazer nada...
if(m_precoSaidaPosicao==m_precoSaidaPosicaoAnt) return;
m_precoSaidaPosicaoAnt = m_precoSaidaPosicao;
// 4. movendo ordens pendentes numericas para o preco de saida...
m_trade.alterarValorDeOrdensNumericasPara(m_symb_str,m_precoSaidaPosicao, m_precoPosicao);
//if( estouComprado() ){
// //mova ordens de venda, acima do preco de saida para o preco de saida.
// //m_trade.baixarValorDeOrdensNumericasDeVendaPara(m_precoSaidaPosicao);
//}else{
// //mova ordens de compra, abaixo do preco de saida para o preco de saida.
// //m_trade.subirValorDeOrdensNumericasDeCompraPara(m_precoSaidaPosicao);
//}
return;
}
double m_saida_posicao = 0;
double calcSaidaPosicao(double volumePosicao ){
if( volumePosicao < m_stop_qtd_contrat) return volumePosicao*m_qtd_ticks_4_gain_ini*m_tick_size;
if( volumePosicao < m_stop_chunk* 2.0 ) return m_lucroPosicao4Gain* 0.95;
if( volumePosicao < m_stop_chunk* 3.0 ) return m_lucroPosicao4Gain* 0.9 ;
if( volumePosicao < m_stop_chunk* 4.0 ) return m_lucroPosicao4Gain* 0.85;
if( volumePosicao < m_stop_chunk* 5.0 ) return m_lucroPosicao4Gain* 0.8 ;
if( volumePosicao < m_stop_chunk* 6.0 ) return m_lucroPosicao4Gain* 0.75;
if( volumePosicao < m_stop_chunk* 7.0 ) return m_lucroPosicao4Gain* 0.7 ;
if( volumePosicao < m_stop_chunk* 8.0 ) return m_lucroPosicao4Gain* 0.65;
if( volumePosicao < m_stop_chunk* 9.0 ) return m_lucroPosicao4Gain* 0.6 ;
if( volumePosicao < m_stop_chunk*10.0 ) return m_lucroPosicao4Gain* 0.55;
if( volumePosicao < m_stop_chunk*11.0 ) return m_lucroPosicao4Gain* 0.5 ;
if( volumePosicao < m_stop_chunk*12.0 ) return m_lucroPosicao4Gain* 0.45;
if( volumePosicao < m_stop_chunk*13.0 ) return m_lucroPosicao4Gain* 0.4 ;
if( volumePosicao < m_stop_chunk*14.0 ) return m_lucroPosicao4Gain* 0.35;
if( volumePosicao < m_stop_chunk*15.0 ) return m_lucroPosicao4Gain* 0.3 ;
if( volumePosicao < m_stop_chunk*16.0 ) return m_lucroPosicao4Gain* 0.25;
if( volumePosicao < m_stop_chunk*17.0 ) return m_lucroPosicao4Gain* 0.2 ;
if( volumePosicao < m_stop_chunk*18.0 ) return m_lucroPosicao4Gain* 0.15;
if( volumePosicao < m_stop_chunk*19.0 ) return m_lucroPosicao4Gain* 0.1 ;
if( volumePosicao < m_stop_chunk*20.0 ) return m_lucroPosicao4Gain* 0.05;
if( volumePosicao < m_stop_chunk*21.0 ) return m_lucroPosicao4Gain* 0.0 ;
if( volumePosicao < m_stop_chunk*22.0 ) return m_lucroPosicao4Gain*-0.05;
if( volumePosicao < m_stop_chunk*23.0 ) return m_lucroPosicao4Gain*-0.1 ;
if( volumePosicao < m_stop_chunk*24.0 ) return m_lucroPosicao4Gain*-0.15;
if( volumePosicao < m_stop_chunk*25.0 ) return m_lucroPosicao4Gain*-0.2 ;
if( volumePosicao < m_stop_chunk*26.0 ) return m_lucroPosicao4Gain*-0.25;
if( volumePosicao < m_stop_chunk*27.0 ) return m_lucroPosicao4Gain*-0.3 ;
if( volumePosicao < m_stop_chunk*28.0 ) return m_lucroPosicao4Gain*-0.35;
if( volumePosicao < m_stop_chunk*29.0 ) return m_lucroPosicao4Gain*-0.4 ;
if( volumePosicao < m_stop_chunk*30.0 ) return m_lucroPosicao4Gain*-0.45;
if( volumePosicao < m_stop_chunk*31.0 ) return m_lucroPosicao4Gain*-0.5 ;
if( volumePosicao < m_stop_chunk*32.0 ) return m_lucroPosicao4Gain*-0.55;
if( volumePosicao < m_stop_chunk*33.0 ) return m_lucroPosicao4Gain*-0.6 ;
if( volumePosicao < m_stop_chunk*34.0 ) return m_lucroPosicao4Gain*-0.65;
if( volumePosicao < m_stop_chunk*35.0 ) return m_lucroPosicao4Gain*-0.7 ;
if( volumePosicao < m_stop_chunk*36.0 ) return m_lucroPosicao4Gain*-0.75;
if( volumePosicao < m_stop_chunk*37.0 ) return m_lucroPosicao4Gain*-0.8 ;
if( volumePosicao < m_stop_chunk*38.0 ) return m_lucroPosicao4Gain*-0.85;
if( volumePosicao < m_stop_chunk*39.0 ) return m_lucroPosicao4Gain*-0.9 ;
if( volumePosicao < m_stop_chunk*40.0 ) return m_lucroPosicao4Gain*-1.0 ;
if( volumePosicao < m_stop_chunk*41.0 ) return m_lucroPosicao4Gain*-1.05;
if( volumePosicao < m_stop_chunk*24.0 ) return m_lucroPosicao4Gain*-1.1 ;
if( volumePosicao < m_stop_chunk*25.0 ) return m_lucroPosicao4Gain*-1.15;
if( volumePosicao < m_stop_chunk*26.0 ) return m_lucroPosicao4Gain*-1.2 ;
if( volumePosicao < m_stop_chunk*27.0 ) return m_lucroPosicao4Gain*-1.25;
if( volumePosicao < m_stop_chunk*28.0 ) return m_lucroPosicao4Gain*-1.3 ;
if( volumePosicao < m_stop_chunk*29.0 ) return m_lucroPosicao4Gain*-1.35;
if( volumePosicao < m_stop_chunk*30.0 ) return m_lucroPosicao4Gain*-1.4 ;
if( volumePosicao < m_stop_chunk*31.0 ) return m_lucroPosicao4Gain*-1.45;
if( volumePosicao < m_stop_chunk*32.0 ) return m_lucroPosicao4Gain*-1.5 ;
if( volumePosicao < m_stop_chunk*33.0 ) return m_lucroPosicao4Gain*-1.55;
if( volumePosicao < m_stop_chunk*34.0 ) return m_lucroPosicao4Gain*-1.6 ;
if( volumePosicao < m_stop_chunk*35.0 ) return m_lucroPosicao4Gain*-1.65;
if( volumePosicao < m_stop_chunk*36.0 ) return m_lucroPosicao4Gain*-1.8 ;
if( volumePosicao < m_stop_chunk*37.0 ) return m_lucroPosicao4Gain*-1.85;
if( volumePosicao < m_stop_chunk*38.0 ) return m_lucroPosicao4Gain*-1.9 ;
if( volumePosicao < m_stop_chunk*39.0 ) return m_lucroPosicao4Gain*-1.9 ;
if( volumePosicao < m_stop_chunk*40.0 ) return m_lucroPosicao4Gain*-1.95;
if( volumePosicao < m_stop_chunk*41.0 ) return m_lucroPosicao4Gain*-2.0 ;
//if( volumePosicao < m_stop_chunk*31.0 ) return m_lucroPosicao4Gain*-2.1;
return m_lucroPosicao4Gain*-2.05;
}
bool controlarRiscoDaPosicao(){
//if( volat4sExigeStop() ){ fecharTudo("STOP_V4S_ALTA"); return true;}
if( distaciaEntrelacamentoDeveStopar() ){ fecharTudo("STOP_TCE"); return true;}
if( saldoRebaixouMaisQuePermitidoNoDia() ){ fecharTudo("STOP_REBAIXAMENTO_DE_CAPITAL"); return true;}
//if( m_acionou_stop_rebaixamento_saldo ){ fecharTudo("STOP_REBAIXAMENTO_DE_CAPITAL"); return true;}
// Esta opcao FECHAR_POSICAO fecha todas as posicoes e ordens...
if( EA07_ABRIR_POSICAO == FECHAR_POSICAO ) { fecharTudo("STOP_FECHAR_POSICAO" ,"STOP_FECHAR_POSICAO" ); return true; }
if( EA07_ABRIR_POSICAO == FECHAR_POSICAO_POSITIVA && m_posicaoProfit > 0 ) { fecharTudo("STOP_FECHAR_POSICAO_POSITIVA","STOP_FECHAR_POSICAO_POSITIVA"); return true; }
// se tem posicao aberta, cancelamos as ordens apmb que porventura tenham ficado abertas
// comentado aqui e colocado dentro de refreshme para que execute uma unica vez apos a abertura de cada posicao.
//m_trade.cancelarOrdensComentadas(m_apmb);//<TODO: DESCOMENTE e transforme em parametro>
if( m_lucroPosicao < m_stopLossPosicao && m_capitalInicial != 0 ){
Print(":-( Acionando STOP_LOSS_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
fecharTudo("STOP_LOSS_" + DoubleToString(m_lucroPosicao,0) );
return true;
}
//+----------------------------------------------------------------------------------------
//+ Controle de STOPs em funcao das quantidades totais e pendentes de contratos na posicao.
//+----------------------------------------------------------------------------------------
if( m_capitalInicial != 0 && // deixe isso aqui, senao dah merda na inicializacao, hehe
m_posicaoVolumeTot >= m_stop_qtd_contrat &&
m_posicaoVolumePend > 0 ){
// stop se a porcentagem de contratos pendentes for muito alta em relacao a quantidade de contratos totais.
//if( m_posicaoVolumePend/m_posicaoVolumeTot > EA_STOP_PORC_CONTRAT && EA_STOP_PORC_CONTRAT > 0){
// Print(":-( Acionando STOP_QTD_PORC_CONTRATOS_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
// m_lucroStops += m_lucroPosicao;
// fecharTudo("STOP_QTD_%_CONTRATOS_"+ DoubleToString(m_lucroPosicao,0),1);
// return true;
//}
//+----------------------------------------------------------------------------------------------------
//+ CONTROLE DOS STOP LOSS INTERMEDIARIOS
//+----------------------------------------------------------------------------------------------------
// 2. LOSS: se a quantidade de contratos pendentes estah maior que 2x o inicio do stop, fecha posicao se o loss eh maior que EA_STOP_L2;
//if( m_posicaoVolumePend >= m_stop_qtd_contrat*2 &&
// m_posicaoVolumePend < m_stop_qtd_contrat*3 &&
// m_lucroPosicao > EA_STOP_L2 ){
// Print(":-| Acionando STOP_LO_L2_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
// m_lucroStops += m_lucroPosicao;
// fecharTudo("STOP_LO_L2_" + DoubleToString(m_lucroPosicao,0));
// return true;
//}
// 3. LOSS: se a quantidade de contratos pendentes estah maior que 3x o inicio do stop, fecha posicao se o loss eh maior que EA_STOP_L3;
//if( m_posicaoVolumePend >= m_stop_qtd_contrat*3 &&
// m_posicaoVolumePend < m_stop_qtd_contrat*4 &&
// m_lucroPosicao > EA_STOP_L3 ){
// Print(":-( Acionando STOP_LO_LEVEL3_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
// m_lucroStops += m_lucroPosicao;
// fecharTudo("STOP_LO_L3_" + DoubleToString(m_lucroPosicao,0) );
// return true;
//}
// 4. LOSS: se a quantidade de contratos pendentes estah maior que 4x o inicio do stop, fecha posicao se o loss eh maior que EA_STOP_L4;
//if( m_posicaoVolumePend > m_stop_qtd_contrat*4 &&
// m_lucroPosicao > EA_STOP_L4 ){
// Print(":-( Acionando STOP_LOSS_LEVEL4_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
// m_lucroStops += m_lucroPosicao;
// fecharTudo("STOP_LO_L4_"+ DoubleToString(m_lucroPosicao,0) );
// return true;
//}
//+----------------------------------------------------------------------------------------------------
//+----------------------------------------------------------------------------------------------------
//+ CONTROLE DOS STOP GAIN INTERMEDIARIOS
//+----------------------------------------------------------------------------------------------------
if( EA_TIPO_CONTROLE_RISCO == 2 ){
controlarRiscoDaPosicao2();
}else{
m_saida_posicao = calcSaidaPosicao(m_posicaoVolumeTot);
if ( m_lucroPosicao > m_saida_posicao ){
Print(":-| Acionando STOP_GLX_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GLX_" + DoubleToString(m_lucroPosicao,0), 1 );
return true;
}
}
// testando stop por entrelacamento...
//if( m_coefEntrelaca < 0.35 && m_lucroPosicao > -250 ){
//if( m_coefEntrelaca < 0.4 ){
// Print(":-| Acionando STOP_ENT_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
// m_lucroStops += m_lucroPosicao;
// fecharTudo("STOP_ENT_" + DoubleToString(m_lucroPosicao,0), 1 );
// return true;
//}
/*
else{
// 1.1 GAIN: quantidade de contratos totais eh maior que 1x o inicio do controle de stops, aplica a % do gain informada em STOP_PORC_L1;
if( m_lucroPosicao > m_lucroPosicao4Gain ){
Print(":-| Acionando STOP_GAIN_L1_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GA_L1_" + DoubleToString(m_lucroPosicao,0), 1 );
return true;
}
// 2.1 GAIN: se a quantidade de contratos totais estah maior que 2x o inicio do controle de stops, abate 20% do gain L1;
if( m_posicaoVolumeTot >= m_stop_qtd_contrat*2 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*3 &&
m_lucroPosicao > m_lucroPosicao4Gain*0.8 ){
Print(":-| Acionando STOP_GA_L2_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GA_L2_" + DoubleToString(m_lucroPosicao,0), 1);
return true;
}
// 3.1 GAIN: se a quantidade de contratos totais estah maior que 3x o inicio do controle de stops, abate 40% do gain L1;
if( m_posicaoVolumeTot >= m_stop_qtd_contrat*3 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*4 &&
m_lucroPosicao > m_lucroPosicao4Gain*0.6 ){
Print(":-| Acionando STOP_GA_L3_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GA_L3_" + DoubleToString(m_lucroPosicao,0), 1);
return true;
}
// 4.1 GAIN: se a quantidade de contratos totais estah maior que 4x o inicio do controle de stops, abate 60% do gain L1;
if( m_posicaoVolumeTot >= m_stop_qtd_contrat*4 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*5 &&
m_lucroPosicao > m_lucroPosicao4Gain*0.4 ){
Print(":-| Acionando STOP_GA_L4_"+ DoubleToString(m_lucroPosicao,0), strPosicao(), 1 );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GA_L4_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 5.1 GAIN: se a quantidade de contratos totais estah maior que 5x o inicio do controle de stops, abate 80% do gain L1;
if( m_posicaoVolumeTot >= m_stop_qtd_contrat*5 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*6 &&
m_lucroPosicao > m_lucroPosicao4Gain*0.2 ){
Print(":-| Acionando STOP_GA_L5_"+ DoubleToString(m_lucroPosicao,0), strPosicao(), 1 );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GA_L5_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 6.1 GAIN: se a quantidade de contratos totais estah maior que 6x o inicio do controle de stops, abate 100% do gain L1;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*6 &&
m_lucroPosicao > 0 ){
Print(":-| Acionando STOP_GA_L6_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_GA_L6_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 7.1 LOSS: se a quantidade de contratos totais estah maior que 7x o inicio do controle de stops, aceita 20% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*7 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*8 &&
m_lucroPosicao > -m_lucroPosicao4Gain*0.2 ){
Print(":-| Acionando STOP_LO_L7_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L7_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 8.1 LOSS: se a quantidade de contratos totais estah maior que 8x o inicio do controle de stops, aceita 40% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*8 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*9 &&
m_lucroPosicao > -m_lucroPosicao4Gain*0.4 ){
Print(":-| Acionando STOP_LO_L8_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L8_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 9.1 LOSS: se a quantidade de contratos totais estah maior que 9x o inicio do controle de stops, aceita 60% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*9 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*10 &&
m_lucroPosicao > -m_lucroPosicao4Gain*0.6 ){
Print(":-| Acionando STOP_LO_L9_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L9_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 10.1 LOSS: se a quantidade de contratos totais estah maior que 10x o inicio do controle de stops, aceita 80% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*10 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*11 &&
m_lucroPosicao > -m_lucroPosicao4Gain*0.8 ){
Print(":-| Acionando STOP_LO_L10_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L10_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 11.1 LOSS: se a quantidade de contratos totais estah maior que 11x o inicio do controle de stops, aceita 100% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*11 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*12 &&
m_lucroPosicao > -m_lucroPosicao4Gain ){
Print(":-| Acionando STOP_LO_L11_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L11_" + DoubleToString(m_lucroPosicao,0),1);
return true;
}
// 12.1 LOSS: se a quantidade de contratos totais estah maior que 12x o inicio do controle de stops, aceita 120% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*12 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*13 &&
m_lucroPosicao > -m_lucroPosicao4Gain*1.20 ){
Print(":-| Acionando STOP_LO_L12_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L12_" + DoubleToString(m_lucroPosicao,0),1); //abrindo mao do gain L1...
return true;
}
// 13.1 LOSS: se a quantidade de contratos totais estah maior que 13x o inicio do controle de stops, aceita 140% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*13 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*14 &&
m_lucroPosicao > -m_lucroPosicao4Gain*1.40 ){
Print(":-| Acionando STOP_LO_L13_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L13_" + DoubleToString(m_lucroPosicao,0),1); //abrindo mao do gain L1...
return true;
}
// 14.1 LOSS: se a quantidade de contratos totais estah maior que 14x o inicio do controle de stops, aceita 160% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*14 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*15 &&
m_lucroPosicao > -m_lucroPosicao4Gain*1.60 ){
Print(":-| Acionando STOP_LO_L14_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L14_" + DoubleToString(m_lucroPosicao,0),1); //abrindo mao do gain L1...
return true;
}
// 15.1 LOSS: se a quantidade de contratos totais estah maior que 15x o inicio do controle de stops, aceita 180% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*15 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*16 &&
m_lucroPosicao > -m_lucroPosicao4Gain*1.80 ){
Print(":-| Acionando STOP_LO_L15_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L15_" + DoubleToString(m_lucroPosicao,0),1); //abrindo mao do gain L1...
return true;
}
// 16.1 LOSS: se a quantidade de contratos totais estah maior que 16x o inicio do controle de stops, aceita 200% do gain L1(negativo) como perda;
if( m_posicaoVolumeTot > m_stop_qtd_contrat*16 &&
m_posicaoVolumeTot < m_stop_qtd_contrat*17 &&
m_lucroPosicao > -m_lucroPosicao4Gain*2.00 ){
Print(":-| Acionando STOP_LO_L16_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_L16_" + DoubleToString(m_lucroPosicao,0),1); //abrindo mao do gain L1...
return true;
}
}
*/
//+----------------------------------------------------------------------------------------------------
} // FIM DO CONTROLE DE STOPS
// fecha a posicao ativa a mais de 10 min
if( m_tempo_posicao_atu > EA_10MINUTOS && EA_10MINUTOS > 0 ){
Print(":-( Acionando STOP_LOSS_TEMPO_ALTO_"+ DoubleToString(m_lucroPosicao,0)," T=",m_tempo_posicao_atu," ", strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_LO_TEMPO_ALTO_"+ DoubleToString(m_lucroPosicao,0));
return true;
}
// testando...
//if( taxaVolumeEstahAlta() ){
// fecharTudo("STOP_TAXA_VOLUME_ALTA","STOP_TAXA_VOLUME_ALTA"); return;
//}
return false;
}
//bool movimentoEmDirecaoDesfavoravel(){
// return ( ( estouComprado() && m_icci.Main(0) < m_icci.Main(1) ) ||
// ( estouVendido () && m_icci.Main(0) > m_icci.Main(1) ) );
// //return ( estouComprado() && m_inclTra < -EA_INCL_MIN && m_icci.Main(0) < m_icci.Main(1) ||
// // estouVendido () && m_inclTra > EA_INCL_MIN && m_icci.Main(0) > m_icci.Main(1) );
//}
string strPosicao(){
return " Contr=" + DoubleToString (m_posicaoVolumePend,0)+ "/"+
DoubleToString (m_posicaoVolumeTot ,0)+
" SPRE= " + DoubleToString (m_symb.Spread() ,2)+
" VSBUY/SEL=" + DoubleToString (m_volTradePorSegBuy,0)+ "/" + DoubleToString(m_volTradePorSegSel,0)+
" Incl=" + DoubleToString (m_inclTra ,2)+
//" PUP0/1=" + DoubleToString (m_desbUp0*100 ,0)+ "/" + DoubleToString(m_desbUp0*100,0)+
//" CCI[DIF]=" + DoubleToString ( ( m_icci.Main(0)-m_icci.Main(1) ) ,2)+
" LUCRP=" + DoubleToString (m_lucroPosicao ,2)+
//" T4GI=" + IntegerToString(m_qtd_ticks_4_gain_ini )+
//" T4GR=" + IntegerToString(m_qtd_ticks_4_gain_raj )+
//" MVDESF=" + IntegerToString(movimentoEmDirecaoDesfavoravel())+
" Volat=" + DoubleToString (m_volatilidade ,2)+
" DBBI=" + DoubleToString (m_bbInfDelta ,2)+
" DBBM=" + DoubleToString (m_bbMedDelta ,2)+
" DBBS=" + DoubleToString (m_bbSupDelta ,2)+
//" BB[1]=" + DoubleToString (m_bbMedAnt ,2)+
//" BB[0]=" + DoubleToString (m_bbMed ,2)+
//" CCI[1]=" + DoubleToString (m_icci.Main(1) ,2)+
//" CCI[0]=" + DoubleToString (m_icci.Main(0) ,2)+
//" CAPINI=" + DoubleToString (m_capitalInicial ,2)+
//" CAPLIQ=" + DoubleToString (m_capitalLiquido ,2)+
//" LUCRSTOPS=" + DoubleToString (m_lucroStops ,2)+
//" Proft=" + DoubleToString (m_posicaoProfit ,2)+
//" CAP=" + DoubleToString (m_cta.Equity () ,2)+
//" SLD=" + DoubleToString (m_cta.Balance () ,2)+
//" MSLDDIA=" + DoubleToString (m_maior_sld_do_dia ,2)+
//" RSLD=" + DoubleToString (m_rebaixamento_atu) +
" ASK/BID=" + DoubleToString (m_ask,_Digits) + "/"+ DoubleToString (m_bid,_Digits)+
//" PMTRADE=" + DoubleToString (m_pmTra ,2)+
//" ORDPEN=" + IntegerToString(m_qtdOrdens )+
" Leilao=" + strEmLeilao() ;
}
bool emLeilao(){return (m_ask<=m_bid);}
string strEmLeilao(){ if(emLeilao()) return "SIM"; return "NAO";}
//----------------------------------------------------------------------------------------------------------------------------
// Esta funcao deve ser chamada sempre qua ha uma posicao aberta.
// Ela cria rajada de ordens no sentido da posicao, bem como as ordens de fechamento da posicao baseadas nas ordens da rajada.
// passo : aumento de preco na direcao contraria a posicao
// volLimite: volume maximo em risco
// volLote : volume de ordem aberta na direcao contraria a posicao
// profit : quantidade de ticks para o gain
//
// versao 02-084: closerajada antes do openrajada.
// Para abrir logo o close da ordem de abertura da posicao.
// Estava abrindo as rajadas antes da ordem de fechamento da posicao.
//----------------------------------------------------------------------------------------------------------------------------
bool doOpenRajada(double passo, double volLimite, double volLote, double profit){
if(passo == 0) return true;
if( estouVendido() ){
// se nao tem ordem pendente acima do preco atual mais o passo, abre uma...
double precoOrdem = m_bid+(m_tick_size*passo);
openOrdemRajadaVenda(passo,volLimite,volLote,profit,precoOrdem);
return true;
}else{
if( estouComprado() ){
// se nao tem ordem pendente abaixo do preco atual, abre uma...
double precoOrdem = m_ask-(m_tick_size*passo);
openOrdemRajadaCompra(passo,volLimite,volLote,profit,precoOrdem);
return true;
}
}
// nao deveria chegar aqui, a menos que esta funcao seja chamada sem uma posicao aberta.
Print(":-( ATENCAO OPENRAJADA chamado sem posicao aberta. Verifique! ",strPosicao() );
return false;
}
// abre rajada em posicao vendida...
bool openOrdemRajadaVenda( double passo, double volLimite, double volLote, double profit, double precoOrdem){
// distancia entre a primeira ordem da posicao e a ordem atual...
//int distancia =(int)( (m_val_order_4_gain==0)?0:(precoOrdem-m_val_order_4_gain) );
if(m_val_order_4_gain==0){
Print(":-( openOrdemRajadaVenda() chamado, mas valor de abertura da posicao eh ZERO. VERIFIQUE!!!");
return false;
}
precoOrdem = normalizar( m_val_order_4_gain+(passo*m_tick_size) );
if(EA_MARTINGALE) volLote = volLote*2;
//while(precoOrdem < m_ask){
while(precoOrdem < m_bid){
precoOrdem = normalizar( precoOrdem + (passo*m_tick_size) );
if(EA_MARTINGALE) volLote = volLote*2;
}
for(int i=0; i<EA_TAMANHO_RAJADA; i++){
precoOrdem = normalizar(precoOrdem);
if( m_posicaoVolumePend <= volLimite && // se o volume em risco for menor que o limite (ex: 10 lotes), abre ordem limitada acima do preco
//( passo==0 || distancia%(int)(passo*m_tick_size)== 0 ) && // posiciona rajada em distancias multiplas do passo.
(precoOrdem > m_val_order_4_gain || m_val_order_4_gain==0 ) && // vender sempre acima da primeira ordem da posicao
!m_trade.tenhoOrdemLimitadaDeVenda ( precoOrdem , m_symb_str, m_strRajada ) &&
!m_trade.tenhoOrdemLimitadaDeCompra( normalizar(precoOrdem-profit*m_tick_size), m_symb_str, m_strRajada ) // se tiver a ordem de compra pendente,
// significa que a ordem de venda foi
// executada, entao nao abrimos nova
// ordem de venda ateh que a compra,
// que eh seu fechamento, seja executada.
){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) Print(":-| HFT_ORDEM OPEN_RAJADA SELL_LIMIT=",precoOrdem, ". Enviando... ",strPosicao() ); #endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO); #endif
// essa a parte original antes da alteracao para o passo dinamico
if( m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, volLote, m_strRajada+getStrComment() ) ){
if( m_val_order_4_gain==0 ){ m_val_order_4_gain = precoOrdem; }
//return true;
}
}
precoOrdem = precoOrdem + (passo*m_tick_size);
if(EA_MARTINGALE) volLote = volLote*2;
}
return false;
}
// abre rajada em posicao comprada...
bool openOrdemRajadaCompra( double passo, double volLimite, double volLote, double profit, double precoOrdem){
// distancia entre a primeira ordem da posicao e a ordem atual...
//int distancia = (int)( (m_val_order_4_gain==0)?0:(m_val_order_4_gain-precoOrdem) );
if(m_val_order_4_gain==0){
Print(":-( openOrdemRajadaCompra() chamado, mas valor de abertura da posicao eh ZERO. VERIFIQUE!!!");
return false;
}
precoOrdem = normalizar( m_val_order_4_gain-(passo*m_tick_size) );
if(EA_MARTINGALE) volLote = volLote*2;
//while(precoOrdem > m_bid){
while(precoOrdem > m_ask){
precoOrdem = normalizar( precoOrdem - (passo*m_tick_size) );
if(EA_MARTINGALE) volLote = volLote*2;
}
for(int i=0; i<EA_TAMANHO_RAJADA; i++){
precoOrdem = normalizar(precoOrdem);
if( m_posicaoVolumePend <= volLimite && // se o volume em risco for menor que o limite (ex: 10 lotes), abre ordem limitada acima do preco
//( passo==0 || distancia%(int)(passo*m_tick_size)== 0 ) && // posiciona rajada em distancias multiplas do passo.
(precoOrdem < m_val_order_4_gain || m_val_order_4_gain==0 ) && // comprar sempre abaixo da primeira ordem da posicao
!m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem , m_symb.Name(), m_strRajada ) &&
!m_trade.tenhoOrdemLimitadaDeVenda ( normalizar( precoOrdem+profit*m_tick_size ), m_symb.Name(), m_strRajada ) // se tiver a ordem de venda pendente,
// significa que a ordem de compra foi
// executada, entao nao abrimos nova
// ordem de compra ateh que a venda,
// que eh seu fechamento, seja executada.
){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) Print(":-| HFT_ORDEM OPEN_RAJADA BUY_LIMIT=",precoOrdem, ". Enviando...",strPosicao()); #endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO); #endif
// essa a parte original antes da alteracao para o passo dinamico
if( m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, volLote, m_strRajada+getStrComment() ) ){
if( m_val_order_4_gain==0 ){ m_val_order_4_gain = precoOrdem;}
//return true;
}
}
precoOrdem = precoOrdem - (passo*m_tick_size);
if(EA_MARTINGALE) volLote = volLote*2;
}
return false;
}
//----------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------
// Faz : Abre as ordens de fechamento das posicoes abertas no doOpenRajada. As posicoes de fechamento sao
// abertas sempre que as ordens da rajada sao executadas, ou seja, sempre que vao pra posicao.
// Aqui vamos eliminar o bug da versao doCloseRajada, que estah duplicando as ordens de fechamento
// da primeira ordem executada no fechamento da posicao.
//
// passo : aumento de preco na direcao contraria a posicao
// volLote : volume de ordem aberta na direcao contraria a posicao
// profit : quantidade de ticks para o gain
//------------------------------------------------------------------------------------------------------------
bool doCloseRajada(double passo, double volLote, double profit ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_tcloseRajada=GetMicrosecondCount();#endif
if( estouVendido() ){
return doCloseRajada2(m_passo_rajada, m_vol_lote_raj, m_qtd_ticks_4_gain_raj, true );
}else{
return doCloseRajada2(m_passo_rajada, m_vol_lote_raj, m_qtd_ticks_4_gain_raj, false);
}
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) m_tcloseRajada=GetMicrosecondCount()-m_tcloseRajada;#endif
}
//------------------------------------------------------------------------------------------------------------
// Faz : Abre as ordens de fechamento das posicoes abertas no doOpenRajada. As posicoes de fechamento sao
// abertas sempre que as ordens da rajada sao executadas, ou seja, sempre que vao pra posicao.
// Aqui vamos eliminar o bug da versao doCloseRajada, que estah duplicando as ordens de fechamento
// da primeira ordem executada no fechamento da posicao.
//
// passo : aumento de preco na direcao contraria a posicao
// volLote : volume de ordem aberta na direcao contraria a posicao
// profit : quantidade de ticks para o gain
// close_seel: true se estah fechando uma rajada de vendas e false se quer fechar uma rajada de compras.
//------------------------------------------------------------------------------------------------------------
string m_deal_comment;
double m_deal_vol = 0;
bool doCloseRajada2(double passo, double volLote, double profit, bool close_sell){
ulong deal_ticket; // ticket da transacao
int deal_type ; // tipo de operação comercial
//CQueue<long> qDealSel ; // fila de transacoes de venda da posicao. Ao final do segundo laco, devem ficar na fila, as vendas cuja compra nao foi concretizada...
//CQueue<long> qDealBuy ; // fila de transacoes de compra da posicao. Ao final do segundo laco, deve ficar vazia.
//CHashMap<long,string> hDealSel; // hash de transacoes de venda da posicao. Ao final do segundo laco, devem ficar na fila, as vendas cuja compra nao foi concretizada...
//CHashMap<long,string> hDealBuy; // hash de transacoes de compra da posicao. Ao final do segundo laco, deve ficar vazia.
// aproveitando pra atualizar o contador de transacoes na posicao...
m_volVendasNaPosicao = 0;
m_volComprasNaPosicao = 0;
// Faca assim:
// 1. Coloque vendas e compras em filas separadas.
// 2. Percorra a fila de compras e, pra cada compra encontrada, busque a venda correspondente e retire-a da fila de vendas.
// 3. Se sobraram vendas na fila de vendas, processe-a conforme abaixo.
HistorySelectByPosition(m_positionId); //preenchendo o cache com ordens e transacoes da posicao atual no historico...
int deals = HistoryDealsTotal();
// abrindo ordens de compra pra fechar uma rajada de vendas...
if(close_sell){
CQueue <long > qDealBuy; // fila de transacoes de compra da posicao. Ao final do segundo laco, deve ficar vazia.
CHashMap<long,long> hDealSel; // hash de transacoes de venda da posicao. Ao final do segundo laco, devem ficar na fila, as vendas cuja compra nao foi concretizada...
for(int i=0;i<deals;i++) { // selecionando as transacoes (entradas e saidas) para processamento...
deal_ticket = HistoryDealGetTicket (i);
deal_type = (int)HistoryDealGetInteger(deal_ticket,DEAL_TYPE );
m_deal_vol = HistoryDealGetDouble (deal_ticket,DEAL_VOLUME );
//m_deal_comment = HistoryDealGetString (deal_ticket,DEAL_COMMENT);
//Print("DEAL_COMMENT: I=",i, " COMMENT: ", HistoryDealGetString (deal_ticket,DEAL_COMMENT) );
if( i==0 ){
m_deal_comment = HistoryDealGetString (deal_ticket,DEAL_COMMENT);
if( StringFind(m_deal_comment,"IN") < 0 ){
fecharPosicao("STOP_RAJADA");
Print("DEAL_COMMENT: I=",i, " COMMENT: ", HistoryDealGetString (deal_ticket,DEAL_COMMENT) );
return false;
}
}
// 1. Colocando vendas e compras em estruturas separadas...
switch(deal_type){
case DEAL_TYPE_BUY : {qDealBuy.Add(deal_ticket ); m_volComprasNaPosicao += m_deal_vol; break;}
case DEAL_TYPE_SELL: {hDealSel.Add(deal_ticket,deal_ticket); m_volVendasNaPosicao += m_deal_vol; break;}
}
}
// 2. Percorra a fila de compras e, pra cada compra encontrada, busque a venda correspondente e retire-a da fila de vendas.
long ticketSel;
int qtd = qDealBuy.Count();
for(int i=0;i<qtd;i++) {
deal_ticket = qDealBuy.Dequeue();
ticketSel = StringToInteger( HistoryDealGetString(deal_ticket,DEAL_COMMENT) ); // obtendo o ticket de venda no comentario da ordem de compra...
hDealSel.Remove(ticketSel); // removendo a venda da fila de vendas pendentes de abrir posicao de compra...
}
// 3. Se sobraram vendas na fila de vendas, processe-a conforme abaixo.
// se sobrou elemento na fila, checamos se jah tem a ordem de compra correspondente. Se nao tiver, criamos.
double val = 0 ;
double precoProfit = 0 ;
string idClose ;
double vol = 0 ;
qtd = hDealSel.Count();
if( qtd > 0 ){
long vetSel[];
long vetSel2[];
hDealSel.CopyTo(vetSel,vetSel2);
for(int i=0;i<qtd;i++) {
deal_ticket = vetSel[i]; // qDealSel.Dequeue();
idClose = IntegerToString(deal_ticket); // colocando o ticket da venda na ordem de compra. Serah usado posteriormente
// para encontrar as compras que jah foram processadas.
if( m_qtdOrdens == 0 || !m_trade.tenhoOrdemPendenteComComentario(_Symbol, idClose ) ){
// se nao tem ordem de fechamento da posicao, criamos uma agora:
// se tem ateh 3 rajadas na posicao colocamos o preco da saida igual ao preco da saida da primeira ordem da posicao.
//if( m_volVendasNaPosicao > 1 && m_volVendasNaPosicao <= m_stop_qtd_contrat ){
// precoProfit = m_symb.NormalizePrice( HistoryDealGetDouble(deal_ticket,DEAL_PRICE) - profit*m_tick_size*(m_volVendasNaPosicao) );
//}else{
precoProfit = m_symb.NormalizePrice( HistoryDealGetDouble(deal_ticket,DEAL_PRICE) - profit*m_tick_size );
//}
if(precoProfit > m_ask) precoProfit = m_ask;
vol = HistoryDealGetDouble(deal_ticket,DEAL_VOLUME);
//if( HistoryDealGetString(deal_ticket,DEAL_COMMENT) == m_apmb ) vol = vol*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG )Print(":-| HFT_ORDEM CLOSE_RAJADA BUY_LIMIT=",precoProfit, " ID=", idClose, "... ", strPosicao() ); #endif
#ifndef COMPILE_PRODUCAO if(EA_SLEEP_ATRASO!= 0) Sleep(EA_SLEEP_ATRASO); #endif
m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT,precoProfit, vol, idClose);
incrementarPasso();
}
}
}
// abrindo ordens de venda pra fechar uma rajada de compras...
}else{
CQueue <long > qDealSel; // fila de transacoes de venda da posicao. Ao final do segundo laco, deve ficar vazia.
CHashMap<long,long> hDealBuy; // hash de transacoes de compra da posicao. Ao final do segundo laco, devem ficar na fila, as compras cuja venda nao foi concretizada...
for(int i=0;i<deals;i++) { // selecionando as transacoes (entradas e saidas) para processamento...
deal_ticket = HistoryDealGetTicket (i);
deal_type = (int)HistoryDealGetInteger(deal_ticket,DEAL_TYPE );
m_deal_vol = HistoryDealGetDouble (deal_ticket,DEAL_VOLUME );
//m_deal_comment = HistoryDealGetString (deal_ticket,DEAL_COMMENT);
if( i==0 ){
m_deal_comment = HistoryDealGetString (deal_ticket,DEAL_COMMENT);
if( StringFind(m_deal_comment,"IN") < 0 ){
fecharPosicao("STOP_RAJADA");
Print("DEAL_COMMENT: I=",i, " COMMENT: ", HistoryDealGetString (deal_ticket,DEAL_COMMENT) );
return false;
}
}
// 1. Colocando vendas e estruturas separadas...
switch(deal_type){
case DEAL_TYPE_BUY : {hDealBuy.Add(deal_ticket,deal_ticket); m_volComprasNaPosicao += m_deal_vol; break;}
case DEAL_TYPE_SELL: {qDealSel.Add(deal_ticket ); m_volVendasNaPosicao += m_deal_vol; break;}
}
}
// 2. Percorra a fila de vendas e, pra cada venda encontrada, busque a compra correspondente e retire-a da fila de compras.
int qtd = qDealSel.Count();
long ticketBuy;
for(int i=0;i<qtd;i++) {
deal_ticket = qDealSel.Dequeue();
ticketBuy = StringToInteger( HistoryDealGetString(deal_ticket,DEAL_COMMENT) ); // obtendo o ticket de compra no comentario da ordem de venda...
hDealBuy.Remove(ticketBuy); // removendo a compra da fila de compras pendentes de abrir posicao de venda...
}
// 3. Se sobraram compras na fila de compras, processe-a conforme abaixo.
// se sobrou elemento na fila, checamos se jah tem a ordem de venda correspondente. Se nao tiver, criamos.
double val = 0 ;
double precoProfit = 0 ;
string idClose ;
double vol = 0 ;
qtd = hDealBuy.Count();
if( qtd > 0 ){
long vetBuy [];
long vetBuy2[];
hDealBuy.CopyTo(vetBuy,vetBuy2);
for(int i=0;i<qtd;i++) {
deal_ticket = vetBuy[i]; // qDealBuy.Dequeue();
idClose = IntegerToString(deal_ticket); // colocando o ticket da compra na ordem de venda. Serah usado posteriormente
// para encontrar as vendas que jah foram processadas.
if( m_qtdOrdens == 0 || !m_trade.tenhoOrdemPendenteComComentario(_Symbol, idClose ) ){
// se nao tem ordem de fechamento da posicao, criamos uma agora:
// se tem ateh 3 rajadas na posicao colocamos o preco da saida igual ao preco da saida da primeira ordem da posicao.
//if( m_volComprasNaPosicao > 1 && m_volComprasNaPosicao <= m_stop_qtd_contrat ){
// precoProfit = m_symb.NormalizePrice( HistoryDealGetDouble(deal_ticket,DEAL_PRICE) + profit*m_tick_size*(m_volComprasNaPosicao) );
//}else{
precoProfit = m_symb.NormalizePrice( HistoryDealGetDouble(deal_ticket,DEAL_PRICE) + profit*m_tick_size );
//}
if(precoProfit < m_bid) precoProfit = m_bid;
vol = HistoryDealGetDouble(deal_ticket,DEAL_VOLUME);
//if( HistoryDealGetString(deal_ticket,DEAL_COMMENT) == m_apmb ) vol = vol*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG ) Print(":-| HFT_ORDEM CLOSE_RAJADA SELL_LIMIT=",precoProfit, " ID=", idClose, "...", strPosicao() ); #endif
#ifndef COMPILE_PRODUCAO if(EA_SLEEP_ATRASO!= 0) Sleep(EA_SLEEP_ATRASO); #endif
m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT,precoProfit, vol, idClose);
incrementarPasso();
}
}
}
}
return true;
}
// coloca duas ordens
void abrirPosicaoHFTnorteSul(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double inclinacaoMin = 0.1;
double shift = 1;
if( m_qtdOrdens == 1 ){
//m_trade.cancelarOrdensComentadas(m_apmb);
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_ns);
}
if(m_qtdOrdens==0){
// processando em paralelo
m_trade.setAsync(true);
if( m_inclBok < 0 ) {
// colocando a venda
precoOrdem = m_ask;
//precoOrdem = m_ask+m_tick_size;
//precoOrdem = m_ask+m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) Print("HFT_VENDA_NS=",precoOrdem,". Criando ordem de VENDA.", strPosicao()," ..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_ns );
// colocando a compra
precoOrdem = m_bid;
//precoOrdem = m_bid-m_tick_size;
//precoOrdem = m_bid-m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG) Print("HFT_COMPRA_NS=",precoOrdem,". Criando ordem de COMPRA.", strPosicao()," ..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, vol, m_apmb_ns );
}else{
// colocando a compra
precoOrdem = m_bid;
//precoOrdem = m_bid-m_tick_size;
//precoOrdem = m_bid-m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_COMPRA_NS=",precoOrdem,". Criando ordem de COMPRA.", strPosicao()," ..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, vol, m_apmb_ns );
// colocando a venda
precoOrdem = m_ask;
//precoOrdem = m_ask+m_tick_size;
//precoOrdem = m_ask+m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_VENDA_NS=",precoOrdem,". Criando ordem de VENDA.", strPosicao()," ..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_ns );
}
m_trade.setAsync(false);
}
/*
if( m_inclTra > 0 ){
// colocando a saida antes da entrada
precoOrdem = m_ask+m_tick_size;
Print("HFT_VENDA_NS=",precoOrdem,". Criando ordem de VENDA.", strPosicao()," ...");
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb );
precoOrdem = m_ask;
Print("HFT_COMPRA_NS=",precoOrdem,". Criando ordem de COMPRA.", strPosicao()," ...");
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, vol, m_strRajada );
}else{
precoOrdem = m_bid-m_tick_size;
Print("HFT_COMPRA_NS=",precoOrdem,". Criando ordem de COMPRA.", strPosicao()," ...");
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, vol, m_apmb );
precoOrdem = m_bid;
Print("HFT_VENDA_NS=",precoOrdem,". Criando ordem de VENDA.", strPosicao()," ...");
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_strRajada );
}
*/
}
// HFT_DISTANCIA_PRECO
// Abre e mantem as ordens limitadas de abertura de posicao.
// Condicoes:
// Compra abaixo da media de compra(barato) e vende acima da media de compra(caro);
// Ordens limitadas sao colocadas EA_TICKS_ENTRADA_DIST_PRECO (geralmente zero, 1 ou 2 ticks) de distancia do preco atual.
// Nao abre posicao durante o pregao.
// Nao abre posicao se a volatilidade estiver alta.
// Nao chame este metodo se houver posicao aberta.
// Correcoes na versao 02-084
// - Passa a considerar o ask pra comprar e o bid pra vender (estava invertido).
// - Passa a proteger a compra pra que o gain nao ultrapasse a media de agressoes (estava protegendo somente a venda).
// - Corrige a impressao do ordem de compra (estava colocando o valor errado).
void abrirPosicaoHFTdistanciaDoPreco(){
double precoOrdem = 0;
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
//if( m_inclTra <= -EA_INCL_MIN && m_volTradePorSegDeltaPorc < EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO ){
//if( m_inclTra <= -EA_INCL_MIN && m_volTradePorSegDeltaPorc < 0 && m_acelVolTradePorSegDeltaPorc > 0 ){
//if( m_inclTra <= -EA_INCL_MIN ){
//m_trade.cancelarOrdensComentadas(m_apmb_buy); m_precoUltOrdemInBuy = 0;
// se preco acima da media da banda de bollinguer e as extremidades abrindo, nao deixa vender...
//if( //m_ask > m_bbMed && //preco acima da media da banda de bollinguer
// m_bbMedDelta > 0 && //inclinacao da media pra cima
// m_bbSupDelta > 0 && //inclinacao da banda superior pra cima
// m_bbInfDelta < 0 ){//inclinacao da banda inferior pra baixo
//if( m_bbMedDelta < -2 ){//inclinacao da media pra baixo
//if( m_bbMedDelta < -5 && m_bbInfDelta < 0 ){//inclinacao da media pra baixo
//if( ( m_volTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO ) ||
// ( m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL_ACELERACAO ) ){
// Vende EA_TICKS_ENTRADA_DIST_PRECO ticks acima do preco atual.
precoOrdem = m_bid+(m_tick_size*EA_TICKS_ENTRADA_DIST_PRECO);
// vendendo acima da media...
if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini);
//precoOrdem = m_pmTra + (m_tick_size ); // pra teste
}
precoOrdem = normalizar(precoOrdem); //correcao aplicada em 17/01/2020
if( precoOrdem != m_precoUltOrdemInSel || m_precoUltOrdemInSel==0){
m_precoUltOrdemInSel = precoOrdem;
//if( precoOrdem > m_pmAsk ){ precoOrdem = m_pmAsk; }
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda ( precoOrdem, m_symb.Name(), m_apmb, m_vol_lote_ini, true, m_shift, m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_VENDA BID=",m_bid,". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel+getStrComment() );
}
}
//}else{
// m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_sel); m_precoUltOrdemInSel = 0;
//}
} // fim do "if" do tipos de entrada permitida "sell"...
//}else{
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
//if( m_inclTra >= EA_INCL_MIN && m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO){
//if( m_inclTra >= EA_INCL_MIN && m_volTradePorSegDeltaPorc > 0 && m_acelVolTradePorSegDeltaPorc > 0 ){
//if( m_inclTra >= EA_INCL_MIN ){
//m_trade.cancelarOrdensComentadas(m_apmb_sel); m_precoUltOrdemInSel = 0;
// se preco abaixo da media da banda de bollinguer e as extremidades abrindo, nao deixa comprar...
//if( //m_bid < m_bbMed && //preco abaixo da media da banda de bollinguer
// m_bbMedDelta < 0 && //inclinacao da media pra baixo
// m_bbSupDelta > 0 && //inclinacao da banda superior pra cima
// m_bbInfDelta < 0 ){//inclinacao da banda inferior pra baixo
//if( m_bbMedDelta > 2 ){//inclinacao da media pra cima
//if( m_bbMedDelta > 5 && m_bbSupDelta > 0 ){//inclinacao da media pra cima
//if( ( m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO ) ||
// ( m_volTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL_ACELERACAO ) ){
//Compra EA_TICKS_ENTRADA_DIST_PRECO abaixo do preco atual.
precoOrdem = m_ask-(m_tick_size*EA_TICKS_ENTRADA_DIST_PRECO);
// comprando abaixo da media (barato)...
if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini );
//precoOrdem = m_pmTra - (m_tick_size );
}
precoOrdem = normalizar(precoOrdem); //correcao aplicada em 17/01/2020
if( precoOrdem != m_precoUltOrdemInBuy || m_precoUltOrdemInBuy==0){
m_precoUltOrdemInBuy = precoOrdem;
//if( precoOrdem < m_pmBid ){ precoOrdem = m_pmBid; }
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, m_vol_lote_ini , true, m_shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_COMPRA ASK=",m_ask,". Criando ordem de COMPRA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy+getStrComment() );
}
}
//}else{
// m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_buy); m_precoUltOrdemInBuy = 0;
//}
} // fim do "if" controle do tipo de entrada permitida "compra"...
//}
}
//void calcStopLossPosicao(){ if( EA_PASSO_DINAMICO ){ m_stopLossPosicao = (m_len_canal_entrelacamento*m_tick_size)*-1; } }
void calcStopLossPosicao(){ if( EA_PASSO_DINAMICO ){ m_stopLossPosicao = (m_len_canal_entrelacamento*EA_PASSO_DINAMICO_STOP_PORC_CANAL)*-1; } }
// HFT_REGIAO_CANAL_ENTRELACA (nova estrategia implantada em 08/04/2020 13:39)
// Abre e mantem as ordens limitadas de nas regioes de compra e venda do canal de entrelacamento.
// Condicoes:
// Compra se preco na porcao inferior do canal;
// Vende se preco na porcao superior do canal;
void abrirPosRegiaoCanalEntrelaca(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double shift = 0;
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
precoOrdem = m_bid;
if( regiaoPrecoPermiteVenda() ){
//if( regiaoPrecoPermiteVenda() && precoOrdem >= m_pmTra ){
//if( entrelacamentoDeAlta() && precoOrdem >= m_pmTra ){
//precoOrdem = m_pmTra + EA_TICKS_ENTRADA_DIST_MEDIA*m_tick_size;
//
//// vendendo acima da media...
//if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini) ){
// precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini);
//}
precoOrdem = normalizar(precoOrdem);
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size*shift, m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_VENDA BID=",m_bid,". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_sel+getStrComment() );
}
return;
}else{m_trade.cancelarOrdensComentadasDeVenda(m_symb_str,m_apmb);}
} // fim do "if" do tipos de entrada permitida "sell"...
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
precoOrdem = m_ask;
if( regiaoPrecoPermiteCompra() ){
//if( regiaoPrecoPermiteCompra() && precoOrdem <= m_pmTra ){
//if( entrelacamentoDeBaixa () && precoOrdem <= m_pmTra ){
//precoOrdem = m_pmTra - EA_TICKS_ENTRADA_DIST_MEDIA*m_tick_size;
//
//// comprando abaixo da media (barato)...
//if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
// precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini );
//}
precoOrdem = normalizar(precoOrdem);
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size*shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_COMPRA ASK=",m_ask,". Criando ordem de COMPRA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb_buy+getStrComment() );
}
}else{m_trade.cancelarOrdensComentadasDeCompra(m_symb_str,m_apmb);}
} // fim do "if" controle do tipo de entrada permitida "compra"...
}
// HFT_FLUXO_ORDENS (nova estrategia implantada em 04/03/2020)
// Abre e mantem as ordens limitadas de acordo com a probabilidade do preco subir/descer baseado no book de ofertas e no fluxo de transacoes.
// Condicoes:
// Compra se probabilidade do preco subir for mair que 80%;
// Vende se probabilidade do preco descer for mair que 80%;
void abrirPosicaoHFTfluxoOrdens(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double shift = 0;
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
precoOrdem = m_ask;
//if( m_probAskDescer > EA_PROB_UPDW && precoOrdem > (m_pmTra+m_tick_size*m_qtd_ticks_4_gain_ini) ){
//if( m_probAskDescer > EA_PROB_UPDW && precoOrdem >= m_pmTra ){
//if( m_probAskDescer > EA_PROB_UPDW && m_volTradePorSegDeltaPorc<0 && precoOrdem >= m_pmTra ){
//if( m_probAskDescer > EA_PROB_UPDW && m_volTradePorSegDeltaPorc<0 && precoOrdem >= m_pmTra && m_acelVolTradePorSegDeltaPorc>0 ){
//if( m_probAskDescer > EA_PROB_UPDW && regiaoPrecoPermiteVenda() && precoOrdem >= m_pmTra ){
if( m_probAskDescer > EA_PROB_UPDW && regiaoPrecoPermiteVenda() ){
//precoOrdem = m_pmTra + EA_TICKS_ENTRADA_DIST_MEDIA*m_tick_size;
//
//// vendendo acima da media...
//if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini) ){
// precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini);
//}
//if( precoOrdem < m_bid ){ precoOrdem = m_bid; }
precoOrdem = normalizar(precoOrdem);
//if( precoOrdem != m_precoUltOrdemInSel || m_precoUltOrdemInSel==0 ){
// m_precoUltOrdemInSel = precoOrdem;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size*shift, m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_VENDA BID=",m_bid,". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_sel+getStrComment() );
}
return;
//}
}else{m_trade.cancelarOrdensComentadasDeVenda(m_symb_str,m_apmb);}
} // fim do "if" do tipos de entrada permitida "sell"...
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
precoOrdem = m_bid;
//if( m_probAskSubir > EA_PROB_UPDW && precoOrdem < m_pmTra-(m_tick_size*m_qtd_ticks_4_gain_ini) ){
//if( m_probAskSubir > EA_PROB_UPDW && precoOrdem <= m_pmTra ){
//if( m_probAskSubir > EA_PROB_UPDW && m_volTradePorSegDeltaPorc>0 && precoOrdem <= m_pmTra ){
//if( m_probAskSubir > EA_PROB_UPDW && m_volTradePorSegDeltaPorc>0 && precoOrdem <= m_pmTra && m_acelVolTradePorSegDeltaPorc>0 ){
//if( m_probAskSubir > EA_PROB_UPDW && regiaoPrecoPermiteCompra() && precoOrdem <= m_pmTra ){
if( m_probAskSubir > EA_PROB_UPDW && regiaoPrecoPermiteCompra() ){
//precoOrdem = m_pmTra - EA_TICKS_ENTRADA_DIST_MEDIA*m_tick_size;
//
//// comprando abaixo da media (barato)...
//if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
// precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini );
//}
//if( precoOrdem > m_ask ){precoOrdem = m_ask;}
precoOrdem = normalizar(precoOrdem);
//if( precoOrdem != m_precoUltOrdemInBuy || m_precoUltOrdemInBuy==0 ){
// m_precoUltOrdemInBuy = precoOrdem;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size*shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_COMPRA ASK=",m_ask,". Criando ordem de COMPRA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb_buy+getStrComment() );
}
//}
}else{m_trade.cancelarOrdensComentadasDeCompra(m_symb_str,m_apmb);}
} // fim do "if" controle do tipo de entrada permitida "compra"...
//}
}
// HFT_DISTANCIA_DA_MEDIA (nova estrategia implanatada em 29/01/2020)
// Abre e mantem as ordens limitadas de abertura de posicao.
// Condicoes:
// Compra abaixo da media de compra(barato) e vende acima da media de compra(caro);
// Ordens limitadas sao colocadas EA_TICKS_FOR_GAIN de distancia da media.
void abrirPosicaoHFTdistanciaDaMedia(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double shift = 0;
if( ( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS) && regiaoPrecoPermiteVenda() ){
precoOrdem = m_pmTra + EA_TICKS_ENTRADA_DIST_MEDIA*m_tick_size;
// vendendo acima da media...
if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini);
}
if( precoOrdem < m_bid ){ precoOrdem = m_bid; }
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInSel || m_precoUltOrdemInSel==0 ){
m_precoUltOrdemInSel = precoOrdem;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size*shift, m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_VENDA BID=",m_bid,". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_sel+getStrComment() );
}
}
} // fim do "if" do tipos de entrada permitida "sell"...
if( (EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS) && regiaoPrecoPermiteCompra() ){
precoOrdem = m_pmTra - EA_TICKS_ENTRADA_DIST_MEDIA*m_tick_size;
// comprando abaixo da media (barato)...
if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini );
}
if( precoOrdem > m_ask ){precoOrdem = m_ask;}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInBuy || m_precoUltOrdemInBuy==0 ){
m_precoUltOrdemInBuy = precoOrdem;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size*shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| HFT_COMPRA ASK=",m_ask,". Criando ordem de COMPRA a ", precoOrdem, " ", strPosicao(),"..."); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb_buy+getStrComment() );
}
}
} // fim do "if" controle do tipo de entrada permitida "compra"...
//}
}
//------------------------------------------------------------------------------------------------------------
// HFT_NA_TENDENCIA
// Abre e mantem as ordens de abertura de posicao HFT.
// Abre e mantem as ordens limitadas de abertura de posicao.
// Condicoes:
// Tenta abrir na tendencia.
// Compra abaixo da media de compra(barato) e vende acima da media de compra(caro);
// Nao abre posicao durante o pregao.
// Nao abre posicao se a volatilidade estiver alta.
// Nao chame este metodo se houver posicao aberta.
//------------------------------------------------------------------------------------------------------------
void abrirPosicaoHFTnaTendencia(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double incl_limite = 0.08;
//Se a volatilidade estah alta, cancela as ordens de abertura de posicao.
//if ( volatilidadeEstahAlta() ){ m_trade.cancelarOrdensComentadas(m_apmb); return; }
// Vendendo na inclinacao negativa...
//if( m_feira.getSinalInclinacaoDw(0) > 0 && m_volTradePorSegDeltaPorc < 10 && m_bid < m_bbMed + m_dx1 ){
//if( m_feira.getSinalInclinacaoDw(0) > 0 && m_bid < m_bbMed + m_dx1 ){
//if( m_feira.getSinalInclinacaoDw(0) > 0 && m_bbMedDelta<0 && m_ask < m_bbMed + m_dx1 ){
//if( m_feira.getSinalInclinacaoDw(0) > 0 && m_bbMedDelta<0 && m_ask < m_bbMed + m_dx1 && m_bbSupDelta>0 && m_bbInfDelta<0){
//if( m_bbMedDelta<0 && m_ask < m_bbMed + m_dx1 && m_bbSupDelta>0 && m_bbInfDelta<0){
//if( m_bbMedDelta<0 && m_bbInfDelta<0){
if( (m_bbMedDelta<-1 && m_ask < m_bbMed && m_bbInfDelta<-2) ||
(m_bbMedDelta<-1 && m_ask > m_bbMed && m_bbSupDelta<-2) ){
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_buy);
precoOrdem = m_phigh;
if(precoOrdem > m_pmAsk) precoOrdem = m_pmAsk;
if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini);
}
precoOrdem = normalizar(precoOrdem);
/*
precoOrdem = m_ask;
//if( precoOrdem < m_pmTra - (m_tick_size*m_qtd_ticks_4_gain) ){
//if( precoOrdem < m_pmTra ){
// precoOrdem = normalizar( m_pmTra + (m_tick_size*m_qtd_ticks_4_gain) );
// //precoOrdem = normalizar( m_pmTra );
//}
if( precoOrdem > m_pmAsk ){
precoOrdem = normalizar( m_pmAsk );
}
*/
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_ORDEM OPEN_POS BID=",m_bid,". Criando ord VENDA a ", precoOrdem, strPosicao());#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_sel+getStrComment() );
}
return;
}else{
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_sel);
}
// Comprando na inclinacao positiva e gain abaixo ou igual a media de precos...
//if( m_feira.getSinalInclinacaoUp(0)>0 && m_volTradePorSegDeltaPorc > -10 && m_ask > m_bbMed - m_dx1 ){ //(estrategia 1)
//if( m_feira.getSinalInclinacaoUp(0)>0 && m_ask > m_bbMed - m_dx1 ){ //(estrategia 2)
//if( m_feira.getSinalInclinacaoUp(0)>0 && m_bbMedDelta>0 && m_bid > m_bbMed - m_dx1 ){ //(estrategia 3)
//if( m_feira.getSinalInclinacaoUp(0)>0 && m_bbMedDelta>0 && m_bid > m_bbMed - m_dx1 && m_bbSupDelta>0 && m_bbInfDelta<0 ){ //(estrategia 4)
//if( m_bbMedDelta>0 && m_bid > m_bbMed - m_dx1 && m_bbSupDelta>0 && m_bbInfDelta<0 ){ //(estrategia 4)
//if( m_bbMedDelta>0 && m_bbSupDelta>0 ){ //(estrategia 6)
if( (m_bbMedDelta>1 && m_bid > m_bbMed && m_bbSupDelta>2) ||
(m_bbMedDelta>1 && m_bid < m_bbMed && m_bbInfDelta>2) ){ //(estrategia 7)
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_sel);
precoOrdem = m_plow;
if(precoOrdem < m_pmBid) precoOrdem = m_pmBid;
if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini);
}
precoOrdem = normalizar(precoOrdem);
/*
precoOrdem = normalizar(m_bid);
//if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain) ){
//if( precoOrdem > m_pmTra ){
// precoOrdem = normalizar( m_pmTra - (m_tick_size*m_qtd_ticks_4_gain) );
// //precoOrdem = normalizar( m_pmTra );
//}
if( precoOrdem > m_pmBid ){
precoOrdem = normalizar( m_pmBid );
}
*/
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_ORDEM OPEN_POS ASK=",m_ask,". Criando ord COMPRA a ", precoOrdem, strPosicao() ," ... profit=", m_posicaoProfit);#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb_buy+getStrComment() );
}
return;
}else{
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_buy);
}
}
//------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------
// Estrategia testada em 29/11/2019 retornou
//CONTRA_TEND_DURANTE_COMPROMETIMENTO
void abrirPosicaoDuranteComprometimentoInstitucional(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double shift = m_tick_size;
//double shift = 0
precoOrdem = normalizar(m_pmAsk); // venda no preco medio de compra
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, shift ) ){
if(precoOrdem!=0) {
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_ASK=",m_pmAsk,". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao(),"...");#endif
m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb);
}else{
m_qtd_erros++;
if(m_qtd_erros>1000){
Print(":-( MEDIA_ASK=",m_pmAsk,". Preco zerado ao criar ordem de VENDA a ", precoOrdem, "... VERIFIQUE!", strPosicao());
m_qtd_erros=0;
}
}
}
precoOrdem = normalizar(m_pmBid); // copmpra no preco medio de venda
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, shift ) ){
if(precoOrdem!=0){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_BID ",m_pmBid,". Criando ordem de COMPRA a ", precoOrdem, " ", strPosicao(), "...");#endif
m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb);
}else{
m_qtd_erros++;
if(m_qtd_erros>1000){
Print(":-( MEDIA_BID ",m_pmBid,". Preco zerado ao criar ordem de COMPRA a ", precoOrdem, "... VERIFIQUE!", strPosicao());
m_qtd_erros=0;
}
}
}
}
//------------------------------------------------------------------------------------------------------------
// Abre posicao na vela seguinte ao comprometimento institucional, no mesmo valor do ponto de comprometimento
// e contra sua direcao.
//------------------------------------------------------------------------------------------------------------
void abrirPosicaoAposComprometimentoInstitucional(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
//double shift = m_tick_size;
double shift = 0 ;
bool tem_comprometimento = false;
// Vende se o preco ficar maior que o comprometimento institucional da vela anterior
//if ( m_comprometimento_up > 0 && m_ask >= (m_comprometimento_up-shift) ){
if ( m_comprometimento_up > 0 ){
tem_comprometimento = true;
if( m_ask >= (m_comprometimento_up-shift) ){
precoOrdem = m_ask; // se o ask jah passou do valor do comprometimento, entramos com o preco ask.
}else{
precoOrdem = m_comprometimento_up; // se ask nao passou do valor do comprometimento, entramos no valor do comprometimento
}
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("COMPROMISSO_UP=",m_comprometimento_up,". Criando ordem de VENDA a ", precoOrdem, "...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb);
}
}
// Compra se o preco ficar menor que o comprometimento institucional da vela anterior
//if( m_comprometimento_dw > 0 && m_bid <= (m_comprometimento_dw+shift) ){
// precoOrdem = m_bid; // copmpra no preco medio de venda
if ( m_comprometimento_dw > 0 ){
tem_comprometimento = true;
if( m_bid <= (m_comprometimento_up+shift) ){
precoOrdem = m_bid; // se o bid jah passou do valor do comprometimento, entramos com o preco bid.
}else{
precoOrdem = m_comprometimento_dw; // se bid nao passou do valor do comprometimento, entramos no valor do comprometimento
}
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("COMPROMISSO_DW=",m_comprometimento_dw,". Criando ordem de COMPRA a ", precoOrdem, "...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb);
}
}
// se nao tem comprometimento, cancela as ordens abertas.
if (!tem_comprometimento) m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb);
}
//----------------------------------------------------------------------------------------------------------------------------------
// Abre e mantem as ordens de abertura de posicao. Nao chame este metodo se houver posicao aberta.
void abrirPosicaoAposMaxMinBarraAnterior(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
//Nao abrir posicao se volatilidade for alta.
//se a volatilidade estah alta, cancela as ordens de abertura de posicao.
if ( volatilidadeEstahAlta() ) { m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb); return; }
//Vende se o preco ficar maior que a maxima da vela anterior.
if( m_ask >= m_max_barra_anterior ){
precoOrdem = m_ask; // se o ask jah passou a maxima da barra anterior, entramos com o preco ask.
}else{
precoOrdem = m_max_barra_anterior; // se ask nao passou a maxima da barra anterior, entramos na maxima da barra anterior
}
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("MAX_BARRA_ANT=",m_max_barra_anterior,". Criando ordem de VENDA a ", precoOrdem, " Volatilidade=",m_volatilidade," ...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb);
}
//Compra se o preco ficar menor que a minima da vela anterior.
//Nao abrir posicao se volatilidade for alta.
if( m_bid <= m_min_barra_anterior ){
precoOrdem = m_bid; // se o bid jah passou o minimo da barra anterior, entramos com o preco bid.
}else{
precoOrdem = m_min_barra_anterior; // se bid nao passou o minimo da barra anterior, entramos no minimo da barra anterior
}
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, vol , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("MIN_BARRA_ANT=",m_min_barra_anterior,". Criando ordem de COMPRA a ", precoOrdem, " Volatilidade=",m_volatilidade, " ...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb);
}
}
/*
// Abre posicao apos rompimento do max ou min da volatilidade...
// ESta opcao nao se importa se a volatilidade estiver alta
void abrirPosicaoCCINaTendencia(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
//double shift = m_tick_size*3;
double inclinacao_min = EA_INCL_MIN;
if ( !taxaVolumeEstahL2() ) return;
precoOrdem = m_bid;
if( precoOrdem <= m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
//if( precoOrdem < m_pmTra ){
//precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain);
//precoOrdem = m_pmTra;
// cci acima de 100 e cci apontando pra baixo...
if( (m_icci.Main(0) > 0 &&
m_icci.Main(0) < m_icci.Main(1) &&
m_icci.Main(1) <= m_icci.Main(2) && // comentado na cci-v6
m_inclTra < -inclinacao_min ) ||
m_icci.Main(0) > 200 ){ // CCI pra baixo;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb_sel, vol , true, m_tick_size ) ){
if(precoOrdem!=0) {
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao(),"...");#endif
m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_sel);
}
}
}else{
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_sel);
}
}
precoOrdem = m_ask;
if( precoOrdem >= m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
//if( precoOrdem > m_pmTra ){
//precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain );
//precoOrdem = m_pmTra ;
// cci abaixo de -100 e cci apotando pra cima...
if( (m_icci.Main(0) < 0 &&
m_icci.Main(0) > m_icci.Main(1) &&
m_icci.Main(1) >= m_icci.Main(2) &&
m_inclTra > inclinacao_min ) ||
m_icci.Main(0) < -200 ){ // CCI pra cima;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb_buy, vol , true, m_tick_size ) ){
if(precoOrdem!=0){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando ordem de COMPRA a ", precoOrdem, " ", strPosicao(), "...");#endif
m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, vol, m_apmb_buy);
}
}
}else{
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_buy);
}
}
}
*/
//HFT_BB_NA_TENDENCIA
void abrirPosicaoNaBBNaTendencia(){
double precoOrdem = 0;
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
if( m_bbSupDelta > EA_LIMITE_ENTRADA_BBM &&
m_bbMedDelta > EA_LIMITE_ENTRADA_BBM &&
m_bbInfDelta < -EA_LIMITE_ENTRADA_BBM ){
//precoOrdem = m_bbInf;
precoOrdem = m_ask;
//if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) ){
// precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini);
//}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInBuy || m_precoUltOrdemInBuy == 0 ){
m_precoUltOrdemInBuy = precoOrdem;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb_buy, m_vol_lote_ini , true, m_shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando ordem de COMPRA a ", precoOrdem," ", strPosicao());#endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy + getStrComment() );
}
}
}
}
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
if( m_bbSupDelta > EA_LIMITE_ENTRADA_BBM &&
m_bbMedDelta < -EA_LIMITE_ENTRADA_BBM &&
m_bbInfDelta < -EA_LIMITE_ENTRADA_BBM ){
//precoOrdem = m_bbSup;
precoOrdem = m_bid;
//if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
// precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini );
//}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInSel || m_precoUltOrdemInSel == 0 ){
m_precoUltOrdemInSel = precoOrdem;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb_sel, m_vol_lote_ini , true, m_shift,m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao() );#endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO);#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel + getStrComment() );
//m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
//m_vol_close_position_sel = m_vol_lote_ini;
}
}
}
}
}
//HFT_HIBRIDO_MAX_MIN_VOL_X_DISTANCIA_PRECO
//Abre posicao:
// - A favor da tendencia no rompimento da distancia do preco;
// - Contra tendencia no rompimento do max ou min da volatilidade e se acima/abaixo da banda de bollinguer...
// - - aceleracao % deltaVolumeTrade positiva e maior que EA_MIN_DELTA_VOL_ACELERACAO
void abrirPosHibridaMaxMinVolatDistanciaPreco(){
double precoOrdem = 0;
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
// Na tendencia de alta...
if( m_bbMedDelta > 3 ){
// Usamos a distancia do preco para entrar na posicao compradora...
precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini);
// Na tendencia de baixa...
}else{
// Usamos a mínima do periodo para entrar na posicao se a minimo estiver abaixo da banda superior de bollinguer...
if( m_plow < m_bbInf-m_dx1 ){
precoOrdem = m_plow;
}else{
precoOrdem = m_bbInf-m_dx1;
}
}
if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini);
}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInBuy || m_precoUltOrdemInBuy == 0 ){
m_precoUltOrdemInBuy = precoOrdem;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb_buy, m_vol_lote_ini , true, m_shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando ordem de COMPRA a ", precoOrdem," ", strPosicao());#endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy + getStrComment() );
}
}
}
if( EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS ){
// Na tendencia de baixa...
if( m_bbMedDelta < -3 ){
// Usamos a distancia do preco para entrar na posicao vendedora...
precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini);
// Na tendencia de alta...
}else{
// Usamos a maxima do periodo para entrar na posicao se a maxima estiver acima da banda superior de bollinguer...
if( m_phigh > m_bbSup+m_dx1 ){
precoOrdem = m_phigh;
}else{
precoOrdem = m_bbSup+m_dx1;
}
}
if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini );
}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInSel || m_precoUltOrdemInSel == 0 ){
m_precoUltOrdemInSel = precoOrdem;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb_sel, m_vol_lote_ini , true, m_shift,m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao() );#endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO);#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel + getStrComment() );
//m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
//m_vol_close_position_sel = m_vol_lote_ini;
}
}
}
}
//HFT_MAX_MIN_VOLAT
//Abre posicao apos rompimento do max ou min da volatilidade...
// Condicoes compra:
// - preco abaixo da media de trade
// - preco igual ao minimo no historico de 1 min (um tick de tolerancia)
// - mercado comprador: - % deltaVolumeTrade positivo e maior que EA_MIN_DELTA_VOL
// - - aceleracao % deltaVolumeTrade positiva e maior que EA_MIN_DELTA_VOL_ACELERACAO
// Condicoes compra:
// - preco acima da media de trade
// - preco igual ao maximo no historico de 1 min (um tick de tolerancia)
// - mercado vendedor: - % deltaVolumeTrade negativo e menor que EA_MIN_DELTA_VOL
// - - aceleracao % deltaVolumeTrade positiva e maior que EA_MIN_DELTA_VOL_ACELERACAO
//
void abrirPosMaxMinVolatContraTend(){
double precoOrdem = 0;
if( (EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_BUY || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS) && regiaoPrecoPermiteCompra() ){
// mercado estah comprador, entao cancelamos ordens de venda pendentes e abrimos as de compra....
// if( ( m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO )
// ||
// ( m_volTradePorSegDeltaPorc < 0 &&
// m_volTradePorSegDeltaPorc > -20 &&
// m_acelVolTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL_ACELERACAO )// mercado vendedor, mas desacelerando...
// ){
//
// m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_sel);
//
precoOrdem = m_plow + (2*m_tick_size); // compra no topo inferior do canal de volatilidade
//if( precoOrdem > m_pmBid - (m_tick_size*m_qtd_ticks_4_gain_ini) ){
// precoOrdem = m_pmBid - (m_tick_size*m_qtd_ticks_4_gain_ini);
//}
if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini);
}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInBuy || m_precoUltOrdemInBuy == 0 ){
m_precoUltOrdemInBuy = precoOrdem;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb_buy, m_vol_lote_ini , true, m_shift, m_apmb_buy+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando ordem de COMPRA a ", precoOrdem," ", strPosicao());#endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO); #endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy + getStrComment() );
//m_val_close_position_buy = precoOrdem + (m_tick_size*m_qtd_ticks_4_gain_ini);
//m_vol_close_position_buy = m_vol_lote_ini;
}
}
}
// }else
//
if( (EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_SELL || EA_TIPO_ENTRADA_PERMITIDA == ENTRADA_TODAS) && regiaoPrecoPermiteVenda() ){
// // mercado estah vendedor, entao cancelamos ordens de compra pendentes e abrimos as venda....
// if( (m_volTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO)
// ||
// ( m_volTradePorSegDeltaPorc > 0 &&
// m_volTradePorSegDeltaPorc < 20 &&
// m_acelVolTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL_ACELERACAO )// mercado comprador, mas desacelerando...
// ){
//
// m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_buy);
//
precoOrdem = m_phigh-(2*m_tick_size); // venda no topo superior do canal de volatilidade
if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
precoOrdem = m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini );
}
precoOrdem = normalizar(precoOrdem);
if( precoOrdem != m_precoUltOrdemInSel || m_precoUltOrdemInSel == 0 ){
m_precoUltOrdemInSel = precoOrdem;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb_sel, m_vol_lote_ini , true, m_shift,m_apmb_sel+getStrComment() ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao() );#endif
#ifndef COMPILE_PRODUCAO if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO);#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel + getStrComment() );
//m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
//m_vol_close_position_sel = m_vol_lote_ini;
}
}
}
// }
// else{
// m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb);
// }
/*
else{
// mercado sem direcao definida, entao podemos manter pedidos nas duas direcoes.
precoOrdem = m_plow; // compra no topo inferior do canal de volatilidade
if( precoOrdem > m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) ){
precoOrdem = normalizar( m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) );
}
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb_buy, m_vol_lote_ini , true, m_tick_size ) ){
if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando ordem de COMPRA a ", precoOrdem," ", strPosicao());
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy + getStrComment() );
m_val_close_position_buy = precoOrdem + (m_tick_size*m_qtd_ticks_4_gain_ini);
m_vol_close_position_buy = m_vol_lote_ini;
}
precoOrdem = m_phigh; // venda no topo superior do canal de volatilidade
if( precoOrdem < m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){
precoOrdem = normalizar( m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) );
}
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb_sel, m_vol_lote_ini , true, m_tick_size ) ){
if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao() );
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel + getStrComment() );
m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
m_vol_close_position_sel = m_vol_lote_ini;
}
}
*/
}
// HFT_ARBITRAGEM_VOLUME
// Abre posicao na arbitragem de volume.
// Se preco acima da media de trade e volume de vendas eh maior que volume de compras, vende .
// Se preco abaixo da media de trade e volume de compras eh maior que volume de vendas , compra.
// ESta opcao nao se importa se a volatilidade estiver alta
void abrirPosicaoArbitragemVolume(){
double precoOrdem = 0;
// mercado estah comprador, entao cancelamos ordens de venda pendentes e abrimos as de compra....
if( m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO ){
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_sel);
// comprando abaixo da media...
//precoOrdem = normalizar( m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini) );
precoOrdem = m_bid;
//verificando se tem ordens buy abertas (usando 1 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb_buy, m_vol_lote_ini , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando ordem de COMPRA a ", precoOrdem," ", strPosicao());#endif
if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO);
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy + getStrComment() );
m_val_close_position_buy = precoOrdem + (m_tick_size*m_qtd_ticks_4_gain_ini);
m_vol_close_position_buy = m_vol_lote_ini;
}
}else
// mercado estah vendedor, entao cancelamos ordens de compra pendentes e abrimos as venda....
if( m_volTradePorSegDeltaPorc < -EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO ){
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb_buy);
// vendendo acima da media...
//precoOrdem = normalizar( m_pmTra + (m_tick_size*m_qtd_ticks_4_gain ) );
precoOrdem = m_ask;
//verificando se tem ordens sell abertas (usando 1 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb_sel, m_vol_lote_ini , true, m_tick_size ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando ordem de VENDA a ", precoOrdem, " ", strPosicao() );#endif
if( EA_SLEEP_ATRASO!= 0 ) Sleep(EA_SLEEP_ATRASO);
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel + getStrComment() );
m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
m_vol_close_position_sel = m_vol_lote_ini;
}
}
else{
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb);
}
}
string getStrComment(){
if( EA07_ABRIR_POSICAO == HFT_DESBALANC_BOOK ||
EA07_ABRIR_POSICAO == HFT_DESBALANC_BOOKNS ){
return getStrCommentBook();
}else if(EA07_ABRIR_POSICAO==HFT_FLUXO_ORDENS){
return getStrCommentFluxo();
}else{
return getStrCommentEntrelac();
return
" v" +DoubleToString (m_volTradePorSeg ,0) + // volume de contratos/ticks negociados por segundo
" d" +IntegerToString(m_volTradePorSegDeltaPorc ) + // % delta dos contratos/ticks negociados por segundo.
" a" +IntegerToString(m_acelVolTradePorSegDeltaPorc ) + // aceleracao da % delta dos contratos/ticks negociados por segundo.
//" t" +DoubleToString (m_volatilidade*10 ,0) + // volatilidade
" t" +DoubleToString (m_volatilidade_4_seg ,0) + // volatilidade medida por segundo
" i" +DoubleToString (m_inclTra*10 ,0) + // inclinacao das agressoes
" b" +DoubleToString (m_desbUp0*100 ,0) + // desbalanceamento book na primeira fila
" b" +DoubleToString (m_desbUp1*100 ,0) ; // desbalanceamento book na segunda fila
}
}
string getStrCommentBook(){
return getStrCommentEntrelac();
return
" v" +DoubleToString (m_volTradePorSeg ,0) + // volume de contratos/ticks negociados por segundo
" d" +IntegerToString(m_volTradePorSegDeltaPorc ) + // % delta dos contratos/ticks negociados por segundo.
" a" +IntegerToString(m_acelVolTradePorSegDeltaPorc ) + // aceleracao da % delta dos contratos/ticks negociados por segundo.
" b" +DoubleToString (m_desbUp0*100 ,0) + // desbalanceamento book na primeira fila
" b" +DoubleToString (m_desbUp1*100 ,0) + // desbalanceamento book na segunda fila
//" t" +DoubleToString (m_volatilidade*10 ,0) ; // volatilidade
" t" +DoubleToString (m_volatilidade_4_seg ,0) ; // volatilidade medida por segundo
}
string getStrCommentFluxo(){
return getStrCommentEntrelac();
return
//" v" +DoubleToString (m_volTradePorSeg ,0) + // volume de contratos/ticks negociados por segundo
//" t" +DoubleToString (m_volatilidade*10 ,0) + // volatilidade
" t" +DoubleToString (m_volatilidade_4_seg ,0) + // volatilidade medida por segundo
" d" +IntegerToString(m_volTradePorSegDeltaPorc ) + // % delta dos contratos/ticks negociados por segundo.
" a" +IntegerToString(m_acelVolTradePorSegDeltaPorc ) + // aceleracao da % delta dos contratos/ticks negociados por segundo.
" s" +DoubleToString (m_probAskSubir*100.0 ,0) + // probabildade do preco subir.
//" w" +DoubleToString (m_probAskDescer*100.0 ,0) + // probabildade do preco descer.
" c" +DoubleToString (m_coefEntrelaca*100 ,0) + // coeficiente de entrelacamento
//" f" +DoubleToString (m_est.getFluxoAsk() ,0) + // fluxo na parte Ask do Book
" g" +DoubleToString (m_est.getFluxoBid() ,0) ; // fluxo na parte Bid do Book
}
string getStrCommentEntrelac(){
return
" v" +DoubleToString (m_volatilidade_4_seg_media ,0) + // volatilidade medida por segundo media.
" p" +DoubleToString (m_est.getPrbAskSubir ()*100,0) + // probabildade do preco subir.
" e" +DoubleToString (m_coefEntrelaca*100 ,0) + // coeficiente de entrelacamento.
" d" +DoubleToString (m_len_canal_entrelacamento ,0) + // tamanho do canal de entrelacamento.
" c" +DoubleToString (m_regiaoPrecoCompra*100 ,0) ; // distancia dos extremos do canal de entrelacamento em porcentagem.
}
// Abre posicao se houver desbalanceamento de ofertas nas primeiras filas do book...
// Esta opcao nao se importa se a volatilidade estiver alta
// HFT_DESBALANC_BOOK
void abrirPosicaoHFTDesbalancBook(){
double precoOrdem = 0;
//precoOrdem = m_ask;
if( (m_desbUp0 <= EA_DESBALAN_DW0 || EA_DESBALAN_DW0 == 0) && // 80% de chance do o preco cair
(m_desbUp1 <= EA_DESBALAN_DW1 || EA_DESBALAN_DW1 == 0) && // 70% de chance do o preco cair
(m_desbUp2 <= EA_DESBALAN_DW2 || EA_DESBALAN_DW2 == 0) && // 65% de chance do o preco cair
(m_desbUp3 <= EA_DESBALAN_DW3 || EA_DESBALAN_DW3 == 0) // 60% de chance do o preco cair
//m_volTradePorSegDeltaPorc < EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO && // volume de vendas superior.
//precoOrdem >= m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){ // vendendo acima da media de trade
){
//precoOrdem = m_ask+m_tick_size; // <TODO>para piorar as condicoes de entrada no teste. Em producao, tem de tirar o +5
precoOrdem = m_bid ;
if( precoOrdem != m_precoUltOrdemInSel ){
m_precoUltOrdemInSel = precoOrdem;
//verificando se tem ordens sell abertas (usando 0 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), m_apmb, m_vol_lote_ini , true, 0 ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG )Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando VENDA a ", precoOrdem, " ", strPosicao() );#endif
#ifndef COMPILE_PRODUCAO if(EA_SLEEP_ATRASO!= 0) Sleep(EA_SLEEP_ATRASO);#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, m_apmb_sel+getStrCommentBook());
//m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
//m_vol_close_position_sel = m_vol_lote_ini;
}
}
}else{
m_trade.cancelarOrdensComentadasDeVenda(m_symb_str,"");
if( (m_desbUp0 >= EA_DESBALAN_UP0 || EA_DESBALAN_UP0 == 0) && // 80% de chance do preco subir
(m_desbUp1 >= EA_DESBALAN_UP1 || EA_DESBALAN_UP1 == 0) && // 70% de chance do preco subir
(m_desbUp2 >= EA_DESBALAN_UP2 || EA_DESBALAN_UP2 == 0) && // 65% de chance do preco subir
(m_desbUp3 >= EA_DESBALAN_UP3 || EA_DESBALAN_UP3 == 0) // 60% de chance do preco subir
//m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO && // volume de compras superior.
//precoOrdem <= m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini // comprando abaixo da media de trade
){
//precoOrdem = m_bid-m_tick_size; // <TODO>para piorar as condicoes de entrada no teste. Em producao, tem de tirar o -5
precoOrdem = m_ask;
if( precoOrdem != m_precoUltOrdemInBuy ){
m_precoUltOrdemInBuy = precoOrdem;
//verificando se tem ordens buy abertas (usando 0 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), m_apmb, m_vol_lote_ini , true, 0 ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG )Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando COMPRA a ", precoOrdem," ", strPosicao());#endif
#ifndef COMPILE_PRODUCAO if(EA_SLEEP_ATRASO!= 0) Sleep(EA_SLEEP_ATRASO);#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, m_apmb_buy+getStrCommentBook());
//m_val_close_position_buy = precoOrdem + (m_tick_size*m_qtd_ticks_4_gain_ini);
//m_vol_close_position_buy = m_vol_lote_ini;
}
}
}else{
m_trade.cancelarOrdensComentadasDeCompra(m_symb_str,"");
}
}
}
void abrirPosicaoHFTDesbalancBookNorteSul(){
double precoOrdem = 0;
bool sincro = false;
precoOrdem = m_ask;
if( m_desbUp0 < EA_DESBALAN_DW0 && m_desbUp0 != 0 && // 80% de chance do o preco cair
m_volTradePorSegDeltaPorc < EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO && // volume de vendas superior...
precoOrdem > m_pmTra + (m_tick_size*m_qtd_ticks_4_gain_ini ) ){ // vendendo acima da media de trade
//verificando se tem ordens sell abertas (usando 0 tick de tolerancia)...
if( !m_trade.tenhoOrdemLimitadaDeVenda( precoOrdem, m_symb.Name(), "OPCL", m_vol_lote_ini , true, 0 ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE=",DoubleToString(m_pmTra,2),". Criando VENDA a ", precoOrdem, " ", strPosicao() );#endif
if( precoOrdem!=0 ){
sincro = m_trade.getAsync();
m_trade.setAsync(true);
if( m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, m_vol_lote_ini, "OPCL") ){
m_val_close_position_sel = precoOrdem - (m_tick_size*m_qtd_ticks_4_gain_ini);
m_vol_close_position_sel = m_vol_lote_ini;
m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, m_val_close_position_sel, m_vol_lote_ini, "OPCL");
}
m_trade.setAsync(sincro);
}
}
}else{
precoOrdem = m_bid;
if( m_desbUp0 > EA_DESBALAN_UP0 && m_desbUp0 != 0 && // 80% de chance do preco subir
m_volTradePorSegDeltaPorc > EA_MIN_DELTA_VOL && m_acelVolTradePorSegDeltaPorc > EA_MIN_DELTA_VOL_ACELERACAO && // volume de compras superior...
precoOrdem < m_pmTra - (m_tick_size*m_qtd_ticks_4_gain_ini ) ){ // comprando abaixo da media de trade
//verificando se tem ordens buy abertas (usando 0 tick de tolerância)...
if( !m_trade.tenhoOrdemLimitadaDeCompra( precoOrdem, m_symb.Name(), "OPCL", m_vol_lote_ini , true, 0 ) ){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print(":-| MEDIA_TRADE ",DoubleToString(m_pmTra,2),". Criando COMPRA a ", precoOrdem," ", strPosicao());#endif
if(precoOrdem!=0) {
sincro = m_trade.getAsync();
m_trade.setAsync(true);
if( m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , precoOrdem, m_vol_lote_ini, "OPCL") ){
m_val_close_position_buy = precoOrdem + (m_tick_size*m_qtd_ticks_4_gain_ini);
m_vol_close_position_buy = m_vol_lote_ini;
m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT , m_val_close_position_buy, m_vol_lote_ini, "OPCL");
}
m_trade.setAsync(sincro);
}
}
// nao cancelar por enquanto. entendo que esta ordem pode ganhar prioridade se o preco voltar
// para o lado contrario do desbalanceamento.
//}else{
// m_trade.cancelarOrdensComentadas(m_apmb);
// m_val_close_position_sel = 0;
// m_vol_close_position_sel = 0;
// m_val_close_position_buy = 0;
// m_vol_close_position_buy = 0;
}
}
}
//
// coloca duas ordens, sendo uma acima da media e outra abaixo da media.
// nao usa rajada.
//
void abrirPosicaoHFTNaMediaTrade(){
double vol = m_vol_lote_ini;
double precoOrdem = 0;
double inclinacaoMin = 0.1;
double shift = 1;
// entrada quando ask estah acima acima da media de trades e bid estah abaixo da media de trade.
if(//m_qtdOrdens==0 &&
( (m_ask >= m_pmTra && m_ask <= m_pmTra+15) || (m_bid <= m_pmTra && m_bid >= m_pmTra-15) ) ){
// processando em paralelo
m_trade.setAsync(true);
if( m_inclTra < 0 ) {
// colocando a venda
precoOrdem = m_ask;
//precoOrdem = m_ask+m_tick_size;
//precoOrdem = m_ask+m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_VENDA_NS=",precoOrdem,". Criando ordem de VENDA.", strPosicao()," ...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_ns );
// colocando a compra
precoOrdem = m_bid;
//precoOrdem = m_bid-m_tick_size;
//precoOrdem = m_bid-m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_COMPRA_NS=",precoOrdem,". Criando ordem de COMPRA.", strPosicao()," ...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, vol, m_apmb_ns );
}else{
// colocando a compra
precoOrdem = m_bid;
//precoOrdem = m_bid-m_tick_size;
//precoOrdem = m_bid-m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_COMPRA_NS=",precoOrdem,". Criando ordem de COMPRA.", strPosicao()," ...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT, precoOrdem, vol, m_apmb_ns );
// colocando a venda
precoOrdem = m_ask;
//precoOrdem = m_ask+m_tick_size;
//precoOrdem = m_ask+m_tick_size*2;
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("HFT_VENDA_NS=",precoOrdem,". Criando ordem de VENDA.", strPosicao()," ...");#endif
if(precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT, precoOrdem, vol, m_apmb_ns );
}
m_trade.setAsync(false);
}
}
bool taxaVolumeEstahL1 (){return EA_VOLSEG_L1 >0 && m_volTradePorSeg <= EA_VOLSEG_L1 ;}
bool taxaVolumeEstahL2 (){return EA_VOLSEG_L2 >0 && m_volTradePorSeg <= EA_VOLSEG_L2 && m_volTradePorSeg > EA_VOLSEG_L1;}
bool taxaVolumeEstahL3 (){return EA_VOLSEG_L3 >0 && m_volTradePorSeg <= EA_VOLSEG_L3 && m_volTradePorSeg > EA_VOLSEG_L2;}
bool taxaVolumeEstahL4 (){return EA_VOLSEG_L4 >0 && m_volTradePorSeg <= EA_VOLSEG_L4 && m_volTradePorSeg > EA_VOLSEG_L3;}
bool taxaVolumeEstahL5 (){return EA_VOLSEG_L5 >0 && m_volTradePorSeg <= EA_VOLSEG_L5 && m_volTradePorSeg > EA_VOLSEG_L4;}
bool taxaVolPermiteAbrirPosicao (){return EA_VOLSEG_MAX_ENTRADA_POSIC==0 || m_volTradePorSeg <= EA_VOLSEG_MAX_ENTRADA_POSIC ;}
bool taxaVolumeEstahAlta (){return EA_VOLSEG_ALTO >0 && m_volTradePorSeg > EA_VOLSEG_ALTO ;}
bool volatilidadeEstahAlta (){return m_volatilidade > EA_VOLAT_ALTA && EA_VOLAT_ALTA != 0;}
bool volatilidade4segEstahAlta(){return m_volatilidade_4_seg > m_volatilidade_4_seg_media*m_volat4s_alta_porc && m_volat4s_alta_porc != 0;}
bool volat4sExigeStop (){return m_volatilidade_4_seg > m_volatilidade_4_seg_media*m_volat4s_stop_porc && m_volat4s_stop_porc != 0;}
//bool volatilidadeEstahAlta (){return volatilidade4segEstahAlta() ;}
//bool volatilidade4segEstahAlta (){return m_volatilidade_4_seg > m_passo_rajada*1 ;}
//bool volatilidadeEstahBaixa (){return m_volatilidade < EA09_VOLAT_BAIXA ;}
//bool volatilidadeEstahMedia (){return m_volatilidade > m_volBaixa && m_volatilidade < m_volBaixa ;}
//bool volat4sExigeStop (){return m_volatilidade_4_seg > EA_VOLAT4S_MAX && EA_VOLAT4S_MAX > 0; }
bool volat4sPermiteAbrirPosicao(){ return m_volatilidade_4_seg <= EA_VOLAT4S_MIN || EA_VOLAT4S_MIN == 0; }
bool spreadMaiorQueMaximoPermitido(){ return m_symb.Spread() > m_spread_maximo_in_points; }
bool m_fastClose = true;
bool m_traillingStop = false;
void setFastClose() { m_fastClose=true ; m_traillingStop=false; m_inclEntrada = m_inclTra;}
void setTraillingStop(){ m_fastClose=false; m_traillingStop=true ;}
bool doTraillingStop(){
double last = m_symb.Last();// m_minion.last(); // preco do ultimo tick;
double bid = m_symb.Bid ();
double ask = m_symb.Ask ();
double lenstop = m_dx1 * EA04_DX_TRAILLING_STOP;
double sl = 0;
//string m_line_tstop = "linha_stoploss";
//int tendencia = getEstrategiaTendencia_02();
//string strTendencia = tendencia == 1?"UP":(tendencia==-1?"DW":"ST");
if( lenstop < 30 ) lenstop = 30;
// calculando o trailling stop...
if( estouComprado() ){
//sl = last - dxsl;
sl = bid - lenstop;
if ( m_tstop < sl || m_tstop == 0 ) {
m_tstop = sl;
#ifndef COMPILE_PRODUCAO
if(EA_DEBUG)Print(m_name,":COMPRADO: [OPEN " ,m_precoPosicao,
"][LENSTOP ",lenstop ,
"][SL " ,sl ,
"][BID " ,bid ,
"][m_tstop ",m_tstop,
"][profit " ,m_posicaoProfit,
"][sldstop ",m_tstop-m_precoPosicao,"]")
;#endif
//if( !HLineMove(0,m_line_tstop,m_tstop) ){ HLineCreate(0,m_line_tstop,0,m_tstop,clrBlack,STYLE_SOLID,1,false,true,false,0);}
//ChartRedraw(0);
}
}else{
if( estouVendido() ){
//sl = last + dxsl;
sl = ask + lenstop;
if ( m_tstop > sl || m_tstop == 0 ) {
m_tstop = sl;
#ifndef COMPILE_PRODUCAO
if(EA_DEBUG)Print(m_name,":VENDIDO: [OPEN ",m_precoPosicao,
"][LENSTOP ",lenstop,
"][SL " ,sl ,
"][ASK " ,ask ,
"][m_tstop ",m_tstop,
"][profit ",m_posicaoProfit,
"][sldstop ",m_precoPosicao-m_tstop,"]");
#endif
//if( !HLineMove(0,m_line_tstop,m_tstop) ){ HLineCreate(0,m_line_tstop,0,m_tstop,clrBlack,STYLE_SOLID,1,false,true,false,0);}
//ChartRedraw(0);
}
}
}
//if(!HlineMove(0,m_line_tstop,m_tstop){ HLineCreate(0,m_line_tstop,0,m_tstop,clrBlack,STYLE_SOLID,1,false,true,false,0);}
//if ( !ObjectMove(0,"linha_stoploss",0,0,m_tstop) ){
// ObjectCreate(0,"linha_stoploss",OBJ_HLINE,0,0,m_tstop);
// ObjectSetInteger(0,"linha_stoploss",OBJPROP_COLOR,clrYellow);
//}
// acionando o trailling stop...
if( ( estouComprado() && m_tstop != 0 ) &&
( ( bid < m_tstop && bid > m_precoPosicao ) )
){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("TSTOP COMPRADO: bid:"+DoubleToString(bid,_Digits)+" m_tstop:"+DoubleToString(m_tstop,_Digits),"[profit ",m_posicaoProfit,"]" );#endif
fecharPosicao("TRLSTP");
//ObjectDelete(0,"linha_stoploss");
//HLineDelete(0,m_line_tstop);
//ChartRedraw(0);
return true;
}
if( ( estouVendido() && m_tstop != 0 ) &&
( ( ask > m_tstop && ask < m_precoPosicao ) )
){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("TSTOP VENDIDO: ask:"+DoubleToString(ask,_Digits)+" m_tstop:"+DoubleToString(m_tstop,_Digits),"[profit ",m_posicaoProfit,"]" );#endif
fecharPosicao("TRLSTP");
//ObjectDelete(0,"linha_stoploss");
//HLineDelete(0,m_line_tstop);
//ChartRedraw(0);
return true;
}
return false;
}
bool doTraillingStop2(){
m_symb.Refresh();
m_ibb.Refresh(-1);
double last = m_symb.Last();// m_minion.last(); // preco do ultimo tick;
double bid = m_symb.Bid ();
double ask = m_symb.Ask ();
double lenstop = m_dx1 * EA04_DX_TRAILLING_STOP;
double sl = 0;
double posicaoProfit = 0;
if( lenstop < 30 ) lenstop = 30;
// calculando o trailling stop...
if( m_trade.estouComprado() ){
sl = bid - lenstop - m_symb.Spread(); // SL eh fixo
//tstop = sl; // tstop varia assim que o lucro passar sl
if ( m_tstop < sl || m_tstop == 0 ) {
m_tstop = sl;
#ifndef COMPILE_PRODUCAO
if(EA_DEBUG)Print(m_name,":COMPRADO2: [OPEN " ,m_precoPosicao,
"][LENSTOP ",lenstop ,
"][SL " ,sl ,
"][BID " ,bid ,
"][m_tstop ",m_tstop,
"][profit " ,m_posicaoProfit,
"][sldstop ",m_tstop-m_precoPosicao,"]");
#endif
}
}else{
if( m_trade.estouVendido() ){
sl = ask + lenstop + m_symb.Spread();
if ( m_tstop > sl || m_tstop == 0 ) {
m_tstop = sl;
#ifndef COMPILE_PRODUCAO
if(EA_DEBUG)Print(m_name,":VENDIDO2: [OPEN ",m_precoPosicao,
"][LENSTOP ",lenstop,
"][SL " ,sl ,
"][ASK " ,ask ,
"][m_tstop ",m_tstop,
"][profit " ,m_posicaoProfit,
"][sldstop ",m_precoPosicao-m_tstop,"]");
#endif
}
}
}
// acionando o trailling stop...
if( ( estouComprado() && m_tstop != 0 ) &&
( ( bid < m_tstop && ask > m_precoPosicao ) )
){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("TSTOP2 COMPRADO2: bid:"+DoubleToString(bid,_Digits)+" m_tstop:"+DoubleToString(m_tstop,_Digits),"[profit ",m_posicaoProfit,"]" );#endif
fecharPosicao("TRLSTP2");
return true;
}
if( ( estouVendido() && m_tstop != 0 ) &&
( ( ask > m_tstop && ask < m_precoPosicao ) )
){
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print("TSTOP2 VENDIDO2: ask:"+DoubleToString(ask,_Digits)+" m_tstop:"+DoubleToString(m_tstop,_Digits),"[profit ",m_posicaoProfit,"]" ); #endif
fecharPosicao("TRLSTP2");
return true;
}
return false;
}
double normalizar(double preco){ return m_symb.NormalizePrice(preco); }
bool precoPosicaoAbaixoDaMedia(){ return m_precoPosicao < m_ibb.Base(0) ;}
bool precoPosicaoAcimaDaMedia (){ return m_precoPosicao > m_ibb.Base(0) ;}
bool precoNaMedia (){ return m_symb.Last() < m_ibb.Base(0) + m_tick_size &&
m_symb.Last() > m_ibb.Base(0) - m_tick_size ;}
bool precoNaBandaInferior (){ return m_symb.Ask() < m_ibb.Lower(0) + m_tick_size &&
m_symb.Ask() > m_ibb.Lower(0) - m_tick_size ;}
bool precoAbaixoBandaInferior (){ return m_symb.Ask() < m_ibb.Lower(0) + m_tick_size;}
bool precoNaBandaSuperior (){ return m_symb.Bid() < m_ibb.Upper(0) + m_tick_size &&
m_symb.Bid() > m_ibb.Upper(0) - m_tick_size ;}
bool precoAcimaBandaSuperior (){ return m_symb.Bid() > m_ibb.Upper(0) - m_tick_size;}
void fecharPosicao (string comentario){ m_trade.fecharQualquerPosicao (comentario); setSemPosicao(); }
void cancelarOrdens(string comentario){ m_trade.cancelarOrdens(comentario); setSemPosicao(); }
void setCompradoSoft(){ m_comprado = true ; m_vendido = false; }
void setVendidoSoft() { m_comprado = false; m_vendido = true ; }
void setComprado() { m_comprado = true ; m_vendido = false; m_tstop = 0;}
void setVendido() { m_comprado = false; m_vendido = true ; m_tstop = 0;}
void setSemPosicao() { m_comprado = false; m_vendido = false; m_tstop = 0;}
bool estouComprado(){ return m_comprado; }
bool estouVendido (){ return m_vendido ; }
string status(){
string obs =
//" preco=" + m_tick.ask +
//" bid=" + m_tick.bid +
//" spread=" + (m_tick.ask-m_tick.bid) +
" last=" + DoubleToString( m_symb.Last() )
//" time=" + m_tick.time
;
return obs;
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
Print(m_name,":-| Expert ", m_name, " Iniciando metodo OnDeinit..." );
delLineMinPreco(); Print(m_name,":-| Expert ", m_name, " Linha de preco minimo elimnada." );
delLineMaxPreco(); Print(m_name,":-| Expert ", m_name, " Linha de preco maximo elimnada." );
delLineTimeDesdeEntrelaca(); Print(m_name,":-| Expert ", m_name, " Linha horizontal entrelacamento eliminada." );
delLineMaiorPrecoCompra(); Print(m_name,":-| Expert ", m_name, " Linha horizontal regiao de compra." );
delLineMenorPrecoVenda(); Print(m_name,":-| Expert ", m_name, " Linha horizontal regiao de venda." );
EventKillTimer(); Print(m_name,":-| Expert ", m_name, " Timer destruido." );
//m_feira.DeleteFromChart(0,0); Print(m_name,":-| Expert ", m_name, " Indicador feira retirado do grafico." );
//IndicatorRelease( m_feira.Handle() ); Print(m_name,":-| Expert ", m_name, " Manipulador do indicador feira liberado." );
MarketBookRelease(m_symb_str); Print(m_name,":-| Expert ", m_name, " Manipulador do Book liberado." );
//IndicatorRelease( m_icci.Handle() ); Print(m_name,":-| Expert ", m_name, " Manipulador do indicador cci liberado." );
//IndicatorRelease( m_ibb.Handle() );
Print(m_name,":-) Expert ", m_name, " OnDeinit finalizado!" );
Comment("");
return;
}
double OnTester(){ m_trade_estatistica.print_posicoes(0, m_time_in_seconds_atu); return 0; }
void escreverLogAfterNewBar(string msg){
MqlDateTime mdt;
TimeToStruct(TimeCurrent(),mdt);
//if(estah_no_intervalo_de_negociacao()) { m_minion.logWriteAfterNewBar(msg); }
}
void escreverLog(string msg){
MqlDateTime mdt;
TimeToStruct(TimeCurrent(),mdt);
//if(estah_no_intervalo_de_negociacao()) { m_minion.logWrite(msg); }
}
//+-----------------------------------------------------------+
//| |
//+-----------------------------------------------------------+
void OnTradex(){
if( m_fechando_posicao && m_ordem_fechamento_posicao > 0 ){
if( HistoryOrderSelect(m_ordem_fechamento_posicao) ){
ENUM_ORDER_STATE order_state = (ENUM_ORDER_STATE)OrderGetInteger(ORDER_STATE);
if( order_state == ORDER_STATE_FILLED || //Ordem executada completamente
order_state == ORDER_STATE_REJECTED || //Ordem rejeitada
order_state == ORDER_STATE_EXPIRED || //Ordem expirada
order_state == ORDER_STATE_CANCELED ){ //Ordem cancelada pelo cliente
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print( ":-| Ordem de fechamento de posicao CONCLUIDA! ticket=", m_ordem_fechamento_posicao, " status=", EnumToString(order_state), strPosicao() );#endif
m_fechando_posicao = false;
m_ordem_fechamento_posicao = 0;
}else{
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print( ":-| Ordem de fechamento de posicao PENDENTE! ticket=", m_ordem_fechamento_posicao, " status=", EnumToString(order_state), strPosicao() );#endif
}
}else{
#ifndef COMPILE_PRODUCAO if(EA_DEBUG)Print( ":-| Ordem de fechamento de posicao NAO ENCONTRADA! ticket=", m_ordem_fechamento_posicao, strPosicao() );#endif
m_fechando_posicao = false;
m_ordem_fechamento_posicao = 0;
}
}
}
string strFuncNormal(string str){ return ":-| " + str + " "; }
void printHeartBit(){ if(m_date_ant.min != m_date_atu.min) Print(":-| HeartBit!"); }
//----------------------------------------------------------------------------------------------------
//
// 1. Atualizando as variaveis de tempo atual m_time_in_seconds e m_date.
// 2. Executa funcoes que dependem das variaveis m_time_in_seconds ou m_date atualizadas e
// suas respectivas anteriores atualizas.
// 3. Atualizando variaveis de comparacao de data anterior e atual m_time_in_seconds_ant e m_date_ant.
//
//----------------------------------------------------------------------------------------------------
bool m_estah_no_intervalo_de_negociacao = false;
datetime m_time_in_seconds_atu = TimeCurrent();
datetime m_time_in_seconds_ant = m_time_in_seconds_atu;
MqlDateTime m_date_atu;
MqlDateTime m_date_ant;
//----------------------------------------------------------------------------------------------------
void OnTimer(){
// 1. Atualizando as variaveis de tempo atual m_time_in_seconds e m_date...
m_time_in_seconds_atu = TimeCurrent();
TimeToStruct(m_time_in_seconds_atu,m_date_atu);
//Print("Apos passo 1:",
// " m_time_in_seconds_ant:",TimeToString(m_time_in_seconds_ant,TIME_DATE|TIME_MINUTES|TIME_SECONDS),
// " m_date_ant.sec:" ,m_date_ant.sec );
//Print("Apos passo 1:",
// " m_time_in_seconds_atu:",TimeToString(m_time_in_seconds_atu,TIME_DATE|TIME_MINUTES|TIME_SECONDS),
// " m_date_atu.sec:" ,m_date_atu.sec );
// 2. executando funcoes que dependem das valiaveis m_time_in_seconds ou m_date atualizadas...
m_estah_no_intervalo_de_negociacao = estah_no_intervalo_de_negociacao(); // verificando intervalo de negociacao...
calcularAceleracaoVelTradeDeltaPorc(); // calculando aceleracao da %Delta da velocidade do volume de trade...
//calcRun(EA_MINUTOS_RUN,m_passo_rajada); // calculando o indice de runs baseado no passo atual
//calcRun(m_passo_rajada); // calculando o indice de runs baseado no passo atual
controlarTimerParaAbrirPosicao();
//calcCoefEntrelacamentoMedio(); // calculando o coeficiente de entrelacamento;
printHeartBit();
// 3. atualizando variaveis de comparacao de data anterior e atual m_time_in_seconds_ant e m_date_ant.
// a partir deste ponto, as atuais e anteriores ficam iguais.
m_time_in_seconds_ant = m_time_in_seconds_atu;
m_date_ant = m_date_atu;
//Print("Apos passo 3:",
// " m_time_in_seconds_ant:",TimeToString(m_time_in_seconds_ant,TIME_DATE|TIME_MINUTES|TIME_SECONDS),
// " m_date_ant.sec:" ,m_date_ant.sec );
//Print("Apos passo 3:",
// " m_time_in_seconds_atu:",TimeToString(m_time_in_seconds_atu,TIME_DATE|TIME_MINUTES|TIME_SECONDS),
// " m_date_atu.sec:" ,m_date_atu.sec );
//if (EA_SHOW_TELA) m_trade_estatistica.calcRelacaoVolumeProfit(m_time_in_seconds_ini_day, m_time_in_seconds_atu);
m_trade_estatistica.refresh(m_time_in_seconds_ini_day, m_time_in_seconds_atu);
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
// 1. Faz o shift das velocidades de volume registradas e despreza a mais antiga
// 2. Substitui a ultima velocidade pela mais atual
// 3. Recalcula a aceleracao da velocidade do volume
//----------------------------------------------------------------------------------------------------
int m_vet_vel_volume_len = 60;
double m_vet_vel_volume[60];
int m_acelVolTradePorSegDeltaPorc = 0;
//----------------------------------------------------------------------------------------------------
void calcularAceleracaoVelTradeDeltaPorc(){
//if( m_time_in_seconds_atu != m_time_in_seconds_ant ){
// fazendo shift para tras e desprezando a posicao mais antiga(indice zero)...
for(int i=0; i<m_vet_vel_volume_len-1; i++){
m_vet_vel_volume[i] = m_vet_vel_volume[i+1];
}
// atualizando a ultima posicao do vetor com a velocidade atual...
m_vet_vel_volume[m_vet_vel_volume_len-1] = m_volTradePorSegDeltaPorc;
// recalculando a aceleracao do volume... deltaVelocidade/deltaTempo (usando a formula da fisica)...
m_acelVolTradePorSegDeltaPorc = ( (m_volTradePorSegDeltaPorc - m_vet_vel_volume[0])/m_vet_vel_volume_len )*10;
//}
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
bool estah_no_intervalo_de_negociacao(){
//if( m_date_atu.hour == 16 && m_date_atu.min == 1){
// Print("Break Point!!!!");
//}
// informando a mudanca do dia (usada no controle do rebaixamento de saldo maximo da sessao).
if( m_date_ant.day != m_date_atu.day ){ m_mudou_dia = true; m_time_in_seconds_ini_day = StringToTime( TimeToString( TimeCurrent(), TIME_DATE )); }
// restricao para nao operar no inicio nem no final do dia...
if(m_date_atu.hour < HR_INI_OPERACAO ) { return false; } // operacao antes de 9:00 distorce os testes.
if(m_date_atu.hour >= HR_FIM_OPERACAO + 1 ) { return false; } // operacao apos 18:00 distorce os testes.
if(m_date_atu.hour == HR_INI_OPERACAO && m_date_atu.min < MI_INI_OPERACAO ) { return false; } // operacao antes de 9:10 distorce os testes.
if(m_date_atu.hour == HR_FIM_OPERACAO && m_date_atu.min > MI_FIM_OPERACAO ) { return false; } // operacao apos 17:50 distorce os testes.
//if( m_date_atu.year==2020 &&
// m_date_atu.mon ==2 &&
// m_date_atu.day ==26 &&
// m_date_atu.hour==13 &&
// m_date_atu.min < 30 ) { return false; } // para permitir teste na quarta-feira de cinzas.
return true;
}
//----------------------------------------------------------------------------------------------------
// controle da permissao para abrir posicoes em funcao de um tempo de penalidade.
// novas posicoes soh podem ser abertas se a penalidade(m_aguardar_para_abrir_posicao) estiver zerada.
void controlarTimerParaAbrirPosicao(){
if( m_aguardar_para_abrir_posicao > 0 ){
m_aguardar_para_abrir_posicao -= EA_QTD_SEG_TIMER;
}
if( m_aguardar_para_abrir_posicao < 0 ) m_aguardar_para_abrir_posicao = 0;
}
string m_strRun = "";
void OnChartEvent(const int id ,
const long &lparam,
const double &dparam,
const string &sparam){
if(id==SVC_RUN+CHARTEVENT_CUSTOM ){
m_strRun = "\n\n" + sparam;
}
}
double m_indRunMais1Ant = 0;
double m_indRunMenos1Ant = 0;
double m_indRunAnt = 0;
double m_indRunMais1 = 0;
double m_indRunMenos1 = 0;
double m_indRun = 0;
double m_indVarRunMais1 = 0;
double m_indVarRunMenos1 = 0;
double m_indVarRun = 0;
int m_qtd_periodos_run = 0;
//void calcRun(int pQtdMinutos, int pLenChunk){
void calcRun(int pLenChunk){
OscRun cRun;
//MqlTick ticks[]; //vetor de ticks que serao processados;
double price[]; //vetor de precos (obtidos do historico de ticks);
int run1 []; //vetor de runs positivas;
int run2 []; //vetor de runs negativas;
//Print("Buscando ticks para calculo do indice run...");
//int qtdTicks = CopyTicksRange(m_symb_str,ticks,COPY_TICKS_INFO,TimeCurrent()*1000 - (60000*pQtdMinutos), TimeCurrent()*1000 );
int qtdTicks = m_est.copyPriceTo(price);
cRun.calcRuns(price,qtdTicks,pLenChunk,m_tick_size,run1,run2);
m_indRun = cRun.calcIndice(run1,run2);
cRun.calcRuns(price,qtdTicks,pLenChunk-1,m_tick_size,run1,run2);
m_indRunMenos1 = cRun.calcIndice(run1,run2);
cRun.calcRuns(price,qtdTicks,pLenChunk+1,m_tick_size,run1,run2);
m_indRunMais1 = cRun.calcIndice(run1,run2);
m_indVarRun = m_indRunAnt -m_indRun ;
m_indVarRunMenos1 = m_indRunMenos1Ant-m_indRunMenos1;
m_indVarRunMais1 = m_indRunMais1Ant -m_indRunMais1 ;
m_indRunAnt = m_indRun ;
m_indRunMenos1Ant = m_indRunMenos1;
m_indRunMais1Ant = m_indRunMais1 ;
// Printando as runs a cada 5 execucoes do OnTimer...
if( m_qtd_periodos_run++ < 50 ){ return; }
m_qtd_periodos_run = 0;
Print("Informados ",qtdTicks, ". Copiados ", ArraySize(price) );
}
string m_str_line_max_price = "line_max_price";
string m_str_line_min_price = "line_min_price";
string m_str_line_maior_preco_compra = "str_line_maior_preco_compra";
string m_str_line_menor_preco_venda = "str_line_menor_preco_venda";
string m_str_line_time_desde_entrelaca = "line_time_desde_entrelaca";
bool m_line_min_preco_criada = false;
bool m_line_max_preco_criada = false;
bool m_line_maior_preco_compra_criada = false;
bool m_line_menor_preco_venda_criada = false;
bool m_line_time_desde_entrelaca_criada = false;
void drawLineMaxPreco(){
if( EA_SHOW_TELA ){
if( m_line_max_preco_criada ){
HLineMove(0,m_str_line_max_price,m_maxPrecoEntre);
}else{
HLineCreate(0,m_str_line_max_price,0,m_maxPrecoEntre,clrMediumBlue,STYLE_SOLID,1,false,true,false,0);
m_line_max_preco_criada = true;
}
ChartRedraw(0);
}
}
void drawLineMaiorPrecoCompra(){
if( EA_SHOW_TELA ){
if( m_line_maior_preco_compra_criada ){
HLineMove(0,m_str_line_maior_preco_compra,m_maiorPrecoDeCompra);
}else{
HLineCreate(0,m_str_line_maior_preco_compra,0,m_maiorPrecoDeCompra,clrDarkGray,STYLE_DOT,1,false,true,false,0);
m_line_maior_preco_compra_criada = true;
}
ChartRedraw(0);
}
}
void drawLineMenorPrecoVenda(){
if( EA_SHOW_TELA ){
if( m_line_menor_preco_venda_criada ){
HLineMove(0,m_str_line_menor_preco_venda,m_menorPrecoDeVenda);
}else{
HLineCreate(0,m_str_line_menor_preco_venda,0,m_menorPrecoDeVenda,clrDarkGray,STYLE_DOT,1,false,true,false,0);
m_line_menor_preco_venda_criada = true;
}
ChartRedraw(0);
}
}
void drawLineMinPreco(){
if( EA_SHOW_TELA ){
if( m_line_min_preco_criada ){
HLineMove(0,m_str_line_min_price,m_minPrecoEntre);
}else{
HLineCreate(0,m_str_line_min_price,0,m_minPrecoEntre,clrRed,STYLE_SOLID,1,false,true,false,0);
m_line_min_preco_criada = true;
}
ChartRedraw(0);
}
}
void drawLineTimeDesdeEntrelaca(){
if( EA_SHOW_TELA ){
if( m_line_time_desde_entrelaca_criada ){
VLineMove(0,m_str_line_time_desde_entrelaca,m_time_desde_entrelaca);
}else{
VLineCreate(0,m_str_line_time_desde_entrelaca,0,m_time_desde_entrelaca,clrSteelBlue,STYLE_SOLID,1,false,true,false,0);
m_line_time_desde_entrelaca_criada = true;
}
ChartRedraw(0);
}
}
void delLineMinPreco (){HLineDelete(0,m_str_line_min_price ); m_line_min_preco_criada = false;}
void delLineMaxPreco (){HLineDelete(0,m_str_line_max_price ); m_line_max_preco_criada = false;}
void delLineTimeDesdeEntrelaca(){VLineDelete(0,m_str_line_time_desde_entrelaca); m_line_time_desde_entrelaca_criada = false;}
void delLineMaiorPrecoCompra (){HLineDelete(0,m_str_line_maior_preco_compra ); m_line_maior_preco_compra_criada = false;}
void delLineMenorPrecoVenda (){HLineDelete(0,m_str_line_menor_preco_venda ); m_line_menor_preco_venda_criada = false;}
double m_dxPrecoMaxEmTicks = 0; // distancia, em ticks, entre o preco maximo usado no calculo do entrelacamento e o preco atual;
double m_dxPrecoMinEmTicks = 0; // distancia, em ticks, entre o preco minimo usado no calculo do entrelacamento e o preco atual;
double m_regiaoPrecoCompra = 0;
double m_regiaoPrecoVenda = 0;
double m_porcRegiaoOperacaoEntrelaca = 0; //0.20;
double m_maxDistanciaEntrelacaParaOperar = 0; //1000;
double m_stpDistanciaEntrelacamento = 0;
double m_maiorPrecoDeCompra = 0;
double m_menorPrecoDeVenda = 0;
void calcDistPrecoMaxMin(){
m_dxPrecoMaxEmTicks = (m_maxPrecoEntre - m_bid )/m_tick_size;
m_dxPrecoMinEmTicks = (m_bid - m_minPrecoEntre)/m_tick_size;
if( m_len_canal_entrelacamento != 0 ){
m_regiaoPrecoCompra = (m_dxPrecoMinEmTicks / m_len_canal_entrelacamento);
m_regiaoPrecoVenda = 1-m_regiaoPrecoCompra ; //(m_dxPrecoMaxEmTicks / m_len_canal_entrelacamento);
}
}
void calcMaiorPrecoDeCompraVenda(){
m_maiorPrecoDeCompra = m_minPrecoEntre + (m_len_canal_entrelacamento*m_porcRegiaoOperacaoEntrelaca*m_tick_size);
m_menorPrecoDeVenda = m_maxPrecoEntre - (m_len_canal_entrelacamento*m_porcRegiaoOperacaoEntrelaca*m_tick_size);
drawLineMaiorPrecoCompra();
drawLineMenorPrecoVenda ();
}
bool regiaoPrecoPermiteCompra (){ return m_regiaoPrecoCompra <= m_porcRegiaoOperacaoEntrelaca || m_porcRegiaoOperacaoEntrelaca ==0; }
bool regiaoPrecoPermiteVenda (){ return m_regiaoPrecoVenda <= m_porcRegiaoOperacaoEntrelaca || m_porcRegiaoOperacaoEntrelaca ==0; }
bool distaciaEntrelacamentoPermiteOperar(){ return m_len_canal_entrelacamento <= m_maxDistanciaEntrelacaParaOperar || m_maxDistanciaEntrelacaParaOperar==0; }
bool distaciaEntrelacamentoDeveStopar (){ return m_len_canal_entrelacamento > m_stpDistanciaEntrelacamento && m_stpDistanciaEntrelacamento !=0; }
bool entrelacamentoDeBaixa (){ return m_direcao_entre < 0; }
bool entrelacamentoDeAlta (){ return m_direcao_entre > 0; }
//|-------------------------------------------------------------------------------------
//| O coeficiente de entrelacamento eh a porcentagem de intersecao do preco da barra
//| atual em relacao a barra anterior.
//|
//| Esta funcao retorna o coeficiente de entrelacacamento medio dos ultimos x periodos
//|-------------------------------------------------------------------------------------
double m_coefEntrelaca = 0;
double m_coefEntrelacaInv = 0;
int m_qtdPeriodoCoefEntrelaca = 0;
MqlRates m_ratesEntrelaca[] ;
double m_maxPrecoEntre = 0;
double m_minPrecoEntre = 0;
double m_len_canal_entrelacamento= 0;
datetime m_time_desde_entrelaca = 0;
double m_direcao_entre = 0; // indica se a barra total do entrelacamento eh de alta ou baixa...
void calcCoefEntrelacamentoMedio(){
// calculando a cada segundo impar...
//if( m_date_ant.sec == m_date_atu.sec || // espera mudar o segundo para calcular
// m_date_atu.sec%2 == 0 ){ // calcula sempre no segundo impar
// return;
//}
double totCoef = 0;
int peso = m_qtdPeriodoCoefEntrelaca;
int totPeso = 0;
// obtendo as ultimas barras de preco
CopyRates(m_symb_str,_Period,0,m_qtdPeriodoCoefEntrelaca,m_ratesEntrelaca);
ArraySetAsSeries(m_ratesEntrelaca,true);
double maxPreco = m_ratesEntrelaca[0].high;
double minPreco = m_ratesEntrelaca[0].low ;
datetime time_desde_entrelaca = m_ratesEntrelaca[m_qtdPeriodoCoefEntrelaca-1].time;
// calculando direcao nas barras de entrelacamento. resultado positivo eh alta, negativo eh baixa.
m_direcao_entre = m_ratesEntrelaca[0].close - m_ratesEntrelaca[m_qtdPeriodoCoefEntrelaca-1].open;
for( int i=0; i<m_qtdPeriodoCoefEntrelaca-1; i++){
totCoef += calcCoefEntrelacamento( m_ratesEntrelaca[i+1].low, m_ratesEntrelaca[i+1].high,
m_ratesEntrelaca[i] .low, m_ratesEntrelaca[i] .high )*peso;
totPeso += peso;
peso--;
if( m_ratesEntrelaca[i+1].high > maxPreco){ maxPreco = m_ratesEntrelaca[i+1].high; }
if( m_ratesEntrelaca[i+1].low < minPreco){ minPreco = m_ratesEntrelaca[i+1].low ; }
}
m_coefEntrelaca = totCoef/totPeso;
// atualizando a distancia usada no calculo do entrelacamento...
if( maxPreco != m_maxPrecoEntre || minPreco != m_minPrecoEntre ) m_len_canal_entrelacamento = (maxPreco-minPreco)/m_tick_size;
if( maxPreco != m_maxPrecoEntre ){ m_maxPrecoEntre = maxPreco; drawLineMaxPreco(); calcMaiorPrecoDeCompraVenda(); }
if( minPreco != m_minPrecoEntre ){ m_minPrecoEntre = minPreco; drawLineMinPreco(); calcMaiorPrecoDeCompraVenda(); }
if( m_time_desde_entrelaca != time_desde_entrelaca ){ m_time_desde_entrelaca = time_desde_entrelaca; drawLineTimeDesdeEntrelaca(); }
}
double m_entrelacaMinParaOperar = 0; // parametro inicial em 0.45
bool entrelacamentoPermiteAbrirPosicao(){ return m_coefEntrelaca >= m_entrelacaMinParaOperar || m_entrelacaMinParaOperar == 0; }
//|--------------------------------------------------------------------------------
//| O coeficiente de entrelacamento eh a porcentagem de intersecao do preco da barra
//| atual em relacao a barra anterior.
//|
//| Ant ----------
//| Atu -------
//| Int xxxxx
//|
//| Ant ----------
//| Atu -------
//| Int xxxxx
//|
//| Ant ----------
//| Atu -------
//| Int xxxxxxx
//|
//| Ant ----------
//| Atu -------
//| Int
//|
//| Ant ----------
//| Atu ---
//| Int
//|
//|--------------------------------------------------------------------------------
double calcCoefEntrelacamento(double minAnt, double maxAnt, double minAtu, double maxAtu){
double pontosEntre = 0;
// minimo da barra atual estah na barra anterior...
if( minAtu >= minAnt && minAtu <= maxAnt ){
if( maxAtu > maxAnt ){
// ---------|
// ---------|
// xxxxx
pontosEntre = maxAnt - minAtu;
}else{
// ---------
// -----
// xxxxx
pontosEntre = maxAtu - minAtu;
}
}else{
// maximo da barra atual estah na barra anterior...
if( maxAtu >= minAnt && maxAtu <= maxAnt ){
if( minAtu < minAnt ){
// ---------
// ---------
// xxxxx
pontosEntre = maxAtu - minAnt;
}else{
// ---------
// -----
// xxxxx
pontosEntre = maxAtu - minAtu;
}
}
}
// encontrando os maiores maximos e minimos
double max = (maxAnt>maxAtu)?maxAnt:maxAtu;
double min = (minAnt<minAtu)?minAnt:minAtu;
//if(maxAtu-minAtu == 0) return 0;
if(max-min == 0) return 0;
//return pontosEntre/(maxAtu-minAtu);
return pontosEntre/(max-min);
}
Reference in a new issue View git blame Copy permalink