marcoc/oslib
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
oslib/ose/ose-p7-004-001-formador-de-mercado.mq5
super.admin 07f69c4478 convert
2025-05-30 16:15:18 +02:00

2941 lines
321 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| ose-p7-004-000-transacao-por-evento.mq5 |
//| Copyright 2019, OS Corp |
//| http://www.os.org |
//| |
//| Versao p7-004-000 |
//| 1. Superficie de operacao usando OntradeTransaction para |
//| a abertura ou inclusao de ordens em uma posicao e disparar |
//| as ordens de fechamento. Reflete diretamente no closerajada, |
//| que eh mais lento devido a pesquisa das ordens de uma posicao |
//| no historico de ordens. |
//| |
//| Fechamento de posicoes por stop passa a ser pelo valor de |
//| m_precoSaidaPosicao, visando sua simplificacao. |
//| |
//| 2. Portifolio de Estrategias |
//| |
//| 2.1 HFT_OPERAR_VOLUME_CANAL |
//| Abre posicao em funcao de: |
//| - posicao no canal operacional |
//| - velocidade dos volumes de compra e venda |
//| - aceleracao da velocidade dos volumes de compra e venda |
//| - velocidade de mudanca de precos |
//| |
//| 2.2 HFT_FORMADOR_DE_MERCADO |
//| Mantem ordens de abertura de posicao a pelo menos XX ticks|
//| de distancia do nivel zero do book, visando ter prioridade|
//| de execucao quando o preco chegar ao nivel zero. |
//| |
//| // 2.3 HFT_ARBITRAGEM_PAR |
//| // Monitora desvios na correlacao de pares de ativos visando |
//| // abertura de posicoes quando os desvios forem maiores que |
//| // xx desvios padroes e fechamento quando os desvios forem |
//| // menoes que xx desvios padroes. |
//| |
//+------------------------------------------------------------------+
#define COMPILE_PRODUCAO
#property copyright "Copyright 2018, OS Corp."
#property link "http://www.os.org"
#property version "1.2"
//#include <Generic\Queue.mqh>
//#include <Generic\HashMap.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//#include <Indicators\Trend.mqh>
//#include <oslib\os-lib.mq5>
#include <oslib\osc\est\osc-estatistic3.mqh>
#include <oslib\osc\est\C0002ArbitragemPar.mqh>
#include <oslib\osc\osc-minion-trade-03.mqh>
#include <oslib\osc\osc-minion-trade-estatistica.mqh>
#include <oslib\osc\osc-media.mqh>
#include <oslib\osc\trade\osc_position.mqh>
//#include <oslib\svc\osc-svc.mqh>
//#include <oslib\svc\run\cls-run.mqh>
#include <oslib\osc\cp\osc-pc-p7-002-004-vel-vol.mqh> //painel de controle
#include <oslib\osc\osc-canal.mqh> //canais
//#include <oslib\osc\est\C0001FuzzyModel.mqh> // modelo para medir risco de entrar em uma operar
#include <oslib\osc\data\osc-cusum.mqh> // implemantacao do algoritmo cumulative sum.
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.
HFT_OPERAR_VOLUME_CANAL , //HFT_OPERAR_VOLUME_CANAL
HFT_FORMADOR_DE_MERCADO //HFT_FORMADOR_DE_MERCADO
// HFT_ARBITRAGEM_PAR //HFT_ARBITRAGEM_PAR
};
//---------------------------------------------------------------------------------------------
input group "Gerais"
input ENUM_TIPO_OPERACAO EA_ACAO_POSICAO = FECHAR_POSICAO ; //EA_ACAO_POSICAO:Forma de operacao do EA.
input ENUM_TIPO_ENTRADA_PERMITDA EA_TIPO_ENTRADA_PERMITIDA = ENTRADA_TODAS;//TIPO_ENTRADA_PERMITIDA Tipos de entrada permitidas (sel,buy,ambas e nenhuma)
input double EA_SPREAD_MAXIMO_EM_TICKS = 5 ; //EA_SPREAD_MAXIMO_EM_TICKS. Se for maior que o maximo, nao abre novas posicoes.
//
//input group "Volume por Segundo"
//input int EA_VOLSEG_MAX_ENTRADA_POSIC = 150;//VOLSEG_MAX_ENTRADA_POSIC: vol/seg maximo para entrar na posicao.
//
//input group "arbitragem par"
//input string EA_TICKER_REF = "BOVA11";//TICKER_REF
//input int EA_QTD_SEG_MEDIA_PRECO = 5 ;//QTD_SEG_MEDIA_PRECO
//input int EA_QTD_SEG_MEDIA_RATIO = 60*21 ;//QTD_SEG_MEDIA_RATIO
//input double EA_QTD_DP_FIRE_ORDEM = 1.0 ;//QTD_DP_FIRE_ORDEM
//input double EA_QTD_DP_CLOSE_ORDEM = 0.5 ;//QTD_DP_CLOSE_ORDEM
input group "velocidade do volume"
input int EA_EST_QTD_SEGUNDOS = 5; //EST_QTD_SEGUNDOS qtd seg para calc velocidade do volume
input group "canal operacional"
input bool EA_CANAL_DIARIO = true; //CANAL_DIARIO operacional
input int EA_TAMANHO_CANAL = 15 ; //TAMANHO_CANAL operacional
input double EA_PORC_REGIAO_OPERACIONAL_CANAL = 0.5 ; //PORC_REGIAO_OPERACIONAL_CANAL regiao de operacao
input group "formador de mercado"
input int EA_DIST_MIN_IN_BOOK_IN_POS = 6 ; //DIST_MIN_IN_BOOK_IN_POS abrindo posicao
input int EA_DIST_MIN_IN_BOOK_IN_POS_OBRIG = 6 ; //DIST_MIN_IN_BOOK_IN_POS_OBRIG
input int EA_DIST_MIN_IN_BOOK_OUT_POS = 6 ; //DIST_MIN_IN_BOOK_OUT_POS fechando posicao
input int EA_LAG_RAJADA = 6 ; //LAG_RAJADA
input int EA_STOP_PARCIAL_A_PARTIR_DE_X_LOTES = 20 ; //STOP_PARCIAL_A_PARTIR_DE_X_LOTES
input int EA_STOP_PARCIAL_A_PARTIR_DE_X_GANHO = 1000; //STOP_PARCIAL_A_PARTIR_DE_X_GANHO
input bool EA_DECISAO_ENTRADA_COMPRA_VENDA_AUTOMATICA = false;//DECISAO_ENTRADA_COMPRA_VENDA_AUTOMATICA
input bool EA_FECHA_POSICAO_NO_BREAK_EVEN = false;//FECHA_POSICAO_NO_BREAK_EVEN
input double EA_AUMENTO_LAG_POR_LOTE_PENDENTE = 0.25 ;//AUMENTO_LAG_POR_LOTE_PENDENTE
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 double EA_VOL_LOTE_INI = 1 ; //VOL_LOTE_INI:Vol do lote na abertura de posicao qd vol/seg eh L1.
input double EA_QTD_TICKS_4_GAIN_INI = 5 ; //TICKS_4_GAIN_INI Qtd ticks para o gain qd vol/seg eh level 1;
input double EA_QTD_TICKS_4_GAIN_DECR = 0 ; //TICKS_4_GAIN_DECR Qtd ticks a ser decrementado em tfg a cada aumento de volume de posicao;
input double EA_QTD_TICKS_4_GAIN_MIN = 5 ; //QTD_TICKS_4_GAIN_MIN menor alvo inicial possivel;
//input int EA_PERIODO_CALC_TENDENCIA = 3 ; //PERIODO_CALC_TENDENCIA para o calculo da tendencia
input bool EA_ALVO_DINAMICO = false;//ALVO_DINAMICO alvo igual dp/TAMANHO_RAJADA
//input ENUM_TIMEFRAMES EA_BB_PERIODO = PERIOD_CURRENT; // BB_PERIODO
//input int EA_BB_QTD_PERIODOS = 10 ; // BB_QTD_PERIODOS
//input double EA_BB_DESVIO_PADRAO = 1.5 ; // BB_DESVIO_PADRAO
//input ENUM_APPLIED_PRICE EA_BB_APPLIED = PRICE_WEIGHTED; // BB_APPLIED
input group "Rajada"
input bool EA_RAJADA_UNICA = true ; //RAJADA_UNICA se verdadeiro, cria uma raja unica na abertura da posicao.
input int EA_TAMANHO_RAJADA = 1 ; //TAMANHO_RAJADA;
input double EA_VOL_PRIM_ORDEM_RAJ = 1 ; //VOL_PRIM_ORDEM_RAJ:Vol da primeira ordem da rajada.
input double EA_INCREM_VOL_RAJ = 1 ; //INCREM_VOL_RAJ aumento(x) de volume a cada ordem da rajada;
input double EA_DISTAN_PRIM_ORDEM_RAJ = 1 ; //DISTAN_PRIM_ORDEM_RAJ Distancia em ticks desde abertura da posicao ateh prim ordem rajada;
input double EA_DISTAN_DEMAIS_ORDENS_RAJ = 1 ; //DISTAN_DEMAIS_ORDENS_RAJ Distancia entre as demais ordens da rajada;
input double EA_INCREM_DISTAN_DEMAIS_ORDENS_RAJ = 1 ; //INCREM_DISTAN_DEMAIS_ORDENS_RAJ aumento (x) distancia ordens rajada;
input bool EA_STOP_NA_RAJADA = false; //STOP_NA_RAJADA
input double EA_PORC_STOP_NA_RAJADA = 0 ; //PORC_STOP_NA_RAJADA
input bool EA_FECHA_POSICAO_POR_EVENTO = true ; //FECHA_POSICAO_POR_EVENTO
input bool EA_LOGAR_TRADETRANSACTION = false; //LOGAR_TRADETRANSACTION
input group "Entrada CUSUM"
input double EA_KK = 3 ; //K passo do preco para uma acumulacao direcional;
input double EA_HH = true ; //H soma de acumulacoes (K) na mesma direcao para caracterizar a tendencia.
//
//-------------------------------------------------------------------------------------------
//input group "Run"
//input int EA_MINUTOS_RUN = 300 ; //MINUTOS_RUN:minutos usados no calcula do indice das runs.
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
//input group "Passo dinamico"
#define EA_PASSO_DINAMICO false //PASSO_DINAMICO:tamanho do passo muda em funcao da volatilidade
#define EA_PASSO_DINAMICO_PORC_T4G 1 //PASSO_DINAMICO_PORC_TFG: % do TFG para definir o passo.
#define EA_PASSO_DINAMICO_MIN 1 //PASSO_DINAMICO_MIN:menor passo possivel.
#define EA_PASSO_DINAMICO_MAX 15 //PASSO_DINAMICO_MAX:maior passo possivel.
#define EA_PASSO_DINAMICO_PORC_CANAL_ENTRELACA 0.02 //PASSO_DINAMICO_PORC_CANAL_ENTRELACA
#define 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.
#define EA_PASSO_DINAMICO_STOP_CHUNK 2 //PASSO_DINAMICO_STOP_CHUNK:tamanho do chunk.
#define EA_PASSO_DINAMICO_STOP_PORC_CANAL 1 //PASSO_DINAMICO_STOP_PORC_CANAL:porcentagem do canal, usada para calcular o stop_loss dinamico.
#define 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_STOP_TIPO_CONTROLE_RISCO = 1 ; //STOP_TIPO_CONTROLE_RISCO, se 1, controle normal. Se 2, controle por proximidade do breakeven.
input int EA_STOP_TICKS_STOP_LOSS = 0 ; //STOP_TICKS_STOP_LOSS:Quantidade de ticks usados no stop loss;
input int EA_STOP_TICKS_TKPROF = 0 ; //STOP_TICKS_TKPROF:Quantidade de ticks usados no take profit;
input double EA_STOP_REBAIXAMENTO_MAX = 0 ; //STOP_REBAIXAMENTO_MAX:preencha com positivo.
input double EA_STOP_OBJETIVO_DIA = 0 ; //STOP_OBJETIVO_DIA:para se saldo alcancar objetivo do dia.
input double EA_STOP_LOSS = 0 ; //STOP_LOSS:Valor maximo de perda aceitavel;
input int EA_STOP_TICKS_TOLER_SAIDA = 1 ; //STOP_TICKS_TOLER_SAIDA: qtd de ticks a aguardar nas saidas stop;
#define EA_STOP_CHUNK 10 //STOP_CHUNK:A partir dessa qtd contratos totais na posicao, comeca a controlar seu fechamento.
#define EA_STOP_PORC_L1 1 //STOP_PORC_L1:Porc qtd contratos totais da posicao em reais para a saida;
#define EA_STOP_10MINUTOS 0 //STOP_10MINUTOS:fecha a posicao aberta a mais de XX segundos, se xx eh dif de zero.
#define EA_STOP_QTD_CONTRATOS_PENDENTES 0 //STOP_QTD_CONTRATOS_PENDENTES fecha posic se qtd contrat maior que este
//
//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 group "Regiao de compra e venda"
//input double EA_REGIAO_BUY_SELL = 0.3 ; //REGIAO_BUY_SELL: regiao de compra e venda nas extremidades do canal de entrelacamento.
//input bool EA_USA_REGIAO_CANAL_DIA = false; //USA_REGIAO_CANAL_DIA: usa a regiao do canal diario (true) ou canal de entrelacamento(false) para calcular regiao de compra venda.
//
//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 "show_tela"
input bool EA_SHOW_CONTROL_PANEL = false; //SHOW_CONTROL_PANEL mostra painel de controle;
input bool EA_SHOW_TELA = false; //SHOW_TELA:mostra valor de variaveis na tela;
input bool EA_SHOW_CANAL_PRECOS = false; //SHOW_CANAL_PRECOS:mostra linhas do canal de precos;
#define 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 ulong EA_MAGIC = 20093007004000; //MAGIC: Numero magico desse EA. yy-mm-vv-vvv-vvv.
////
//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 = 6.0 ;//DOLAR_TARIFA:usado para calcular a tarifa do dolar.
////
//#define EA_MAX_VOL_EM_RISCO 200 //EA_MAX_VOL_EM_RISCO:Qtd max de contratos em risco; Sao os contratos pendentes da posicao.
//#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 feira...
//input group "estatistica"
//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.
//---------------------------------------------------------------------------------------------
// configurando o horario de inicio e fim da operacao...
input group "horario de operacao"
input int EA_HR_INI_OPERACAO = 09; // Hora de inicio da operacao;
input int EA_MI_INI_OPERACAO = 15; // Minuto de inicio da operacao;
input int EA_HR_FIM_OPERACAO = 17; // Hora de fim da operacao;
input int EA_MI_FIM_OPERACAO = 52; // Minuto de fim da operacao;
input int EA_HR_FECHAR_POSICAO = 17; // HR_FECHAR_POSICAO fecha todas as posicoes;
input int EA_MI_FECHAR_POSICAO = 53; // MI_FECHAR_POSICAO fecha todas as posicoes;
//---------------------------------------------------------------------------------------------
//
// group "sleep e timer"
input int EA_SLEEP_INI_OPER = 10 ;//SLEEP_INI_OPER:Aguarda estes segundos para iniciar abertura de posicoes.
input int EA_QTD_MILISEG_TIMER = 500;//QTD_SEG_TIMER:Tempo de acionamento do timer.
//input int EA_SLEEP_ATRASO = 0 ;//SLEEP_TESTE_ONLINE:atraso em milisegundos antes de enviar ordens.
//---------------------------------------------------------------------------------------------
//osc_estatistic2 m_est;
MqlDateTime m_date;
string m_name = "OSE-P7-004-001" ; //
CSymbolInfo m_symb, m_symb_ref ;
CPositionInfo m_posicao ;
CAccountInfo m_cta ;
double m_tick_size ;// alteracao minima de preco.
double m_lots_step ;// alteracao minima de volume.
double m_spread ;// spread.
double m_point ;// valor do ponto.
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 ; // operacao com ordens
osc_minion_trade_estatistica m_trade_estatistica; // estatistica de trades
osc_estatistic3* m_est ; // estatistica de ticks
osc_control_panel_p7_002_004 m_cp ; // painel de controle
//C0002ArbitragemPar* m_par ;
bool m_comprado = false;
bool m_vendido = false;
double m_posicaoVolumePend = 0; // volume pendente pra fechar a posicao atual
double m_posicaoLotsPend = 0; // lotes pendentes 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 ;
// barras atual e anterior...
//MqlRates m_rates[];
//double m_high0 = 0;
//double m_low0 = 0;
//double m_high1 = 0;
//double m_low1 = 0;
//double m_lenBar0 = 0;
//double m_lenBar1 = 0;
//double m_lenAteStop = 0;
//--- variaveis atualizadas pela funcao refreshMe...
int m_qtdOrdens = 0;
int m_qtdOrdensAnt = 0;
int m_qtdPosicoes = 0;
double m_posicaoProfit = 0;
double m_ask = 0;
double m_bid = 0;
double m_ask_stplev = 0; // ask - stop level
double m_bid_stplev = 0; // bid + stop level
double m_val_order_4_gain = 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
//-- controle das inclinacoes
double m_inclSel = 0;
double m_inclBuy = 0;
double m_inclTra = 0;
double m_inclBok = 0;
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_strRajada = "RJ" ; //string que identifica rajadas de abertura de novas posicoes.
string m_comment_fixo;
string m_comment_var;
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;
double m_stop_level_in_price = 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;
double m_qtd_ticks_4_gain_new = 0;
double m_qtd_ticks_4_gain_ini = 0;
double m_qtd_ticks_4_gain_decr = 0;
double m_qtd_ticks_4_gain_bb = 0;
double m_qtd_ticks_4_gain_raj= 0;
int m_passo_rajada = 0;
double m_vol_lote_ini = 0;
double m_vol_lote_raj = 0;
// operacao com rajada unica.
double m_raj_unica_distancia_demais_ordens = 0;
double m_raj_unica_distancia_prim_ordem = 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_in_points = 0;
datetime m_time_in_seconds_ini_day = TimeCurrent();
ENUM_TIPO_ENTRADA_PERMITDA m_tipo_entrada_permitida = EA_TIPO_ENTRADA_PERMITIDA;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
//CiMA m_vetMaInst [6];
//CiMA m_vetMaTrader[6];
//testando a classe osc_canal...
osc_canal m_canal;
//C0001FuzzyModel m_mercado_modelo;
//double m_riscoVenda = 0;
//double m_riscoCompra = 0;
int OnInit(){
//m_qtd_exec_oninit++;
#ifdef COMPILE_PRODUCAO m_release = "[RELEASE PRODU]";#endif
Print(":-| ", __FUNCTION__,m_release, " ************************************************");
Print(":-| ", __FUNCTION__,m_release, " Iniciando : ", TimeCurrent() );
Print(":-| ", __FUNCTION__,m_release, " MAGIC : ", EA_MAGIC );
Print(":-| ", __FUNCTION__,m_release, " BUILDER : ", __MQLBUILD__ );
Print(":-| ", __FUNCTION__,m_release, " EXECUTAVEL: ", __PATH__ );
Print(":-| ", __FUNCTION__,m_release, " BUILDATE : ", __DATETIME__ );
Print(":-| ", __FUNCTION__,m_release, " MQL : ", __MQL__ );
Print(":-| ", __FUNCTION__,m_release, " ************************************************");
//----------------------------------------------------------------------------------------
inicializarSimbolo(); // Primeiro a executar pois ha varios a frente que dependem do simbolo configurado
inicializarVariaveisRecebidasPorParametro();
inicializarPassoRajadaFixoHFT_FORMADOR_DE_MERCADO();
m_stopLossOrdens = m_symb.NormalizePrice(EA_STOP_TICKS_STOP_LOSS *m_tick_size);
m_tkprof = m_symb.NormalizePrice(EA_STOP_TICKS_TKPROF *m_tick_size);
m_trade.setSymbol ( _Symbol );
m_trade.setMagic ( EA_MAGIC);
m_trade.setStopLoss( m_stopLossOrdens);
m_trade.setTakeProf( m_tkprof);
m_posicao.Select( m_symb_str ); // selecao da posicao por simbolo.
m_canal.inicializar(m_tick_size,EA_TAMANHO_CANAL, EA_PORC_REGIAO_OPERACIONAL_CANAL);
m_canal.setShowCanalPrecos(EA_SHOW_CANAL_PRECOS);
m_canal.setRegiaoBuySellUsaCanalDia(EA_CANAL_DIARIO);
// 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_spread_maximo_in_points = (int)( (EA_SPREAD_MAXIMO_EM_TICKS*m_tick_size)/m_point );
m_stop_level_in_price = normalizar ( m_symb.StopsLevel()*m_point + m_tick_size );
//m_stop_level_in_price = normalizar ( m_symb_ref.StopsLevel()*m_symb.Point() );
m_shift_in_points = normalizar( (EA_TOLERANCIA_ENTRADA*m_tick_size)/m_point ); // 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();
//BBCriar();
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() );
//m_precoUltOrdemInBuy = 0;
//m_precoUltOrdemInSel = 0;
EventSetMillisecondTimer(EA_QTD_MILISEG_TIMER);
Print(":-| Expert ", __FUNCTION__,":", " Criado Timer de ",EA_QTD_MILISEG_TIMER," milisegundos !!! " );
Print(":-) Expert ", __FUNCTION__,":", " inicializado !! " );
Print(":-| " , __FUNCTION__,":",m_release);
Print(":-| " , __FUNCTION__,":",m_release);
Print(":-| " , __FUNCTION__,":",m_release);
// melhorando a administracao do stop_loss quando o EA inicia em meio a uma posicao em andamento
definirPasso();
inicializarControlPanel();
if( EA_LOGAR_TRADETRANSACTION ) m_pos.initLogCSV();//<TODO> RETIRE APOS TESTES
m_pos.initialize();
// if( EA_ACAO_POSICAO == HFT_ARBITRAGEM_PAR ){
// m_par = new C0002ArbitragemPar;
// m_par.initialize(EA_QTD_SEG_MEDIA_PRECO,EA_QTD_SEG_MEDIA_RATIO);
//
// m_est = m_par.getEstAtivo1(); // usando o ponteiro que jah eh atualizado pelo objeto de arbitragem.
// // assim evitamos atualizar outro objeto estatistico.
//
// m_symb_ref.Name( EA_TICKER_REF ); // inicializacao da classe CSymbolInfo do simbolo de referencia
// m_symb_ref.Refresh (); // propriedades do simbolo de referencia. Basta executar uma vez.
// m_symb_ref.RefreshRates (); // valores do tick. execute uma vez por tick.
//
// // aguardando a media de ratio ser totalmente calculada antes de abrir a primeira posicao
// m_aguardar_para_abrir_posicao = EA_QTD_SEG_MEDIA_RATIO*1000;
// }else{
m_est = new osc_estatistic3;
m_est.initialize(EA_EST_QTD_SEGUNDOS,false); // quantidade de segundos que serao usados no calculo da velocidade do volume e flag indicando que deve consertar ticks sem flag.
m_est.setSymbolStr( m_symb_str );
// }
return(INIT_SUCCEEDED);
}
double m_len_canal_ofertas = 0; // tamanho do canal de ofertas 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_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.
double m_volTradePorSegLiq = 0;
double m_lenTradePorSeg = 0; // tamanho do canal de ticks formado durante a acumulacao da estatistica.
int m_volTradePorSegDeltaPorc = 0; // % da diferenca do volume por segundo do vencedor. Se for positivo, o vencedor eh buy, se negativo eh sell.
//ulong m_trefreshMe = 0;
//ulong m_trefreshFeira = 0;
//ulong m_trefreshTela = 0;
//ulong m_trefreshRates = 0;
//ulong m_tcontarTransacoes = 0;
//ulong m_tcloseRajada = 0;
MqlTick m_tick_est, m_tick_est_ref;
osc_cusum m_cusum;
bool m_strikeHmais =false;
bool m_strikeHmenos =false;
bool m_strikeCMais =false;
bool m_strikeCMenos =false;
void refreshMe(){
//m_qtd_exec_refreshme++;
m_symb.RefreshRates();
// adicionando o tick ao componente estatistico...
// if( EA_ACAO_POSICAO == HFT_ARBITRAGEM_PAR ){
// SymbolInfoTick(EA_TICKER_REF,m_tick_est_ref);
// SymbolInfoTick(m_symb_str ,m_tick_est );
// m_par.addTick(m_tick_est ,m_tick_est_ref);
// }else{
SymbolInfoTick(m_symb_str,m_tick_est);
m_est.addTick(m_tick_est);
// }
m_cusum.calcC( m_tick_est.last ,
m_est.getPrecoMedTrade(),
EA_KK , //double K,
EA_HH , //double H,
m_strikeHmais ,
m_strikeHmenos,
m_strikeCMais ,
m_strikeCMenos);
m_spread = m_tick_est.ask-m_tick_est.bid;
m_volTradePorSegLiq=m_est.getVolTradeLiqPorSeg();
m_volTradePorSegBuy=m_est.getVolTradeBuyPorSeg();
m_volTradePorSegSel=m_est.getVolTradeSelPorSeg();
m_lenTradePorSeg = (m_est.getTradeHigh() - m_est.getTradeLow() )/m_tick_size; // tamanho do canal de ticks formado durante a acumulacao da estatistica.
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_ask = m_tick_est.ask;
m_bid = m_tick_est.bid;
//m_ask_stplev = m_bid + m_stop_level_in_price; if( m_ask_stplev < m_ask ) m_ask_stplev = m_ask;
//m_bid_stplev = m_ask - m_stop_level_in_price; if( m_bid_stplev > m_bid ) m_bid_stplev = m_bid;
m_ask_stplev = m_ask + m_stop_level_in_price;
m_bid_stplev = m_bid - m_stop_level_in_price;
m_canal.refresh(m_ask,m_bid);
// atualizando precos de abertura e fechamento da barra atual...
//CopyRates(m_symb_str,_Period,0,2,m_rates);
//m_high0 = m_rates[0].high;
//m_low0 = m_rates[0].low ;
//m_lenBar0 = m_high0-m_low0;
//m_high1 = m_rates[1].high;
//m_low1 = m_rates[1].low ;
//m_lenBar1 = m_high1-m_low1;
// distancia desde entrada da ordem ateh o stop (quando trabalha com rajada fixa).
//m_lenAteStop = (EA_DISTAN_PRIM_ORDEM_RAJ *m_tick_size)+
// (EA_DISTAN_DEMAIS_ORDENS_RAJ*EA_TAMANHO_RAJADA*m_tick_size);
m_qtdOrdens = OrdersTotal();
m_qtdPosicoes = PositionsTotal();
// adminstrando posicao aberta...
if( m_qtdPosicoes > 0 ){
if ( PositionSelect (m_symb_str) ){ // soh funciona em contas hedge
if(m_tempo_posicao_ini == 0) m_tempo_posicao_ini = TimeCurrent();
m_tempo_posicao_atu = TimeCurrent() - m_tempo_posicao_ini;
m_qtdOrdensAnt = 0;
if( PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY ){
setCompradoSoft();
}else{
setVendidoSoft();
}
m_posicaoProfit = PositionGetDouble (POSITION_PROFIT ) ;
m_precoPosicao = normalizar(PositionGetDouble (POSITION_PRICE_OPEN ) ); // este eh o valor medio de abertura da posicao.
m_val_order_4_gain = m_precoPosicao; // que neste formato passamos para a variavel
// que anteriormente guardava o preco original
// de abertura da posicao.
m_posicaoVolumePend = PositionGetDouble (POSITION_VOLUME );
m_posicaoLotsPend = m_posicaoVolumePend/m_lots_step ;
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; // passou a usar em 05/06/2020 jah que nessa estrategia as posicoes sao fechadas de vez.
m_lucroPosicao = m_capitalLiquido - m_capitalInicial; // voltou versao em 07/10/2020
///////////////////////////////////
if( m_precoPosicaoAnt == 0 ){ m_precoPosicaoAnt = m_precoPosicao;}
// preco da posicao mudou...
if( m_precoPosicao != m_precoPosicaoAnt ){
m_precoPosicaoAnt = m_precoPosicao; // salvo no preco anterior
m_qtd_ticks_4_gain_ini -= m_qtd_ticks_4_gain_decr ; // a cada movimentacao da posicao, reduzo a quantidade de ticks necessarios para o gain.
Print(":-| "__FUNCTION__, " m_qtd_ticks_4_gain_ini=",m_qtd_ticks_4_gain_ini );
}
definirPrecoSaidaPosicao();
if( estouComprado() ){
m_posicaoVolumeTot = m_volComprasNaPosicao;
//if( m_stop ){
// // testando acionamento do stop no calculo do preco de saida da posicao...
// m_precoSaidaPosicao = m_ask;
//}else{
// m_precoSaidaPosicao = normalizar(m_precoPosicao + m_qtd_ticks_4_gain_ini*m_tick_size);
//}
}else{
if( estouVendido() ){
m_posicaoVolumeTot = m_volVendasNaPosicao;
//if( m_stop ){
// // testando acionamento do stop no calculo do preco de saida da posicao...
// m_precoSaidaPosicao = m_bid;
//}else{
// m_precoSaidaPosicao = normalizar(m_precoPosicao - m_qtd_ticks_4_gain_ini*m_tick_size);
//}
}
}
//m_lucroPosicao4Gain = (m_posicaoVolumeTot *m_stop_porc);
//m_lucroPosicao4Gain = (m_posicaoVolumeTot *m_qtd_ticks_4_gain_ini); // passou a usar em 05/06/2020
m_lucroPosicao4Gain = (m_posicaoVolumePend*m_qtd_ticks_4_gain_ini); // passou a usar em 05/06/2020
///////////////////////////////////
}else{
// aqui neste bloco, estah garantido que nao ha posicao aberta...
m_qtdPosicoes = 0;
m_volVendasNaPosicao = 0;
m_volComprasNaPosicao = 0;
m_capitalInicial = m_cta.Balance(); // se nao estah na posicao, atualizamos o capital inicial da proxima posicao.
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI;
m_comprado = false;
m_vendido = false;
m_stop = false;
m_lucroPosicao = 0;
m_lucroPosicao4Gain = 0;
m_posicaoVolumePend = 0; // versao 02-085
m_posicaoLotsPend = 0;
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_precoPosicaoAnt = 0 ;
}
}else{
// aqui neste bloco, estah garantido que nao ha posicao aberta...
m_qtdPosicoes = 0;
m_volVendasNaPosicao = 0;
m_volComprasNaPosicao = 0;
m_capitalInicial = m_cta.Balance(); // se nao estah na posicao, atualizamos o capital inicial da proxima posicao.
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI;
m_comprado = false;
m_vendido = false;
m_stop = false;
m_lucroPosicao = 0;
m_lucroPosicao4Gain = 0;
m_posicaoVolumePend = 0; //versao 02-085
m_posicaoLotsPend = 0;
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_precoPosicaoAnt = 0 ;
//Deixando o stop loss de posicao preparado. Quando posicionado, nao altera o stop loss de posicao.
//calcStopLossPosicao();
}
m_sld_sessao_atu = m_cta.Balance();
showAcao("normal");
} // refreshme()
void showAcao(string acao){
if( !EA_SHOW_TELA ){ return; }
Comment(
//"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",
//"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",
" \n ticks_consertados=" ,m_est.getQtdTicksConsertados(),
" \n m_cta.Balance=" ,m_cta.Balance (),
" \n m_cta.Equity=" ,m_cta.Equity (),
" \n m_cta.Profit=" ,m_cta.Balance() - m_cta.Equity(),
" \n m_cta.Profit=" ,m_cta.Profit (),
" \n m_posicao.Profit= " ,m_posicao.Profit (),
" \n m_posicao.Volume= " ,m_posicao.Volume (),
" \n m_lucroPosicao4Gain=" ,m_lucroPosicao4Gain ,
//" \n m_passo_rajada=" ,m_passo_rajada ,
" \n m_tempo_posicao_atu=" ,m_tempo_posicao_atu ,
//" \n m_posicao.PriceOpen=" ,m_posicao.PriceOpen (),
//" \n m_posicao.PriceCurrent=" ,m_posicao.PriceCurrent (),
//" \n acao=" ,acao ,
//----------------
" \n len_canal=" ,m_canal.getLenCanalOperacionalEmTicks(),
" \n regiaoSuperior=" ,m_canal.regiaoSuperior(),
" \n regiaoInferior=" ,m_canal.regiaoInferior(),
" \n precoregiaoSuperior=" ,m_canal.getPrecoRegiaoSuperior(),
" \n precoregiaoInferior=" ,m_canal.getPrecoRegiaoInferior(),
//----------------
" \n m_est.getInclinacaoHLTrade=" ,m_est.getInclinacaoHLTrade (),
" \n m_est.getInclinacaoHLTTradeBuy=",m_est.getInclinacaoHLTradeBuy(),
" \n m_est.getInclinacaoHLTradeSel=" ,m_est.getInclinacaoHLTradeSel(),
" \n FIXOS==================================================" ,
" \n EA_DIST_MIN_IN_BOOK_IN_POS=" ,EA_DIST_MIN_IN_BOOK_IN_POS,
" \n EA_LAG_RAJADA=" ,EA_LAG_RAJADA ,
" \n EA_QTD_TICKS_4_GAIN_INI=" ,EA_QTD_TICKS_4_GAIN_INI ,
" \n EA_QTD_TICKS_4_GAIN_MIN=" ,EA_QTD_TICKS_4_GAIN_MIN ,
" \n m_razao_lag_rajada_x_dist_entrada_book=" ,m_razao_lag_rajada_x_dist_entrada_book ,
" \n DINAMICOS==================================================" ,
" \n m_dist_min_in_book_in_pos=" ,m_dist_min_in_book_in_pos ,
" \n m_dist_min_in_book_out_pos=" ,m_dist_min_in_book_out_pos ,
" \n m_lag_rajada=" ,m_lag_rajada
//" \n SYMB==================================================" ,
//" \n SessionAW=" ,m_symb.SessionAW() ,
//" \n BidHigh=" ,m_symb.BidHigh() ,
//" \n SessionOpen=" ,m_symb.SessionOpen()
);
}
void refreshControlPanel(){
// refresh do painel eh no maximo uma vez por segundo...
//if( m_date_atu.sec%2 == 0 ) return;
if( !EA_SHOW_CONTROL_PANEL ) return;
if( m_qtdPosicoes==0 ){
m_cp.setPosicaoNula("NULL");
}else{
if (estouComprado() ){
m_cp.setPosicaoBuy ("BUY" );
}else{
m_cp.setPosicaoSell("SELL");
}
}
m_cp.setPasso ((int)m_passo_rajada );
m_cp.setProfitPosicao( m_lucroPosicao );
//m_cp.setSaidaPosicao ( m_saida_posicao );
m_cp.setSaidaPosicao ( m_lucroPosicao4Gain );
m_cp.setStopLoss ( m_stopLossPosicao );
m_cp.setT4g ( m_qtd_ticks_4_gain_ini);
m_cp.setVolPosicao ( IntegerToString( (int)(m_posicaoLotsPend ) ) + "/" +
IntegerToString( (int)(m_posicaoVolumeTot ) )
);
m_cp.setPftBruto ( m_trade_estatistica.getProfitDia () );
m_cp.setTarifa ( m_trade_estatistica.getTarifaDia () );
m_cp.setPftContrat( m_trade_estatistica.getProfitPorContrato() );
m_cp.setPftLiquido( m_trade_estatistica.getProfitDiaLiquido () );
m_cp.setVol ( m_trade_estatistica.getVolumeDia () );
//m_cp.setVolTradePorSegDeltaPorc( m_volTradePorSegDeltaPorc );
///m_cp.setVolTradePorSegDeltaPorc( m_exp.getLenCanalOperacionalEmTicks() );
m_cp.setVTLiq ( m_volTradePorSegLiq, m_volTradePorSegLiqAnt );
m_cp.setVTBuy ( m_volTradePorSegBuy );
m_cp.setVTSel ( m_volTradePorSegSel );
m_cp.setVTDir ( m_direcaoVelVolTrade ,0);
m_cp.setVTLen ( m_lenTradePorSeg );
m_cp.setVTDir2( m_direcaoVelVolTradeMed,0);
m_cp.setLEN0 ( m_canal.getLenCanalOperacionalEmTicks(),0);
m_cp.setLEN1 ( m_canal.getCoefLinear(),0);
}
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;
}
//int 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;
//}
int m_dist_min_in_book_in_pos = 0;//EA_DIST_MIN_IN_BOOK_IN_POS; //DISTANCIA_MINIMA_PARA_ENTRAR_NO_BOOK ABRINDO POSICAO
int m_dist_min_in_book_out_pos = 0;//EA_DIST_MIN_IN_BOOK_OUT_POS; //DISTANCIA_MINIMA_PARA_ENTRAR_NO_BOOK FECHANDO POSICAO
int m_lag_rajada = 0;//EA_LAG_RAJADA ; //LAG_RAJADA
double m_razao_lag_rajada_x_dist_entrada_book = 0;//(double)EA_DIST_MIN_IN_BOOK_IN_POS/(double)EA_LAG_RAJADA;
void definirPasso(){
if( EA_ALVO_DINAMICO ){
if( EA_TAMANHO_RAJADA==0 ) return;
if( EA_ACAO_POSICAO == HFT_FORMADOR_DE_MERCADO ){
m_razao_lag_rajada_x_dist_entrada_book = (double)EA_DIST_MIN_IN_BOOK_IN_POS/oneIfZero( (double)EA_LAG_RAJADA );
m_qtd_ticks_4_gain_ini = ceil( m_canal.getLenCanalOperacionalEmTicks()/(double)(EA_TAMANHO_RAJADA*2.0 +(m_razao_lag_rajada_x_dist_entrada_book)*2.0 ) );
if(m_qtd_ticks_4_gain_ini<EA_QTD_TICKS_4_GAIN_MIN) m_qtd_ticks_4_gain_ini=EA_QTD_TICKS_4_GAIN_MIN;
m_lag_rajada = (int)ceil(m_qtd_ticks_4_gain_ini);
m_passo_rajada = m_lag_rajada; //nao eh usado. Eh soh pra aparecer no painel de controle.
m_dist_min_in_book_in_pos = (int)ceil(m_lag_rajada*m_razao_lag_rajada_x_dist_entrada_book);
m_dist_min_in_book_out_pos = (int)ceil(m_lag_rajada*m_razao_lag_rajada_x_dist_entrada_book); //<todo> consertar
}else{
m_qtd_ticks_4_gain_ini = m_canal.getLenCanalOperacionalEmTicks()/(double)EA_TAMANHO_RAJADA;
m_passo_rajada = (int)floor( ( m_canal.getLenCanalOperacionalEmTicks()-
m_canal.getLenCanalOperacionalEmTicks()*
EA_PORC_REGIAO_OPERACIONAL_CANAL )/(double)EA_TAMANHO_RAJADA
);
//m_passo_rajada = floor( m_qtd_ticks_4_gain_ini );
if( m_passo_rajada == 0 ) m_passo_rajada = 1;
m_raj_unica_distancia_demais_ordens = m_passo_rajada;
m_raj_unica_distancia_prim_ordem = m_passo_rajada;
m_qtd_ticks_4_gain_decr = m_qtd_ticks_4_gain_ini/(double)EA_TAMANHO_RAJADA;
//m_qtd_ticks_4_gain_decr = 0; // testando 1 tick
m_raj_unica_distancia_prim_ordem = m_passo_rajada;
m_raj_unica_distancia_demais_ordens = m_passo_rajada;
}
}
if( EA_PASSO_DINAMICO ){
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 = (int)(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;
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;
}
}
// criando o painel de controle do expert...
bool inicializarControlPanel(){
if(!EA_SHOW_CONTROL_PANEL) return true ;
if(!m_cp.Create() ) return false; // create application dialog
if(!m_cp.Run() ) return false; // run application
return true;
}
//----------------------------------------------------------------------------------------
// tem de ser o primeiro ponto pois ha varios a frente que dependem do simbolo configurado
//----------------------------------------------------------------------------------------
void inicializarSimbolo(){
Print(":-| ", __FUNCTION__," ******************************** Inicializando simbolo...");
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_point = m_symb.Point() ;
m_lots_step = m_symb.LotsStep();
Print(":-| ", __FUNCTION__," m_symb_str :", m_symb_str );
Print(":-| ", __FUNCTION__," m_tick_size:", m_tick_size );
Print(":-| ", __FUNCTION__," m_point :", m_point );
Print(":-| ", __FUNCTION__," m_lots_step:", m_lots_step );
Print(":-| ", __FUNCTION__," ******************************** Simbolo inicializado.>");
}
double m_passo_dinamico_porc_canal_entrelaca = 0;
double m_stopLossPosicao = 0;
void inicializarVariaveisRecebidasPorParametro(){
Print(":-| ", __FUNCTION__," ******************************** Inicializando variaveis diversas...");
m_aguardar_para_abrir_posicao = EA_SLEEP_INI_OPER*1000;
m_tipo_entrada_permitida = EA_TIPO_ENTRADA_PERMITIDA;
// stop loss da posicao
m_stopLossPosicao = EA_STOP_LOSS;
//m_stopLossPosicao = m_exp.getStopLoss();//EA_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 = m_exp.getVolat4sAltaPorc();// EA_VOLAT4S_ALTA_PORC;
// quantidade de periodos usados para calcular o coeficiente de entrelacamento.
//m_exp.setEntrelacaPeriodoCoef(EA_ENTRELACA_PERIODO_COEF);
// variaveis de controle do stop...
m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI;
m_qtd_ticks_4_gain_raj = EA_QTD_TICKS_4_GAIN_INI;
m_vol_lote_raj = EA_VOL_PRIM_ORDEM_RAJ!=0?EA_VOL_PRIM_ORDEM_RAJ*m_lots_step:m_symb.LotsMin();
m_vol_lote_ini = EA_VOL_LOTE_INI !=0?EA_VOL_LOTE_INI *m_lots_step:m_symb.LotsMin();
m_passo_rajada = (int)EA_DISTAN_DEMAIS_ORDENS_RAJ;
m_stop_qtd_contrat = (int)EA_STOP_CHUNK;
m_stop_chunk = (int)EA_STOP_CHUNK;
m_stop_porc = EA_STOP_PORC_L1;
// operacao com rajada unica.
m_raj_unica_distancia_prim_ordem = EA_DISTAN_PRIM_ORDEM_RAJ ==0?m_qtd_ticks_4_gain_ini:EA_DISTAN_PRIM_ORDEM_RAJ ; // se param for zero, usa EA_DISTAN_PRIM_ORDEM_RAJ
m_raj_unica_distancia_demais_ordens = EA_DISTAN_DEMAIS_ORDENS_RAJ==0?m_qtd_ticks_4_gain_ini:EA_DISTAN_DEMAIS_ORDENS_RAJ; // se param for zero, usa EA_DISTAN_DEMAIS_ORDENS_RAJ
m_qtd_ticks_4_gain_decr = EA_QTD_TICKS_4_GAIN_DECR;
m_Cmedia_direcaoVelocidadeTradeMedia.initialize(EA_EST_QTD_SEGUNDOS);
Print(":-| ", __FUNCTION__," m_aguardar_para_abrir_posicao :", m_aguardar_para_abrir_posicao );
Print(":-| ", __FUNCTION__," m_tipo_entrada_permitida :", m_tipo_entrada_permitida );
Print(":-| ", __FUNCTION__," m_stopLossPosicao :", m_stopLossPosicao );
Print(":-| ", __FUNCTION__," m_qtd_ticks_4_gain_ini :", m_qtd_ticks_4_gain_ini );
Print(":-| ", __FUNCTION__," m_qtd_ticks_4_gain_raj :", m_qtd_ticks_4_gain_raj );
Print(":-| ", __FUNCTION__," m_vol_lote_raj :", m_vol_lote_raj );
Print(":-| ", __FUNCTION__," m_vol_lote_ini :", m_vol_lote_ini );
Print(":-| ", __FUNCTION__," m_passo_rajada :", m_passo_rajada );
Print(":-| ", __FUNCTION__," m_stop_qtd_contrat :", m_stop_qtd_contrat );
Print(":-| ", __FUNCTION__," m_stop_chunk :", m_stop_chunk );
Print(":-| ", __FUNCTION__," m_stop_porc :", m_stop_porc );
Print(":-| ", __FUNCTION__," m_raj_unica_distancia_prim_ordem :", m_raj_unica_distancia_prim_ordem );
Print(":-| ", __FUNCTION__," m_raj_unica_distancia_demais_ordens :", m_raj_unica_distancia_demais_ordens);
Print(":-| ", __FUNCTION__," m_qtd_ticks_4_gain_decr :", m_qtd_ticks_4_gain_decr );
Print(":-| ", __FUNCTION__," m_Cmedia_direcaoVelocidadeTradeMedia:", EA_EST_QTD_SEGUNDOS," seg" );
Print(":-| ", __FUNCTION__," ******************************** Variaveis diversas inicializadas." );
}
void inicializarPassoRajadaFixoHFT_FORMADOR_DE_MERCADO(){
Print(":-| ", __FUNCTION__," ******************************** Inicializando variaveis HFT_FORMADOR_DE_MERCADO...");
m_dist_min_in_book_in_pos = EA_DIST_MIN_IN_BOOK_IN_POS ; //DISTANCIA_MINIMA_PARA_ENTRAR_NO_BOOK ABRINDO POSICAO
m_dist_min_in_book_out_pos = EA_DIST_MIN_IN_BOOK_OUT_POS; //DISTANCIA_MINIMA_PARA_ENTRAR_NO_BOOK FECHANDO POSICAO
m_razao_lag_rajada_x_dist_entrada_book = (double)EA_DIST_MIN_IN_BOOK_IN_POS/ oneIfZero( (double)EA_LAG_RAJADA );
//m_qtd_ticks_4_gain_ini = EA_QTD_TICKS_4_GAIN_INI;
//if(m_qtd_ticks_4_gain_ini<EA_QTD_TICKS_4_GAIN_MIN) m_qtd_ticks_4_gain_ini=EA_QTD_TICKS_4_GAIN_MIN;
m_lag_rajada = EA_LAG_RAJADA;
m_passo_rajada = m_lag_rajada; //nao eh usado. Eh soh pra aparecer no painel de controle.
Print(":-| ", __FUNCTION__," m_dist_min_in_book_in_pos :", m_dist_min_in_book_in_pos ,": DISTANCIA_MINIMA_PARA_ENTRAR_NO_BOOK ABRINDO POSICAO");
Print(":-| ", __FUNCTION__," m_dist_min_in_book_out_pos :", m_dist_min_in_book_out_pos ,": DISTANCIA_MINIMA_PARA_ENTRAR_NO_BOOK FECHANDO POSICAO");
Print(":-| ", __FUNCTION__," m_razao_lag_rajada_x_dist_entrada_book:", m_razao_lag_rajada_x_dist_entrada_book );
Print(":-| ", __FUNCTION__," m_lag_rajada :", m_lag_rajada );
Print(":-| ", __FUNCTION__," m_passo_rajada :", m_passo_rajada );
Print(":-| ", __FUNCTION__," ******************************** Variaveis HFT_FORMADOR_DE_MERCADO inicializadas.");
}
// retorna a porcentagem como um numero inteiro.
int porcentagem( double parte, double tot, int seTotZero){
if( tot==0 ){ return seTotZero ; }
return (int)( (parte/tot)*100.0);
}
int m_qtd_print_debug = 0;
void fecharTudoForcado(string descr){
m_trade.cancelarOrdens(descr);
if( PositionsTotal()>0 ){
long idPos = PositionGetInteger(POSITION_IDENTIFIER);
m_trade.PositionClose(idPos);
}
}
bool m_stop = false;
void fecharTudo(string descr){ fecharTudo(descr,"",EA_STOP_TICKS_TOLER_SAIDA); }
void fecharTudo(string descr,string strLog){ fecharTudo(descr,strLog,EA_STOP_TICKS_TOLER_SAIDA); }
void fecharTudo(string descr, string strLog, int qtdTicksDeslocamento){
if( m_qtdPosicoes>0 ){
//////////////////////////////////////////////////////////////////////////////////
// testando acionamento do stop usando o preco de saida da posicao...
//
// soh imprime no log uma vez por stop...
//if(m_stop==false) Print(":-| ", __FUNCTION__,"(",descr,",",strLog,",",qtdTicksDeslocamento,")");
m_stop = true;
definirPrecoSaidaPosicao();
if( alterarPrecoOrdensSaidaSeNecessario() ) Print(":-| ", __FUNCTION__,"(",descr,",",strLog,",",qtdTicksDeslocamento,")");
return;
//
//////////////////////////////////////////////////////////////////////////////////
int qtd = 1;
string qtdStr;
string qtdTicksdesloc = IntegerToString(qtdTicksDeslocamento);
//while( m_qtdPosicoes > 0 ){
qtdStr = IntegerToString(qtd++);
Print (":-| ", __FUNCTION__,":",qtdStr,":fecharPosicao2(",descr,",",strLog,",",qtdTicksdesloc,")");
fecharPosicao2(descr, strLog, qtdTicksDeslocamento);
//}
}else{
Print (__FUNCTION__+":m_trade.cancelarOrdens():descr:"+descr);
m_trade.cancelarOrdens(descr);
if( m_stop == true ) m_stop = false;
}
}
// se o preco de saida da posicao mudou, altera o preco das ordens de saida, a menos que o EA feche posicao por ordem de entrada e nao no breakeven...
bool alterarPrecoOrdensSaidaSeNecessario(){
if( !EA_FECHA_POSICAO_NO_BREAK_EVEN && !m_stop ) return false;
if( m_precoSaidaPosicao!=m_precoSaidaPosicaoAnt || m_stop ){
m_precoSaidaPosicaoAnt = m_precoSaidaPosicao;
m_trade.alterarValorDeOrdensNumericasPara(m_symb_str,m_precoSaidaPosicao,m_precoPosicao);
return true;
}
return false;
}
void fecharPosicao2(string descr, string strLog, int qtdTicksDeslocamento=0, int deep=1){
Print(":-| ", __FUNCTION__,"(",descr,",",strLog,",",qtdTicksDeslocamento,",",deep,")");
//<TODO> Este item 1, eh incompativel com novo metodo de fechamento de posicao. Por enquanto
// deixo comentado afim de testar. Resova durante ou logo apos os testes.
//
//1. providenciando ordens de fechamento que porventura faltem na posicao...
//Print (":-| ", __FUNCTION__+":doCloseRajada(",m_passo_rajada,",",m_vol_lote_raj,",",m_qtd_ticks_4_gain_raj,")...");
//doCloseRajada(m_qtd_ticks_4_gain_ini);
//2. cancelando rajadas que ainda nao entraram na posicao...
Print (":-| ", __FUNCTION__+":cancelarOrdensRajada()..." );
cancelarOrdensRajada();
//3. trazendo ordens de fechamento a valor presente...
Print (":-| ", __FUNCTION__+":trazerOrdensComComentarioNumerico2valorPresente(",m_symb_str,",",qtdTicksDeslocamento,")...");
m_trade.trazerOrdensComComentarioNumerico2valorPresente(m_symb_str,qtdTicksDeslocamento);
//4. aguardando a execucao das ordens de fechamento...
Sleep(1000); //<TODO> transforme em parametro
//5. refresh pra saber a situacao atual...
Print (":-| ", __FUNCTION__+":refreshMe()..." );
refreshMe();
//6. se ainda estamos posicionados, realiza todos os passos novamente...
if( m_qtdPosicoes > 0 && deep < 5 ){
Print (":-| ",__FUNCTION__+":fecharPosicao2(",descr,",",strLog,",",qtdTicksDeslocamento,",",deep,")");
fecharPosicao2(descr, strLog, qtdTicksDeslocamento,++deep);
}
// pra que nao cancele ordens de fechamento de posicao...
if( m_qtdPosicoes > 0 ) return;
//7. cancelando outras ordens pendentes...
Print (":-| ",__FUNCTION__+":cancelarOrdens(",descr,")");
m_trade.cancelarOrdens(descr);
}
void fecharPosicao3(string descr, string strLog, int qtdTicksDeslocamento=0, int deep=1){
Print(":-| ", __FUNCTION__,"(",descr,",",strLog,",",qtdTicksDeslocamento,",",deep,")");
//<TODO> Este item 1, eh incompativel com novo metodo de fechamento de posicao. Por enquanto
// deixo comentado afim de testar. Resova durante ou logo apos os testes.
//
//1. providenciando ordens de fechamento que porventura faltem na posicao...
//Print (":-| ", __FUNCTION__+":doCloseRajada(",m_passo_rajada,",",m_vol_lote_raj,",",m_qtd_ticks_4_gain_raj,")...");
//doCloseRajada(m_qtd_ticks_4_gain_ini);
//2. cancelando rajadas que ainda nao entraram na posicao...
Print (":-| ", __FUNCTION__+":cancelarOrdensRajada()..." );
cancelarOrdensRajada();
//3. trazendo ordens de fechamento a valor presente...
Print (":-| ", __FUNCTION__+":trazerOrdensComComentarioNumerico2valorPresente(",m_symb_str,",",qtdTicksDeslocamento,")...");
m_trade.trazerOrdensComComentarioNumerico2valorPresente(m_symb_str,qtdTicksDeslocamento);
//4. aguardando a execucao das ordens de fechamento...
Sleep(1000); //<TODO> transforme em parametro
//5. refresh pra saber a situacao atual...
Print (":-| ", __FUNCTION__+":refreshMe()..." );
refreshMe();
//6. se ainda estamos posicionados, realiza todos os passos novamente...
if( m_qtdPosicoes > 0 && deep < 5 ){
Print (":-| ",__FUNCTION__+":fecharPosicao3(",descr,",",strLog,",",qtdTicksDeslocamento,",",deep,")");
fecharPosicao3(descr, strLog, qtdTicksDeslocamento,++deep);
}
m_trade.fecharPosicao("F3emergencia");
// pra que nao cancele ordens de fechamento de posicao...
if( m_qtdPosicoes > 0 ) return;
//7. cancelando outras ordens pendentes...
Print (":-| ",__FUNCTION__+":cancelarOrdens(",descr,")");
m_trade.cancelarOrdens(descr);
}
void cancelarOrdensRajada(){
m_trade.cancelarOrdensComentadas(m_symb_str, m_strRajada);
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
long m_sec_ontick = -1;
void OnTick(){
// executando o ontick uma vez por segundo.
//if( m_date_atu.sec == m_sec_ontick && m_qtd_ticks_4_gain_ini > 5 ) return;
m_sec_ontick = m_date_atu.sec;
refreshMe();
if ( m_qtdPosicoes > 0 ) {
// Esta opcao NAO_OPERAR nao interfere nas ordens...
if( EA_ACAO_POSICAO == NAO_OPERAR ) return;
m_qtdOrdensAnt = 0;
// estah na hora de fechar as posicoes...
if( m_eh_hora_de_fechar_posicao ){
Print(__FUNCTION__, " :-| HORA DE TERMINAR A OPERACAO. FECHANDO TUDO E SAINDO...");
fecharTudoForcado("HORA_DE_FECHAR_POSICAO");
ExpertRemove();
}
// se controlarRiscoDaPosicao() retornar true, significa que acionou um stop, entao retornamos daqui.
if( controlarRiscoDaPosicao() ){ return; }
if( emLeilao() )return;
//if( EA_ACAO_POSICAO == HFT_FORMADOR_DE_MERCADO ) definirPasso();
definirPasso();
alterarPrecoOrdensSaidaSeNecessario();
// Na estrategia HFT_FORMADOR_DE_MERCADO, mantemos a fila de ordens de entrada aberta, mesmo
// durante a vida de uma posicao. Assim pretendemos ganhar prioridade ao chegar no nivel zero do book.
//if (EA_ACAO_POSICAO == HFT_FORMADOR_DE_MERCADO) abrirPosicaoHFTPrioridadeNoBook();
abrirPosicaoHFTPrioridadeNoBook();
}else{
m_time_analisado = 0; // pra que as posicoes abertas sejam analisadas no mesmo periodo de uma posicao que jah fechou.
definirPasso();
// Esta opcao NAO_OPERAR nao interfere nas ordens...
if( EA_ACAO_POSICAO == NAO_OPERAR ) return;
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( EA_ACAO_POSICAO == FECHAR_POSICAO ){ cancelarOrdens("OPCAO_FECHAR_POSICAO" ); return; }
if( EA_ACAO_POSICAO == FECHAR_POSICAO_POSITIVA ){ cancelarOrdens("OPCAO_FECHAR_POSICAO_POSITIVA"); return; }
// cancela as ordens existentes e nao abre novas ordens se o spread for maior que maximo.
if( spreadMaiorQueMaximoPermitido() ){ cancelarOrdens( "SPREAD_ALTO_" + DoubleToString( m_spread,2 ) ); return; }
// cancelando todas as ordens que nao sejam de abertura de posicao...
if( m_qtdOrdensAnt != m_qtdOrdens ){
m_trade.cancelarOrdensExcetoComTxt(m_apmb,"CANC_NOT_APMB");
m_qtdOrdensAnt = m_qtdOrdens; // para diminuir a quantidade de pedidos de cancelamento repetidos
}
// 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");
}
}
// 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( __FUNCTION__, " :-| 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_STOP_REBAIXAMENTO_MAX != 0 &&
// EA_STOP_REBAIXAMENTO_MAX < m_rebaixamento_atu ){
//if ( EA_STOP_REBAIXAMENTO_MAX != 0 &&
// m_trade_estatistica.getRebaixamentoSld() < -EA_STOP_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 (! podeAbrirProsicao() ) {
m_trade.cancelarOrdensExcetoComTxt("STOP","NAO_PODE_ABRIR_POSICAO");
return;
}
switch(EA_ACAO_POSICAO){
case HFT_OPERAR_VOLUME_CANAL : abrirPosicaoHFTVolumeCanal (); break;
case HFT_FORMADOR_DE_MERCADO : abrirPosicaoHFTPrioridadeNoBook (); break;
//case HFT_ARBITRAGEM_PAR : abrirPosicaoHFTarbitragemPar (); break;
//case HFT_DESBALANC_BOOK : abrirPosicaoHFTDesbalancBook (); break;
//case HFT_FLUXO_ORDENS : abrirPosicaoHFTfluxoOrdens (); break;
//case NAO_ABRIR_POSICAO : break;
}
}
}//+------------------------------------------------------------------+
bool podeAbrirProsicao(){
if( m_aguardar_para_abrir_posicao > 0 ) return false; // soh abre novas posicoes apos zerar a penalidade de tempo do dia...
if( spreadMaiorQueMaximoPermitido() ) return false;
return true; //<TODO> tirar pois eh soh pra teste
}
bool saldoRebaixouMaisQuePermitidoNoDia(){ return ( EA_STOP_REBAIXAMENTO_MAX != 0 && m_trade_estatistica.getRebaixamentoSld () > EA_STOP_REBAIXAMENTO_MAX ); }
bool saldoAtingiuObjetivoDoDia (){ return ( EA_STOP_OBJETIVO_DIA != 0 && m_trade_estatistica.getProfitDiaLiquido() > EA_STOP_OBJETIVO_DIA ); }
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);
return;
}
*/
void definirPrecoSaidaPosicao(){
if( estouComprado() ){
if( m_stop ){
// testando acionamento do stop no calculo do preco de saida da posicao...
m_precoSaidaPosicao = m_ask;
}else{
m_precoSaidaPosicao = normalizar(m_precoPosicao + m_qtd_ticks_4_gain_ini*m_tick_size);
}
}else{
if( estouVendido() ){
if( m_stop ){
// testando acionamento do stop no calculo do preco de saida da posicao...
m_precoSaidaPosicao = m_bid;
}else{
m_precoSaidaPosicao = normalizar(m_precoPosicao - m_qtd_ticks_4_gain_ini*m_tick_size);
}
}
}
}
bool controlarRiscoDaPosicao(){
// prevenindo varias execucoes antes que as ordens de fechamento sejam executadas...
//if( m_stop == true ) return true;
if( saldoRebaixouMaisQuePermitidoNoDia() ){ fecharTudo("STOP_REBAIXAMENTO_DE_CAPITAL"); return true;}
// Esta opcao FECHAR_POSICAO fecha todas as posicoes e ordens...
if( EA_ACAO_POSICAO == FECHAR_POSICAO ) { fecharTudo("STOP_FECHAR_POSICAO" ,"STOP_FECHAR_POSICAO" ); return true; }
if( EA_ACAO_POSICAO == FECHAR_POSICAO_POSITIVA && m_posicaoProfit > 0 ) { fecharTudo("STOP_FECHAR_POSICAO_POSITIVA","STOP_FECHAR_POSICAO_POSITIVA"); return true; }
// STOP REGIAO CANAL ( em teste...)
// if( ( estouComprado() && m_canal.regiaoInferior() ) ||
// ( estouVendido() && m_canal.regiaoSuperior() ) ){
// Print(":-( ",__FUNCTION__," Acionando STOP_LOSS_REGIAO_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
// fecharTudo("STOP_LOSS_REGIAO_" + DoubleToString(m_lucroPosicao,0) );
// return true;
// }
// STOP RISCO ANALISADO
// sai se risco estah alto e prejuizo estah maior que a metade do stop loss
//if( m_stopLossPosicao != 0 && m_lucroPosicao < m_stopLossPosicao/2 && m_capitalInicial != 0 ){
//
// // analisando risco da posicao...
// m_mercado_modelo.CalcularRisco(m_est ,
// m_riscoVenda ,
// m_riscoCompra );
// if( ( estouComprado() && m_riscoCompra > EA_RISCO_MAX_POSICAO ) ||
// ( estouVendido() && m_riscoVenda > EA_RISCO_MAX_POSICAO ) ){
//
// Print(":-( ",__FUNCTION__," Acionando STOP_LOSS_RISCO_"+ DoubleToString(m_lucroPosicao,0), " m_stopLossPosicao/2:",m_stopLossPosicao/2, strPosicao() );
// fecharTudo("STOP_LOSS_RISCO_" + DoubleToString(m_lucroPosicao,0) );
// return true;
// }
//}
if( m_stopLossPosicao != 0 && m_lucroPosicao < m_stopLossPosicao && m_capitalInicial != 0 ){
//Print(":-( ",__FUNCTION__," Acionando STOP_LOSS_"+ DoubleToString(m_lucroPosicao,0), strPosicao() );
fecharTudo("STOP_LOSS_" + DoubleToString(m_lucroPosicao,0) );
return true;
}
// fecha a posicao ativa a mais de 10 min
//if( m_tempo_posicao_atu > EA_STOP_10MINUTOS && EA_STOP_10MINUTOS > 0 && m_posicaoProfit >= 0 ){
if( m_tempo_posicao_atu > EA_STOP_10MINUTOS && EA_STOP_10MINUTOS > 0 ){
//Print(":-( ",__FUNCTION__," Acionando STOP_TEMPO_ALTO_"+ DoubleToString(m_lucroPosicao,0)," T=",m_tempo_posicao_atu," ", strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_TEMPO_ALTO_"+ DoubleToString(m_lucroPosicao,0));
return true;
}
// fecha a posicao ativa se a quantidade de contratos pendentes for maior que o permitido
if( m_posicaoLotsPend > EA_STOP_QTD_CONTRATOS_PENDENTES && EA_STOP_QTD_CONTRATOS_PENDENTES > 0 ){
//Print(":-( ",__FUNCTION__," Acionando STOP_LOSS_QTD_CONTRATOS_"+ DoubleToString(m_lucroPosicao,0)," VOL=",m_posicaoLotsPend," ", strPosicao() );
m_lucroStops += m_lucroPosicao;
fecharTudo("STOP_QTD_CONTRATOS_"+ DoubleToString(m_lucroPosicao,0));
return true;
}
return false;
}
string strPosicao(){
return " Contr=" + DoubleToString (m_posicaoLotsPend ,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)+
" LUCRP=" + DoubleToString (m_lucroPosicao ,2)+
" Volat=" + DoubleToString (m_volatilidade ,2)+
" ASK/BID=" + DoubleToString (m_ask,_Digits) + "/"+ DoubleToString (m_bid,_Digits)+
" 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. se quiser operar sem rajada, zere este parametro (PAAAO_RAJADA).
// 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; // se quiser operar sem rajada, zere o parametro PASSO_RAJADA
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_VOL_MARTINGALE) volLote = volLote*2;
if(EA_VOL_MARTINGALE) volLote = volLote+1;
while(precoOrdem < m_ask){
//while(precoOrdem < m_bid){
precoOrdem = normalizar( precoOrdem + (passo*m_tick_size) );
//if(EA_VOL_MARTINGALE) volLote = volLote*2;
if(EA_VOL_MARTINGALE) volLote = volLote+1;
}
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_VOL_MARTINGALE) volLote = volLote*2;
if(EA_VOL_MARTINGALE) volLote = volLote+1;
}
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_VOL_MARTINGALE) volLote = volLote*2;
if(EA_VOL_MARTINGALE) volLote = volLote+1;
while(precoOrdem > m_bid){
//while(precoOrdem > m_ask){
precoOrdem = normalizar( precoOrdem - (passo*m_tick_size) );
//if(EA_VOL_MARTINGALE) volLote = volLote*2;
if(EA_VOL_MARTINGALE) volLote = volLote+1;
}
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_VOL_MARTINGALE) volLote = volLote*2;
if(EA_VOL_MARTINGALE) volLote = volLote+1;
}
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 profit){
if( estouVendido() ){
return doCloseRajada3(m_qtd_ticks_4_gain_raj, true );
}else{
return doCloseRajada3(m_qtd_ticks_4_gain_raj, 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
// 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 doCloseRajada3(double profit, bool close_sell){
//if( EA_FECHA_POSICAO_POR_EVENTO ) return false;
//m_qtd_exec_closerajada3++;
ulong deal_ticket; // ticket da transacao
int deal_type ; // tipo de operação comercial
// 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.
//preenchendo o cache com ordens e transacoes da posicao atual no historico...
if( !HistorySelectByPosition(m_positionId) ){ return false;}
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 no map, 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( m_deal_comment != "" && StringFind(m_deal_comment,"IN") < 0 ){
//fecharTudo("STOP_CLOSERAJADA");
// Print(":-( ", __FUNCTION__, " POSICAO ABERTA POR UMA RAJADA OU FECHAMENTO DE RAJADA. COMMENT: ", m_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.
// 2. Percorra a fila de compras e, pra cada compra encontrada, busque a venda correspondente e retire-a da fila de vendas
// e altere o preco se necessario.
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...
////////////////// ini trecho versao 3 ///////////////
//price = HistoryDealGetDouble(deal_ticket,DEAL_PRICE) ; // obtendo o preco de uma ordem cuja ordem de fechamento jah foi colocada.
//if( price != m_precoSaidaPosicao ){
// m_trade.alterarOrdem(ORDER_TYPE_BUY_LIMIT,
// m_precoSaidaPosicao,
// HistoryDealGetDouble(deal_ticket,DEAL_VOLUME),
// deal_ticket,
// HistoryDealGetString(deal_ticket,DEAL_COMMENT) );
//}
////////////////// fim trecho versao 3 ///////////////
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 );
precoProfit = m_precoSaidaPosicao;
//}
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( m_deal_comment != "" && StringFind(m_deal_comment,"IN") < 0 ){
//fecharTudo("STOP_CLOSERAJADA");
// Print(":-( ", __FUNCTION__, " POSICAO ABERTA POR UMA RAJADA OU FECHAMENTO DE RAJADA. COMMENT: ", m_deal_comment );
//return false;
}
}
// 1. Colocando vendas e compras em 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...
////////////////// ini trecho versao 3 ///////////////
//price = HistoryDealGetDouble(deal_ticket,DEAL_PRICE) ; // obtendo o preco de uma ordem cuja ordem de fechamento jah foi colocada.
//if( price != m_precoSaidaPosicao ){
// m_trade.alterarOrdem(ORDER_TYPE_SELL_LIMIT,
// m_precoSaidaPosicao,
// HistoryDealGetDouble(deal_ticket,DEAL_VOLUME),
// deal_ticket,
// HistoryDealGetString(deal_ticket,DEAL_COMMENT) );
//}
////////////////// fim trecho versao 3 ///////////////
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 );
precoProfit = m_precoSaidaPosicao;
//}
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;
}
//------------------------------------------------------------------------------------------------------------
// 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.
//
// toCloseidDeal: ticket do trade que serah fechado.
// toCloseVol : volume do trade que serah fechado.
//------------------------------------------------------------------------------------------------------------
void doCloseFixo(ulong toCloseidDeal, double toCloseVol, ENUM_DEAL_TYPE sentidoRajada, double toClosePriceIn=0){
double precoProfit = 0;
if( sentidoRajada==DEAL_TYPE_BUY || estouComprado() ){
precoProfit = normalizar(toClosePriceIn + m_qtd_ticks_4_gain_ini*m_tick_size);
//if(precoProfit==0) precoProfit = m_ask;
if(precoProfit < m_bid || precoProfit==0){
precoProfit = m_ask;
}
if( precoProfit <= toClosePriceIn ) precoProfit = normalizar(toClosePriceIn + m_tick_size);
m_trade.setAsync(true);
m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT,precoProfit, toCloseVol, IntegerToString(toCloseidDeal) );
m_trade.setAsync(false);
return;
}else{
//if(precoProfit==0) precoProfit = m_bid;
if( sentidoRajada==DEAL_TYPE_SELL || estouVendido() ){
precoProfit = normalizar(toClosePriceIn - m_qtd_ticks_4_gain_ini*m_tick_size);
if(precoProfit > m_ask || precoProfit==0){
precoProfit = m_bid; //<TODO> VERIFIQUE E TESTE
}
if( precoProfit >= toClosePriceIn ) precoProfit = normalizar(toClosePriceIn - m_tick_size);
m_trade.setAsync(true);
m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT ,precoProfit, toCloseVol, IntegerToString(toCloseidDeal) );
m_trade.setAsync(false);
return;
}
}
Print(__FUNCTION__, ":-( FUI CHAMADO SEM A DIRECAO DA RAJADA!!!!! VERIFIQUE!!!!!!" );
}
//------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------
// 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.
// Esta versao eh feita para ser executada sempre que for processado um dealAdd no evento
// OnTradeTransaction da primeira ordem executada no fechamento da posicao.
//
// toCloseidDeal : ticket do trade que serah fechado.
// toCloseVol : volume do trade que serah fechado.
// sentidoRajada : sentido do trade de entrada que serah fechada por esta rajada
// toClosePriceIn: preco do trade de entrada que serah fechado por esta ordem
// toCloseOpenPos: se true, significa que o trade a ser fechado eh o primeiro da posicao.
//------------------------------------------------------------------------------------------------------------
void doCloseRajada4(ulong toCloseidDeal, double toCloseVol, ENUM_DEAL_TYPE sentidoRajada, double toClosePriceIn, bool toCloseOpenPos){
// para os casos em que a estrategia nao quer executar o fechamento das ordens de entrada.
if( m_qtd_ticks_4_gain_ini==0) return;
// Durante os stops, nao deveria haver chamadas a doCloseRajada4, uma vez que todas as ordens pendentes da posicao jah deveriam
// estar com suas respectivas ordens de fechamento emitidas.
// Aqui estamos testando uma forma do sistema se recuperar desta situacao...
//if( m_stop ){
// Print(":-( ",__FUNCTION__,"(",toCloseidDeal,",",toCloseVol,",",EnumToString(sentidoRajada),",",toClosePriceIn,",",toCloseOpenPos,")",
// " WARN: chamada durante STOP!! Transferindo execucao para doCloseRajada!! VERIFIQUE!!!!");
// doCloseRajada(0);
// return;
//}
// fechamento de posicao a xx ticks do breakeven...
double precoProfit = m_precoSaidaPosicao; //m_precoSaidaPosicao jah eh normalizado. Nao precisa normalizar.
// fechamento de posicao a xx ticks de cada ordem de entrada...
//if( !EA_FECHA_POSICAO_NO_BREAK_EVEN ){
// if( sentidoRajada==DEAL_TYPE_BUY || estouComprado() ){
// precoProfit = normalizar(toClosePriceIn+m_qtd_ticks_4_gain_ini);
// }else{
// precoProfit = normalizar(toClosePriceIn-m_qtd_ticks_4_gain_ini);
// }
//}
// Nas ordens posteriores a de abertura da posicao, o preco de saida da posicao jah deveria estar configurado.
// Se nao estiver, ainda assim serah corrigido a frente, mas logamos afim de verificar se estah sendo frequente.
if(m_precoSaidaPosicao==0 && !toCloseOpenPos && EA_FECHA_POSICAO_NO_BREAK_EVEN) Print(":-( ",__FUNCTION__,"(",toCloseidDeal,",",toCloseVol,",",EnumToString(sentidoRajada),",",toClosePriceIn,",",toCloseOpenPos,") WARN: m_precoSaidaPosicao==0!!!!! VERIFIQUE!!!!");
// volume da ordem de fechamento poderah ser maior que a de abertura em funcao de condicoes da operacao (veja uso da variavel vol mais adiante).
double vol = toCloseVol ;
double newVol = toCloseVol*qtdLotesStopParcial();
if( newVol>m_vol_lote_ini*qtdLotesStopParcial() ) newVol = m_vol_lote_ini*qtdLotesStopParcial();
if( sentidoRajada==DEAL_TYPE_BUY || estouComprado() ){
if(toCloseOpenPos || !EA_FECHA_POSICAO_NO_BREAK_EVEN) precoProfit = normalizar( toClosePriceIn + ( m_qtd_ticks_4_gain_ini+getTicksAddPorSelecaoAdversa() )*m_tick_size );
if(precoProfit == 0 ) precoProfit = m_ask_stplev ;// precoProfit nao informado, colocamos saida a 1 tick.
if(precoProfit < m_ask ) precoProfit = m_ask ;// precoProfit informado abaixo do preco de mercado, colocamos saida no valor de mercado.
if(precoProfit < toClosePriceIn) precoProfit = toClosePriceIn;
if(m_precoOrdem<m_ask_stplev) m_precoOrdem = m_ask_stplev;
//Print(":-| ",__FUNCTION__,"(",toCloseidDeal,",",toCloseVol,",",EnumToString(sentidoRajada),",",toClosePriceIn,",",toCloseOpenPos,")",
// " INFO: m_precoSaidaPosicao=",m_precoSaidaPosicao," m_ask=",m_ask," m_bid=",m_bid, " emitindo VENDA em:",precoProfit );
if( ( (lotesNaPosicaoHabilitamStopParcial() && m_posicaoVolumePend > newVol) ||
!podeEntrarComprando () ||
(lucroNaPosicaoHabilitaStopParcial () && m_posicaoVolumePend > newVol) )
)vol = newVol;
m_trade.setAsync(true);
m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT,precoProfit, vol, IntegerToString(toCloseidDeal) );
m_trade.cancelarOrdensComComentarioNumerico( m_symb_str, ORDER_TYPE_BUY_LIMIT );
m_trade.setAsync(false);
// se incrementou a volume, cancela a maior ordem de saida (mais antiga).
//if( vol > m_vol_lote_ini ) m_trade.cancelarMaiorOrdemDeVendaComComentarioNumerico();
return;
}else{
if( sentidoRajada==DEAL_TYPE_SELL || estouVendido() ){
if(toCloseOpenPos || !EA_FECHA_POSICAO_NO_BREAK_EVEN) precoProfit = normalizar( toClosePriceIn - ( m_qtd_ticks_4_gain_ini+getTicksAddPorSelecaoAdversa() )*m_tick_size );
if(precoProfit ==0 ) precoProfit = m_bid_stplev ;// precoProfit nao informado, colocamos saida a 1 tick.
if(precoProfit > m_bid ) precoProfit = m_bid ;// precoProfit informado acima do preco de mercado, colocamos saida no valor de mercado.
if(precoProfit > toClosePriceIn) precoProfit = toClosePriceIn;
//Print(":-| ",__FUNCTION__,"(",toCloseidDeal,",",toCloseVol,",",EnumToString(sentidoRajada),",",toClosePriceIn,",",toCloseOpenPos,")",
// " INFO: m_precoSaidaPosicao=",m_precoSaidaPosicao," m_ask=",m_ask," m_bid=",m_bid, " emitindo COMPRA em:",precoProfit );
if( ( ( lotesNaPosicaoHabilitamStopParcial() && m_posicaoVolumePend > newVol ) ||
!podeEntrarVendendo () ||
( lucroNaPosicaoHabilitaStopParcial () && m_posicaoVolumePend > newVol ) )
)vol = newVol;
m_trade.setAsync(true);
m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT ,precoProfit, vol, IntegerToString(toCloseidDeal) );
m_trade.cancelarOrdensComComentarioNumerico( m_symb_str, ORDER_TYPE_SELL_LIMIT );
m_trade.setAsync(false);
// se incrementou a volume, cancela a menor ordem de saida (mais antiga).
//if( vol > m_vol_lote_ini ) m_trade.cancelarMenorOrdemDeCompraComComentarioNumerico();
return;
}
}
Print(":-( ",__FUNCTION__,"(",toCloseidDeal,",",vol,",",EnumToString(sentidoRajada),",",toClosePriceIn,",",toCloseOpenPos,") ERROR: DIRECAO DA RAJADA INVALIDA!!!!! VERIFIQUE!!!!!!");
}
//------------------------------------------------------------------------------------------------------------
int qtdLotesStopParcial(){
if( EA_STOP_PARCIAL_A_PARTIR_DE_X_LOTES > 0 ) return (int)(1 + m_posicaoLotsPend/EA_STOP_PARCIAL_A_PARTIR_DE_X_LOTES);
return 1;
}
bool lotesNaPosicaoHabilitamStopParcial(){
return ( EA_STOP_PARCIAL_A_PARTIR_DE_X_LOTES > 0 && EA_STOP_PARCIAL_A_PARTIR_DE_X_LOTES < m_posicaoLotsPend );
}
bool lucroNaPosicaoHabilitaStopParcial(){
return ( EA_STOP_PARCIAL_A_PARTIR_DE_X_GANHO > 0 && EA_STOP_PARCIAL_A_PARTIR_DE_X_GANHO < m_lucroPosicao );
}
string getStrComment(){
// if( EA_ACAO_POSICAO == HFT_ARBITRAGEM_PAR ){
// return
// " a" +DoubleToString (m_par.getRatioDP()*10 ,0) + // ratio instantaneo entre o par de ativo
// " b" +DoubleToString (m_est.getVolTradeLiqPorSeg(),0) + // Velocidade do volume por segundo.
// " c" +DoubleToString (m_est.getAceVolLiq() ,0) + // Aceleracao da velocidade do volume por segundo ao quadrado.
// " d" +DoubleToString (m_est.getKyleLambda() *10000000,0) + // risco de compra (Buy).
// " e" +DoubleToString (m_est.getKyleLambdaHLTrade()*10000000,0) ; // risco de venda (Sell).
// }
return
" a" +DoubleToString (m_est.getInclinacaoHLTrade(),0) + // velocidade do Preco por segundo.
" b" +DoubleToString (m_est.getVolTradeLiqPorSeg(),0) + // Velocidade do volume por segundo.
" c" +DoubleToString (m_est.getAceVolLiq() ,0) + // Aceleracao da velocidade do volume por segundo ao quadrado.
" d" +DoubleToString (m_est.getKyleLambda() *10000000,0) + // risco de compra (Buy).
" e" +DoubleToString (m_est.getKyleLambdaHLTrade()*10000000,0) ; // risco de venda (Sell).
// " a" +DoubleToString (m_est.getInclinacaoHLTrade(),0) + // velocidade do preco, calculada como a inclinacao da reta HighLow de m_est divida pela janela de acumulacao estatistica.
// " b" +DoubleToString (m_volTradePorSegLiq ,0) + // banda superior da bolinger.
// " c" +DoubleToString (m_volTradePorSegBuy ,0) + // banda media da bolinger.
// " d" +DoubleToString (m_volTradePorSegSel ,0) + // desvio padrao da bolinger em pontos.
// " e" +IntegerToString(EA_EST_QTD_SEGUNDOS ) ; // banda inferior da bolinger.
}
//-----------------------------------------------------------------------------------------------------------------------------
// HFT_OPERAR_VOLUME_CANAL
//
// Entrada:
// - A cada tick.
// - Compra se preco estah na regiao superior do canal.
// - Vende se preco estah na regiao inferior do canal.
//
// Saida:
// - ver
// INS a34 b3 c34 d30 e300 (23 caracteres)
//-----------------------------------------------------------------------------------------------------------------------------
double m_precoOrdem = 0.0;
void abrirPosicaoHFTVolumeCanal(){
if( m_ask==0.0 || m_bid==0.0 ){
Print(__FUNCTION__," Erro abertura posicao: m_ask=",m_ask, " m_bid=",m_bid );
// se tinha ordem pendente, cancela
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb );
m_trade.cancelarOrdensComentadas(m_symb_str,m_strRajada);
m_aguardar_para_abrir_posicao = EA_EST_QTD_SEGUNDOS*1000; // aguarda ateh poder abrir nova posicao
return;
}
// tendencia de alta...
if( m_est.getVolTradeLiqPorSeg() > 0 &&
m_est.getAceVolLiq() > 0 &&
m_est.getInclinacaoHLTrade() > 0 && m_canal.regiaoSuperior() ){
//if( m_canal.regiaoSuperior() ){
//if( m_canal.regiaoSuperior() && m_riscoCompra < EA_RISCO_MAX_POSICAO ){
//if( m_riscoCompra < EA_MAIOR_RISCO_ENTRADA ){
// providenciando a ordem de entrada na posicao...
m_precoOrdem = m_bid;
if( !m_trade.tenhoOrdemLimitadaDeCompra( m_precoOrdem, m_symb_str, m_apmb, m_vol_lote_ini , true, m_shift_in_points, m_apmb_buy+getStrComment() ) ){
if(m_precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_apmb_buy+getStrComment() );
}
// cancelando ordens de venda porventura colocadas...
if( ! m_trade.cancelarOrdensComentadasDeVenda(m_symb_str ,m_apmb ) ) return; // se teve algum problema cancelando ordens, nao segue criando outras
if( ! m_trade.cancelarOrdensComentadasDeVenda(m_symb_str ,m_strRajada) ) return; // se teve algum problema cancelando ordens, nao segue criando outras
return;
}else{
// tendencia de baixa...
if( m_est.getVolTradeLiqPorSeg() < 0 &&
m_est.getAceVolLiq() < 0 &&
m_est.getInclinacaoHLTrade() < 0 && m_canal.regiaoInferior() ){
//if( m_canal.regiaoInferior() ){
//if( m_canal.regiaoInferior() && m_riscoVenda < EA_RISCO_MAX_POSICAO ){
//if( m_riscoVenda < EA_MAIOR_RISCO_ENTRADA ){
// providenciando a ordem de entrada na posicao...
m_precoOrdem = m_ask;
if( !m_trade.tenhoOrdemLimitadaDeVenda( m_precoOrdem, m_symb_str, m_apmb, m_vol_lote_ini , true, m_shift_in_points, m_apmb_sel+getStrComment() ) ){
if(m_precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_apmb_sel+getStrComment() );
}
// cancelando ordens de compra porventura colocadas...
if( ! m_trade.cancelarOrdensComentadasDeCompra(m_symb_str, m_apmb ) ) return ; // se teve algum problema cancelando ordens, nao segue criando outras
if( ! m_trade.cancelarOrdensComentadasDeCompra(m_symb_str, m_strRajada) ) return ; // se teve algum problema cancelando ordens, nao segue criando outras
return;
}
}
// se chegou aqui eh porque nao ha condicao para abrir posicao. Entao cancela pedidos de entrada pendentes.
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb );
m_trade.cancelarOrdensComentadas(m_symb_str,m_strRajada);
}
//-----------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------
// Inicia ordem de abertura a pelo menos XX ticks do preco atual. Visa ter prioridade na fila do book.
// HFT_FORMADOR_DE_MERCADO
//---------------------------------------------------------------------------------------------------------
int getTicksAddPorSelecaoAdversa(){ return (int)ceil(m_posicaoLotsPend*EA_AUMENTO_LAG_POR_LOTE_PENDENTE); }// truncando pra cima
void abrirPosicaoHFTPrioridadeNoBook(){
// cancelando ordens de saida que porventura ficaram mal posicionadas...
if( estouSemPosicao() ){ m_trade.cancelarOrdensComComentarioNumerico(m_symb_str );}
if( estouVendido () ){ m_trade.cancelarOrdensComComentarioNumerico(m_symb_str,ORDER_TYPE_SELL_LIMIT);}
if( estouComprado () ){ m_trade.cancelarOrdensComComentarioNumerico(m_symb_str,ORDER_TYPE_BUY_LIMIT );}
if( m_ask == 0.0 || m_bid == 0.0 ){
Print(__FUNCTION__," Erro abertura posicao :m_ask=",m_ask, " m_bid=",m_bid );
//m_aguardar_para_abrir_posicao = EA_EST_QTD_SEGUNDOS*1000; // aguarda ateh poder abrir nova posicao
return;
}
if( EA_DECISAO_ENTRADA_COMPRA_VENDA_AUTOMATICA){
//if( m_canal.getRegiaoUltExtremoTocado() > 0 ){ m_tipo_entrada_permitida = ENTRADA_BUY; }else{ m_tipo_entrada_permitida = ENTRADA_SELL; }
if( m_canal.getCoefLinear()>0 ){ m_tipo_entrada_permitida = ENTRADA_BUY; }else{ m_tipo_entrada_permitida = ENTRADA_SELL; }
}
// a cada contrato acumulado no estoque, aumenta xx unidades no lag entre novas ordens...
int lag_rajada = m_lag_rajada;
if( estouPosicionado() ) lag_rajada = m_lag_rajada + getTicksAddPorSelecaoAdversa();
// quando o volume pendente da posicao for maior que 2 e estiver posicionado, dobramos o volume das ordens
// de saida quando o valor da posicao estiver acima do breakeven. Isto visa diminuir o risco.
double vol = m_vol_lote_ini;
if( estouComprado() && ( lotesNaPosicaoHabilitamStopParcial() ||
!podeEntrarComprando () ||
(lucroNaPosicaoHabilitaStopParcial() && m_posicaoVolumePend > vol) )
)vol = vol*qtdLotesStopParcial();
//INCLUINDO ORDENS DE VENDA.
double dist_min_entrada_book;
// possibilidade de entrar mais rapido na saida da posicao
if( estouComprado() ){
dist_min_entrada_book = m_dist_min_in_book_out_pos;
}else{
if( devoEntrarVendendo() ){
dist_min_entrada_book = EA_DIST_MIN_IN_BOOK_IN_POS_OBRIG;
}else{
dist_min_entrada_book = m_dist_min_in_book_in_pos;
}
if( estouVendido() ) dist_min_entrada_book = m_dist_min_in_book_in_pos + getTicksAddPorSelecaoAdversa();
}
//m_precoOrdem = normalizar( m_bid + dist_min_entrada_book*m_tick_size );
m_precoOrdem = normalizar( m_ask + dist_min_entrada_book*m_tick_size );
if(m_precoOrdem<m_ask_stplev) m_precoOrdem = m_ask_stplev;
//if( m_qtdPosicoes>0|| ( estouSemPosicao() && podeEntrarVendendo() ) ){
if( estouVendido() || ( estouSemPosicao() && podeEntrarVendendo() ) ){ // testando a entrada em sentido unico quando estah posicionado
//if(m_precoOrdem!=0) m_trade.preencherOrdensLimitadasDeVendaAcimaComLag (m_precoOrdem,EA_TAMANHO_RAJADA,m_symb_str,m_apmb_sel,vol,m_tick_size,lag_rajada);
if(m_precoOrdem!=0) m_trade.preencherOrdensLimitadasDeVendaAcimaComLag2(m_precoOrdem,EA_TAMANHO_RAJADA,m_symb_str,m_apmb_sel,vol,m_tick_size,lag_rajada);
}else{
m_trade.cancelarOrdensComentadasDeVenda(m_symb_str ,m_apmb_sel);
}
vol = m_vol_lote_ini;
if( estouVendido() && ( lotesNaPosicaoHabilitamStopParcial() ||
!podeEntrarVendendo () ||
(lucroNaPosicaoHabilitaStopParcial () && m_posicaoVolumePend > vol) )
) vol = vol*qtdLotesStopParcial();
// INCLUINDO ORDENS DE COMPRA
// possibilidade de entrar mais rapido na saida da posicao
if( estouVendido() ){
dist_min_entrada_book = m_dist_min_in_book_out_pos;
}else{
if( devoEntrarComprando() ){
dist_min_entrada_book = EA_DIST_MIN_IN_BOOK_IN_POS_OBRIG;
}else{
dist_min_entrada_book = m_dist_min_in_book_in_pos ;
}
if( estouComprado() ) dist_min_entrada_book = m_dist_min_in_book_in_pos + getTicksAddPorSelecaoAdversa();
}
//m_precoOrdem = normalizar( m_ask - dist_min_entrada_book*m_tick_size );
m_precoOrdem = normalizar( m_bid - dist_min_entrada_book*m_tick_size );
if(m_precoOrdem>m_bid_stplev) m_precoOrdem = m_bid_stplev;
//if( m_qtdPosicoes>0 || ( estouSemPosicao() && podeEntrarComprando() ) ){
if( estouComprado() || ( estouSemPosicao() && podeEntrarComprando() ) ){ // testando a entrada em sentido unico quando estah posicionado
//if(m_precoOrdem!=0) m_trade.preencherOrdensLimitadasDeCompraAbaixoComLag (m_precoOrdem,EA_TAMANHO_RAJADA,m_symb_str,m_apmb_buy,vol,m_tick_size,lag_rajada);
if(m_precoOrdem!=0) m_trade.preencherOrdensLimitadasDeCompraAbaixoComLag2(m_precoOrdem,EA_TAMANHO_RAJADA,m_symb_str,m_apmb_buy,vol,m_tick_size,lag_rajada);
}else{
m_trade.cancelarOrdensComentadasDeCompra(m_symb_str ,m_apmb_buy);
}
}
//---------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------
// Inicia ordem de abertura a pelo menos XX desvios padrao na correlacao entre paraes de ativos.
// HFT_ARBITRAGEM_PAR
//---------------------------------------------------------------------------------------------------------
/*
void abrirPosicaoHFTarbitragemPar(){
if( m_ask==0.0 || m_bid==0.0 ){
Print(__FUNCTION__," Erro abertura posicao :m_ask=",m_ask, " m_bid=",m_bid );
// se tinha ordem pendente, cancela
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb );
m_trade.cancelarOrdensComentadas(m_symb_str,m_strRajada);
m_aguardar_para_abrir_posicao = EA_EST_QTD_SEGUNDOS*1000; // aguarda ateh poder abrir nova posicao
return;
}
// ativo estah barato em ralacao ao seu par...
if( m_par.getRatioDP() <= -EA_QTD_DP_FIRE_ORDEM ){
// providenciando a ordem de entrada na posicao...
m_precoOrdem = m_bid;
if( !m_trade.tenhoOrdemLimitadaDeCompra( m_precoOrdem, m_symb_str, m_apmb, m_vol_lote_ini , true, m_shift_in_points, m_apmb_buy+getStrComment() ) ){
if(m_precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_apmb_buy+getStrComment() );
}
// cancelando ordens de venda porventura colocadas...
if( ! m_trade.cancelarOrdensComentadasDeVenda(m_symb_str ,m_apmb ) ) return; // se teve algum problema cancelando ordens, nao segue criando outras
if( ! m_trade.cancelarOrdensComentadasDeVenda(m_symb_str ,m_strRajada) ) return; // se teve algum problema cancelando ordens, nao segue criando outras
return;
}else{
// ativo estah caro em relacao ao seu par...
if( m_par.getRatioDP() >= EA_QTD_DP_FIRE_ORDEM ){
// providenciando a ordem de entrada na posicao...
m_precoOrdem = m_ask;
if( !m_trade.tenhoOrdemLimitadaDeVenda( m_precoOrdem, m_symb_str, m_apmb, m_vol_lote_ini , true, m_shift_in_points, m_apmb_sel+getStrComment() ) ){
if(m_precoOrdem!=0) m_trade.enviarOrdemPendente(ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_apmb_sel+getStrComment() );
}
// cancelando ordens de compra porventura colocadas...
if( ! m_trade.cancelarOrdensComentadasDeCompra(m_symb_str, m_apmb ) ) return ; // se teve algum problema cancelando ordens, nao segue criando outras
if( ! m_trade.cancelarOrdensComentadasDeCompra(m_symb_str, m_strRajada) ) return ; // se teve algum problema cancelando ordens, nao segue criando outras
return;
}
}
// se chegou aqui eh porque nao ha condicao para abrir posicao. Entao cancela pedidos de entrada pendentes.
m_trade.cancelarOrdensComentadas(m_symb_str,m_apmb );
m_trade.cancelarOrdensComentadas(m_symb_str,m_strRajada);
}
*/
//---------------------------------------------------------------------------------------------------------
//
// A cada mudanda de periodo faz:
// Posicao vendido : Coloca ordem limitada de venda no preco maximo do periodo anterior ou no preco atual (o maior)
// Posicao comprado: Coloca ordem limitada de compra no preco minimo do periodo anterior ou no preco atual (o menor)
//
//int m_min_analisado = 0;
datetime m_time_analisado = TimeCurrent();
MqlRates m_rates1_tmp[1];
void preencherFilaOrdens(){
//m_qtd_exec_filaordens++;
// obtendo a barra anterior...
int copiados = CopyRates(m_symb_str,_Period,1,1,m_rates1_tmp);
if( copiados <= 0 ){
Print( ":-( ", __FUNCTION__, ": Erro CopyRates():", GetLastError(), " copiados:",copiados);
return;
}
// se jah analisou, volta e aguarda a proximo periodo
if( m_rates1_tmp[0].time == m_time_analisado ) return;
ArrayPrint(m_rates1_tmp);
//if( m_date_atu.min == m_min_analisado || m_date_atu.sec < 2 ) return;
Print( "Analisando minuto: ", TimeCurrent(), "..." );
// obtendo a barra anterior...
//int copiados = CopyRates(m_symb_str,_Period,1,1,m_rates1_tmp);
//Print(":-| Copiados: ", copiados );
//ArrayPrint(m_rates1_tmp);
//double precoOrdem = 0;
double distancia = (EA_DISTAN_DEMAIS_ORDENS_RAJ*m_tick_size);
double shift = 0;
// Posicao vendido : Coloca ordem limitada de venda no preco maximo do periodo anterior ou no preco atual (o maior)
if( estouVendido() ){
// // uma ordem no preco atual...
// m_precoOrdem = normalizar( m_ask + distancia );
////if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
// if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
double pshift = m_ask+distancia;
double dlow = 0;
double dhigh = m_rates1_tmp[0].high - m_rates1_tmp[0].low;
double dopen = m_rates1_tmp[0].open - m_rates1_tmp[0].low;
double dclose = m_rates1_tmp[0].close - m_rates1_tmp[0].low;
double plow = pshift + dlow ;
double phigh = pshift + dhigh ;
double popen = pshift + dopen ;
double pclose = pshift + dclose;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// testando colocacao uma ordem rajada pelo valor maximo e com volume EA_INCREM_VOL_RAJ (EX: 4)
////////////////////////////////////////////////////////////////////////////////////////////////////////////
m_precoOrdem = normalizar( phigh );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini*EA_INCREM_VOL_RAJ, m_strRajada+getStrComment() );
m_time_analisado = m_rates1_tmp[0].time;
return;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// outra ordem na maxima da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].high + distancia );
m_precoOrdem = normalizar( phigh );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
////////////////////////////////////////////////////////////////////////
// NOVOS EM TESTE (saiu o preco atual)
////////////////////////////////////////////////////////////////////////
// outra ordem na minima da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].low + distancia );
m_precoOrdem = normalizar( plow );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
// outra ordem na abertura da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].open + distancia );
m_precoOrdem = normalizar( popen );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
// outra ordem no fechamento da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].close + distancia );
m_precoOrdem = normalizar( pclose );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_SELL_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
////////////////////////////////////////////////////////////////////////
m_time_analisado = m_rates1_tmp[0].time;
}
// Posicao comprado: Coloca ordem limitada de compra no preco minimo do periodo anterior ou no preco atual (o menor)
if( estouComprado() ){
// // uma ordem no preco atual...
// m_precoOrdem = normalizar( m_bid - distancia );
// //if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
// if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
double pshift = m_bid-distancia;
double dhigh = 0 ;
double dlow = m_rates1_tmp[0].high - m_rates1_tmp[0].low;
double dopen = m_rates1_tmp[0].open - m_rates1_tmp[0].low;
double dclose = m_rates1_tmp[0].close - m_rates1_tmp[0].low;
double phigh = pshift - dhigh;
double plow = pshift - dlow ;
double popen = pshift - dopen ;
double pclose = pshift - dclose;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// testando colocacao uma ordem rajada pelo valor minimo e com volume EA_INCREM_VOL_RAJ (ex:4)
////////////////////////////////////////////////////////////////////////////////////////////////////////////
m_precoOrdem = normalizar( plow );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini*EA_INCREM_VOL_RAJ, m_strRajada+getStrComment() );
m_time_analisado = m_rates1_tmp[0].time;
return;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// outra ordem no minimo da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].low - distancia );
m_precoOrdem = normalizar( plow );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
////////////////////////////////////////////////////////////////////////
// NOVOS EM TESTE
////////////////////////////////////////////////////////////////////////
// outra ordem na maxima da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].high - distancia );
m_precoOrdem = normalizar( phigh );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
// outra ordem na abertura da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].open - distancia );
m_precoOrdem = normalizar( popen );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
// outra ordem no fechamento da barra anterior...
//m_precoOrdem = normalizar( m_rates1_tmp[0].close - distancia );
m_precoOrdem = normalizar( pclose );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendente( ORDER_TYPE_BUY_LIMIT , m_precoOrdem, m_vol_lote_ini, m_strRajada+getStrComment() );
m_time_analisado = m_rates1_tmp[0].time;
}
//doCloseRajada(m_passo_rajada, m_vol_lote_raj, m_qtd_ticks_4_gain_ini);
//m_trade.alterarValorDeOrdensNumericasPara(m_symb_str,m_precoSaidaPosicao,m_precoPosicao);
}
void preencherFilaOrdensFixa(){
//m_qtd_exec_filaordens++;
//double precoOrdem = 0;
double passoRajada = (m_raj_unica_distancia_demais_ordens*m_tick_size);
double passoRajadaPrimOrdem = (m_raj_unica_distancia_prim_ordem *m_tick_size);
double shift = 0;
// Posicao vendido : Coloca rajada de ordens limitadas de venda
if( estouVendido() ){
m_precoOrdem = normalizar( m_precoPosicao+passoRajadaPrimOrdem );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
m_trade.setAsync(true);
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendenteRajada( ORDER_TYPE_SELL_LIMIT , // tipo de ordens
m_precoOrdem , // preco da primeira ordem
m_vol_lote_raj , // volume da primeira ordem da rajada
m_strRajada+getStrComment() , // comentario da ordens
passoRajada , // distancia entre ordens da rajada
EA_INCREM_VOL_RAJ , // multiplica pelo volume a cada ordem da rajada
EA_INCREM_DISTAN_DEMAIS_ORDENS_RAJ, // multiplica pela distancia a cada ordem da rajada
EA_TAMANHO_RAJADA , // quantidade de ordens da rajada
EA_STOP_NA_RAJADA , // se true, a ultima ordem da rajada eh um stop loss
EA_PORC_STOP_NA_RAJADA
// testando ordens a favor da posicao...
//,m_precoSaidaPosicao
//,m_tick_size
);//
m_trade.setAsync(false);
//m_time_analisado = m_rates1_tmp[0].time;
return;
}
// Posicao comprado: Coloca rajadas de ordens limitadas de compra
if( estouComprado() ){
m_precoOrdem = normalizar( m_precoPosicao-passoRajadaPrimOrdem );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
m_trade.setAsync(true);
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendenteRajada( ORDER_TYPE_BUY_LIMIT , // tipo de ordens
m_precoOrdem , // preco da primeira ordem
m_vol_lote_raj , // volume da primeira ordem da rajada
m_strRajada+getStrComment() , // comentario da ordens
-passoRajada , // distancia entre ordens da rajada
EA_INCREM_VOL_RAJ , // multiplica pelo volume a cada ordem da rajada
EA_INCREM_DISTAN_DEMAIS_ORDENS_RAJ, // multiplica pela distancia a cada ordem da rajada
EA_TAMANHO_RAJADA , // quantidade de ordens da rajada
EA_STOP_NA_RAJADA , // se true, a ultima ordem da rajada eh um stop loss
EA_PORC_STOP_NA_RAJADA
// testando ordens a favor da posicao...
//,m_precoSaidaPosicao
//,m_tick_size
);//
m_trade.setAsync(false);
//m_time_analisado = m_rates1_tmp[0].time;
return;
}
}
bool estouVendido (ENUM_DEAL_TYPE toCloseTypeDeal){ return toCloseTypeDeal==DEAL_TYPE_SELL; }
bool estouComprado(ENUM_DEAL_TYPE toCloseTypeDeal){ return toCloseTypeDeal==DEAL_TYPE_BUY ; }
void preencherFilaOrdensFixaAssincrona(ENUM_DEAL_TYPE toCloseTypeDeal, double toClosePriceIn){
//double precoOrdem = 0;
double passoRajada = (m_raj_unica_distancia_demais_ordens*m_tick_size);
double passoRajadaPrimOrdem = (m_raj_unica_distancia_prim_ordem *m_tick_size);
double shift = 0;
// Posicao vendido : Coloca rajada de ordens limitadas de venda
if( estouVendido(toCloseTypeDeal) ){
m_precoOrdem = normalizar( toClosePriceIn+passoRajadaPrimOrdem );
if( m_precoOrdem < m_ask ){ m_precoOrdem = m_ask; }
m_trade.setAsync(true);
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendenteRajada( ORDER_TYPE_SELL_LIMIT , // tipo de ordens
m_precoOrdem , // preco da primeira ordem
m_vol_lote_raj , // volume da primeira ordem da rajada
m_strRajada+getStrComment() , // comentario da ordens
passoRajada , // distancia entre ordens da rajada
EA_INCREM_VOL_RAJ , // multiplica pelo volume a cada ordem da rajada
EA_INCREM_DISTAN_DEMAIS_ORDENS_RAJ, // multiplica pela distancia a cada ordem da rajada
EA_TAMANHO_RAJADA , // quantidade de ordens da rajada
EA_STOP_NA_RAJADA , // se true, a ultima ordem da rajada eh um stop loss
EA_PORC_STOP_NA_RAJADA
// testando ordens a favor da posicao...
//,m_precoSaidaPosicao
//,m_tick_size
);//
m_trade.setAsync(false);
//m_time_analisado = m_rates1_tmp[0].time;
return;
}
// Posicao comprado: Coloca rajadas de ordens limitadas de compra
if( estouComprado(toCloseTypeDeal) ){
m_precoOrdem = normalizar( toClosePriceIn-passoRajadaPrimOrdem );
if( m_precoOrdem > m_bid ){ m_precoOrdem = m_bid; }
m_trade.setAsync(true);
if( m_precoOrdem != 0 )m_trade.enviarOrdemPendenteRajada( ORDER_TYPE_BUY_LIMIT , // tipo de ordens
m_precoOrdem , // preco da primeira ordem
m_vol_lote_raj , // volume da primeira ordem da rajada
m_strRajada+getStrComment() , // comentario da ordens
-passoRajada , // distancia entre ordens da rajada
EA_INCREM_VOL_RAJ , // multiplica pelo volume a cada ordem da rajada
EA_INCREM_DISTAN_DEMAIS_ORDENS_RAJ, // multiplica pela distancia a cada ordem da rajada
EA_TAMANHO_RAJADA , // quantidade de ordens da rajada
EA_STOP_NA_RAJADA , // se true, a ultima ordem da rajada eh um stop loss
EA_PORC_STOP_NA_RAJADA
// testando ordens a favor da posicao...
//,m_precoSaidaPosicao
//,m_tick_size
);//
m_trade.setAsync(false);
//m_time_analisado = m_rates1_tmp[0].time;
return;
}
}
//bool taxaVolPermiteAbrirPosicao (){return EA_VOLSEG_MAX_ENTRADA_POSIC==0 || m_volTradePorSeg <= EA_VOLSEG_MAX_ENTRADA_POSIC ;}
//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 volat4sPermiteAbrirPosicao(){ return m_volatilidade_4_seg <= EA_VOLAT4S_MIN || EA_VOLAT4S_MIN == 0; }
bool spreadMaiorQueMaximoPermitido(){ return m_spread > m_spread_maximo_in_points && m_spread_maximo_in_points != 0; }
bool m_fastClose = true;
bool m_traillingStop = false;
void setFastClose() { m_fastClose=true ; m_traillingStop=false;}
void setTraillingStop(){ m_fastClose=false; m_traillingStop=true ;}
double normalizar(double preco){ return m_symb.NormalizePrice(preco); }
//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 podeEntrarComprando(){ return m_tipo_entrada_permitida==ENTRADA_BUY || m_tipo_entrada_permitida==ENTRADA_TODAS; }
bool podeEntrarVendendo (){ return m_tipo_entrada_permitida==ENTRADA_SELL || m_tipo_entrada_permitida==ENTRADA_TODAS; }
bool devoEntrarComprando(){ return m_tipo_entrada_permitida==ENTRADA_BUY ; }
bool devoEntrarVendendo (){ return m_tipo_entrada_permitida==ENTRADA_SELL; }
bool estouComprado (){ return m_comprado; }
bool estouVendido (){ return m_vendido ; }
bool estouSemPosicao (){ return !estouComprado() && !estouVendido() ; }
bool estouPosicionado(){ return estouComprado() || estouVendido() ; }
string status(){
string obs =
//" preco=" + m_tick.ask +
//" bid=" + m_tick.bid +
//" spread=" + (m_tick.ask-m_tick.bid) +
" last=" + DoubleToString( m_tick_est.last )
//" time=" + m_tick.time
;
return obs;
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
Print(m_name,":-| Expert ", m_name, " Iniciando metodo OnDeinit..." );
Print(__FUNCTION__," :-| PROFIT BRUTO :",m_trade_estatistica.getProfitDia () );
Print(__FUNCTION__," :-| TARIFAS :",m_trade_estatistica.getTarifaDia () );
Print(__FUNCTION__," :-| PROFIT LIQUIDO:",m_trade_estatistica.getProfitDiaLiquido() );
//BBDeleFromChart(); Print(m_name,":-| Expert ", m_name, " Indicador GMMA retirado do grafico:", GetLastError() );
//BBRelease(); Print(m_name,":-| Expert ", m_name, " Manipuladores GMMA liberados:", GetLastError() );
//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." );
delete(m_est); Print(__FUNCTION__,":-| m_est deletado:", GetLastError() );
//delete(m_par); Print(__FUNCTION__,":-| m_par deletado:", GetLastError() );
//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() );
if( EA_SHOW_CONTROL_PANEL ) { m_cp.Destroy(reason); Print(m_name,":-| Expert ", m_name, " Painel de controle destruido." ); }
Comment(""); Print(m_name," :-| Expert ", m_name, " Comentarios na tela apagados." );
Print(m_name," :-) Expert ", m_name, " OnDeinit finalizado!" );
return;
}
double OnTester(){
m_trade_estatistica.print_posicoes(0, m_time_in_seconds_atu);
return m_trade_estatistica.getProfitDiaLiquido(); // profit do dia no relatorio de performance
}
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); }
}
string strFuncNormal(string str){ return ":-| " + str + " "; }
void printHeartBit(){ if(m_date_ant.min != m_date_atu.min) Print(":-| HeartBit! m_stop:", m_stop); }
//----------------------------------------------------------------------------------------------------
//
// 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;
bool m_eh_hora_de_fechar_posicao = 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(){
//m_qtd_exec_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...
m_eh_hora_de_fechar_posicao = eh_hora_de_fechar_posicao (); // verificando se as posicoes devem ser fechadas...
//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();
verificarMudancaDeSegundo();
//calcularDirecaoVelocidadeDoVolume(); <TODO>: verificar se este metodo pode ser melhor que o uso estatistica2
//calcCoefEntrelacamentoMedio();
//calcOpenMaxMinDia();
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);
if (EA_SHOW_CONTROL_PANEL) {
m_trade_estatistica.refresh(m_time_in_seconds_ini_day, m_time_in_seconds_atu);
refreshControlPanel();
}
}
//----------------------------------------------------------------------------------------------------
// demarcacao da mudanca de segundo.
bool m_mudou_segundo = false;
void verificarMudancaDeSegundo(){
if(m_date_ant.sec != m_date_atu.sec){m_mudou_segundo=true; return;}
m_mudou_segundo = false;
}
// se a velocidade liquida do volume está aumentando, então a direção eh positiva e espera-se que o preco suba.
// se a velocidade liquida do volume está dimunuindo, então a direção eh negativa e espera-se que o preco caia.
// esta medida eh verifica a cada xx milisegundos definidos no timer do programa.
double m_direcaoVelVolTrade = 0;
double m_volTradePorSegLiqAnt = 0;
void calcularDirecaoVelocidadeDoVolume(){
if( !m_mudou_segundo ) return;
m_direcaoVelVolTrade = m_volTradePorSegLiq - m_volTradePorSegLiqAnt;
m_volTradePorSegLiqAnt = m_volTradePorSegLiq;
calcularDirecaoMediaVelocidadeTrade();
}
//----------------------------------------------------------------------------------------------------
// 1. Mantem a velocidade media da direcao do trade.
//----------------------------------------------------------------------------------------------------
//int m_vet_direcao_vel_trade_ind = 0;
//double m_vet_direcao_vel_trade_tot = 0;
//int m_vet_direcao_vel_trade_len = 60;
//double m_vet_direcao_vel_trade[60] ;
double m_direcaoVelVolTradeMed = 0;
osc_media m_Cmedia_direcaoVelocidadeTradeMedia;
//----------------------------------------------------------------------------------------------------
void calcularDirecaoMediaVelocidadeTrade(){
// m_vet_direcao_vel_trade_tot += m_direcaoVelVolTrade; // adicionando o valor atual a media
// m_vet_direcao_vel_trade_tot -= m_vet_direcao_vel_trade[m_vet_direcao_vel_trade_ind]; // retirando o que estava na posicao atual do vetor
// m_vet_direcao_vel_trade[m_vet_direcao_vel_trade_ind] = m_direcaoVelVolTrade ; // e colocando o ultimo valor calculado
// if( ++m_vet_direcao_vel_trade_ind == m_vet_direcao_vel_trade_len ){ m_vet_direcao_vel_trade_ind=0; }// atualizando o indice
// m_direcaoVelVolTradeMed = m_vet_direcao_vel_trade_tot/(double)m_vet_direcao_vel_trade_len;
m_direcaoVelVolTradeMed = m_Cmedia_direcaoVelocidadeTradeMedia.add(m_direcaoVelVolTrade);
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
// 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 - (int)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 < EA_HR_INI_OPERACAO ) { return false; } // operacao antes de 9:00 distorce os testes.
if(m_date_atu.hour >= EA_HR_FIM_OPERACAO + 1 ) { return false; } // operacao apos 18:00 distorce os testes.
if(m_date_atu.hour == EA_HR_INI_OPERACAO && m_date_atu.min < EA_MI_INI_OPERACAO ) { return false; } // operacao antes de 9:10 distorce os testes.
if(m_date_atu.hour == EA_HR_FIM_OPERACAO && m_date_atu.min > EA_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;
}
// a partir deste horario fecha todas as posicoes abertas.
bool eh_hora_de_fechar_posicao(){
if( m_date_atu.hour > EA_HR_FECHAR_POSICAO ){ return true; }
if( m_date_atu.hour >= EA_HR_FECHAR_POSICAO &&
m_date_atu.min >= EA_MI_FECHAR_POSICAO ){ return true; }
return false;
}
//----------------------------------------------------------------------------------------------------
// 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_MILISEG_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){
// servico de calculo de runs...
//if(id==SVC_RUN+CHARTEVENT_CUSTOM){ m_strRun = "\n\n" + sparam; }
// painel de controle...
if( EA_SHOW_CONTROL_PANEL ) m_cp.ChartEvent(id,lparam,dparam,sparam);
//--- uma tecla foi pressionada
if(id==CHARTEVENT_KEYDOWN) processarAcionamentoDeTecla( (int)lparam );
}
#define KEY_R 82
void processarAcionamentoDeTecla(int tecla){
switch( tecla ){
case KEY_R: Print("KEY_R foi pressionada:",tecla,":",TerminalInfoInteger(TERMINAL_KEYSTATE_SHIFT)<0?"shift":"nao" );
if( TerminalInfoInteger(TERMINAL_KEYSTATE_SHIFT)<0 ){
Print("Atencao: Revertendo posicao...");
}
break;
default: Print("TECLA nnao listada:" ,tecla,":",TerminalInfoInteger(TERMINAL_KEYSTATE_SHIFT)<0?"shift":"nao" );
}
ChartRedraw();
}
//+-----------------------------------------------------------+
//| |
//+-----------------------------------------------------------+
osc_position m_pos;
//void OnTrade(){ m_pos.onTrade(); }
//+-----------------------------------------------------------+
//| |
//+-----------------------------------------------------------+
void OnTradeTransaction( const MqlTradeTransaction& tran, // transacao
const MqlTradeRequest& req , // request
const MqlTradeResult& res ){ // result
bool closer = false; // true: trade eh um fechamento de posicao
bool toClose = false; // true: trade deve ser fechado
ulong toCloseidDeal = 0 ; // se toClose=true este serah o ticket do trade a ser fechado
double toCloseVol = 0 ; // se toClose=true este serah o volume do trade a ser fechado
ENUM_DEAL_TYPE toCloseTypeDeal ; // se toClose=true este serah o sentido do trade a ser fechado, conforme ENUM_DEAL_TYPE
double toClosePriceIn ; // se toClose=true este serah o preco do trade a ser fechado
bool toCloseOpenPos = false; // se toClose=true esta indicarah se a posicao foi aberta agora (primeiraOrdem)
m_pos.onTradeTransaction(tran,req,res,closer,toClose,toCloseidDeal,toCloseVol,toCloseTypeDeal,toClosePriceIn, toCloseOpenPos);
if( EA_LOGAR_TRADETRANSACTION ) m_pos.logarInCSV(tran,req,res);
if( EA_ACAO_POSICAO == NAO_OPERAR ) return;
if( toClose==true ){
// contando volume total da posicao...
if( toCloseTypeDeal == DEAL_TYPE_BUY ){
m_volComprasNaPosicao += (toCloseVol/m_lots_step);
}else{
if( toCloseTypeDeal == DEAL_TYPE_SELL ){
m_volVendasNaPosicao += (toCloseVol/m_lots_step);
}
}
// acionando o fechamento das ordens da posicao...
doCloseRajada4(toCloseidDeal,toCloseVol,toCloseTypeDeal,toClosePriceIn,toCloseOpenPos);
//doCloseFixo(toCloseidDeal,toCloseVol,toCloseTypeDeal,toClosePriceIn);
// se eh a primeira ordem da posicao, incluimos a rajada logo após a primeira ordem de fechamento da posicao.
// execeto na estrategia de prioridade, pois a mesma nao tem rajada.
//if( toCloseOpenPos == true && EA_ACAO_POSICAO != HFT_FORMADOR_DE_MERCADO){
//if( toCloseOpenPos == true ){
// preencherFilaOrdensFixaAssincrona(toCloseTypeDeal,toClosePriceIn);
//}
}else{
// Aqui eh fechamento de posicao.
if(closer){
if( EA_ACAO_POSICAO == HFT_FORMADOR_DE_MERCADO ){
// Se a posicao estah sendo fechada por uma ordem INX, cancele a ordem de fechamento original(comentario numerico) com preco
// mais afastado (maior pra posicoes compradas e menor pra posicoes vendidas).
string comment;
if( m_pos.getComment(tran.order,comment) ){
if( StringFind(comment,m_apmb) > -1 ){
// eh uma ordem INX, entao cancele uma ordem numerica mais afastada
if( estouComprado() ){
m_trade.cancelarMaiorOrdemDeVendaComComentarioNumerico();
}else{
if( estouVendido() ){
m_trade.cancelarMenorOrdemDeCompraComComentarioNumerico();
}
}
}
}
}
}
}
//if( EA_ACAO_POSICAO == HFT_FORMADOR_DE_MERCADO ) abrirPosicaoHFTPrioridadeNoBook();
}
Reference in a new issue View git blame Copy permalink