Participe de nossa página de fãs
Coloque um link para ele, e permita que outras pessoas também o avaliem
Avalie seu funcionamento no terminal MetaTrader 5
CDouble & CDoubleVector - biblioteca para MetaTrader 5
- Visualizações:
- 1075
- Avaliação:
- Publicado:
- 2018.12.31 08:25
- Precisa de um robô ou indicador baseado nesse código? Solicite-o no Freelance Ir para Freelance
Uma biblioteca para métodos de arredondamento comuns usados no desenvolvimento MQL, classe wrapper primitiva para "type" (double) e vetor para objetos CDouble. MQL5 e MQL4 são compatíveis!
Versão 102: (2018.02.18)
- Corrigido o erro em que o resultado do arredondamento alterava a expectativa do resultado. OBRIGADO AMRALI!
Versão 1.01:
- Corrigido erro onde os operadores aritméticos não retornavam os valores arredondados.
- Adicionado o método "setter" de símbolos para configurar o símbolo após a chamado do construtor.
CDouble
A classe CDouble envolve um valor do tipo primitivo double em um objeto. Além disso, essa classe fornece vários métodos e métodos estáticos para arredondar doubles e arrays/collections do tipo double.
Declaração
class CDouble : public CObject
Título
#include <Double.mqh>
Hierarquia de herança
- CObject
- CDouble
Método Virtual implementado/substituído pela classe CObject: Type, Load, Save, Compare.
Um objeto do tipo CDouble contém cinco campos de dados:
string |
m_symbol |
Símbolo atribuído à instância da classe que é usada para recuperar a etapa do lote e o tamanho do tick para arredondamento. |
double |
m_value |
Valor bruto do double atribuído a instância. |
uchar |
m_step |
Step para arredondamento representada como caractere para reduzir os rastros de memória - por exemplo, 0.0025 se torna 25. |
uchar |
m_digits |
Número de dígitos após o decimal. |
ENUM_PRECISION |
m_mode |
Modo de operação para bloquear os métodos de arredondamento para um valor "step" específico. |
Antes de nos aprofundarmos mais nos documentos, aqui está um rápido exemplo prático da classe wrapper em ação:
MqlTick tick; SymbolInfoTick(_Symbol,tick); CDouble price = tick.ask - 0.0087263487676283476, sl = price - 500*_Point, tp = price + 500*_Point, lots = 5.25 / 3.78789; MqlTradeRequest r={0}; r.symbol= _Symbol; r.price = price.AsRoundedTick(); r.sl = sl.AsRoundedTick(); r.tp = tp.AsRoundedTick(); r.volume= lots.AsRoundedLots();...
Outro exemplo usando os métodos estáticos da biblioteca:
MqlTick tick; SymbolInfoTick(_Symbol,tick); MqlTradeRequest r={0}; r.symbol= _Symbol; r.price = tick.ask - 0.0087263487676283476, r.sl = price - 500*_Point, r.tp = price + 500*_Point, r.volume= 5.25 / 3.78789; ... CDouble::RoundTradeRequest(r); //Arredonda automaticamente os campos de preço para o tamanho do tick //e o volume para step do lote
Resumo do método estático
Nota: Não é necessário saber OOP ou usar uma instância da classe wrapper para fazer uso desta biblioteca. Tudo o que tem a fazer é chamar as funções estáticas com a resolução de escopo do CDouble. A sintaxe é a seguinte:
type variable_name = CDouble::Method(args);
Modificador e Tipo | Método | Descrição |
---|---|---|
static bool |
IsEqual (double number1, double number2, double step); |
Compara dois doubles e retorna um booleano pela subtração do segundo número a partir do primeiro, arredondando a soma para o "step" e comparando a 0. |
static bool |
IsEqual (double number1, double number2, int digits); |
Compara dois doubles e retorna um pela subtração do segundo número a partir do primeiro, arredondando a soma para "dígits" e comparando com 0. |
static int |
Compare (double number1, double number2, double step) |
Compara dois doubles e retorna um inteiro:
|
static double |
RoundToStep (const double number, double step) |
Retorna o valor arredondado para a precisão do step mais próximo (e.g. 0.0025). |
static double |
RoundToDigit (const double number, int digits) |
Retorna o valor arredondado para o dígito mais próximo (o mesmo que NormalizeDouble). |
static double |
RoundToStepUp (const double number, double step) |
Retorna o valor arredondado maior para a precisão do step. |
static double |
RoundToStepDown (const double number, double step) |
Retorna o valor arredondado menor para a precisão do step. |
static double |
RoundToTick (const double number, string symbol=NULL) |
Retorna o valor arredondado mais próximo do tamanho do tick referente ao símbolo atual (symbol=NULL) ou o símbolo determinado no parâmetro symbol. |
static double |
RoundToLots (const double number, string symbol=NULL, bool always_return_valid=true) |
Retorna o valor arredondado menor mais próximo do lot step referente ao símbolo atual (symbol=NULL) ou o símbolo determinado no parâmetro symbol always_return_valid == true: sempre retornará um volume válido de lote (min_lots <= return_value <= max_lots) |
static void (MQL5) |
RoundTradeRequest (MqlTradeRequest &request) |
Modifica o preço, sl, tp e os campos de volume para o símbolo identificado no pedido. Arrendonda o valor do preço, sl e tp para o tamanho do tick. Arrendonda o valor menor mais próximo do step do lote. |
static void |
RoundArrayToStep |
Arredonda um array inteiro para o step determinado ou para o tamanho do tick do símbolo atual se step==NULL. |
static void |
RoundArrayToStep |
Arredonda uma coleção inteira do CArrayDouble para o step determinado ou para o tamanho do tick do símbolo atual se step==NULL. |
static int |
GetDigits (double floating_point) |
Retorna o número de dígitos arrastando até o zero no double. (e.g. 0.0002500... retornaria 5 dígitos). |
static double |
GetPoint (int digits) |
Retorna o valor double dos dígitos específicos. (por exemplo 3 retornaria 0.001). |
static string |
ToString |
Retorna uma string do número de ponto flutuante arredondando para os dígitos e arrasta os números zero (e.g. CDouble::ToString(1.23400001, 6) retornaria "1.234"). |
Exemplos:
MqlTick tick; SymbolInfoTick(_Symbol,tick); double rnd_by_step = CDouble::RoundToStep(tick.bid*1.052565465,_Point); double rnd_by_digits = CDouble::RoundToDigit(tick.bid*1.052565465,_Digits); double by_lot_step = CDouble::RoundToLots(0.123423,_Symbol); double by_tick_size = CDouble::RoundToTick(tick.ask-100*_Point,_Symbol); double roundup = CDouble::RoundToStepUp(3.999999999,_Point); double rounddn = CDouble::RoundToStepDown(3.999999999,_Point); int digits = CDouble::GetDigits(0.0000025); double point = CDouble::GetPoint(10); bool equal = CDouble::IsEqual(tick.bid,tick.bid+0.00000009,_Point); string tostr = CDouble::ToString(3.1399999999999999); int compare = CDouble::Compare(tick.ask,tick.bid); #ifdef __MQL5__ MqlTradeRequest r={0}; r.symbol= _Symbol; r.price = tick.ask+0.000089849847658759198199999; r.sl = r.price - 503 * _Point; r.tp = r.price + 503 * _Point; r.volume= 1.127984984; CDouble::RoundTradeRequest(r); #endif
Resumo do Construtor
Construtor | Descrição |
---|---|
CDouble (const ENUM_PRECISION mode = PRECISION_DEFAULT, const string symbol = NULL) |
Nota: Não é necessário chamar explicitamente o construtor, pois os argumentos são inicializados no chamador. Não é necessário também especificar o método de precisão, desde que exista métodos para retornar um valor arredondado com base na chamada de método. ENUM_PRECISION:
|
CDouble (const CDouble &other) |
Construtor de cópias: copia todos os campos privados de outro objeto para este objeto. |
Exemplos:
CDouble num; CDouble bid(PRECISION_TICK_SIZE, _Symbol); CDouble ask(bid) CDouble ask2 = bid; CDouble lots(PRECISION_LOT_STEP, _Symbol);
Resumo de Atribuição - Operadores de Atribuição de Sobrecarga
Modificador e Tipo | Método | Descrição |
---|---|---|
void |
Set(const double value) |
Atribui o valor double bruto para m_value. |
void |
Set(const CDouble &other) |
Atribui o valor double bruto do objeto CDouble para m_value. |
void |
Operadores de sobrecarga =, +=, -=, *=, /= (double OR CDouble&) | Atribui ou modifica o valor double bruto para m_value. |
Nota: o operador de atribuição = pode ser chamado na mesma linha como declaração.
Exemplos:
CDouble bid; bid.Set(tick.bid); CDouble ask = tick.ask; CDouble pi = 3.14; CDouble factor = 2; pi*=factor; Print(pi.ToString()); //6.28
Resumo do Operador Aritmético de Sobrecarga
Modificador e Tipo | Método | Descrição |
---|---|---|
double |
Operadores de Sobrecarga +, -, *, / (double OR CDouble&) | Pode aceitar o tipo double ou objeto CDouble como argumento. Retorna valor double após a aplicação de associação aritmética com o operador de sobrecarga. |
Nota: Apenas um operador aritmético pode ser usado pela declaração.
Sintaxe para a aritmética do operador de sobrecarga:
type_double_result <-- CDouble_object <-- operator <-- double //objeto CDouble sempre vai estar no lado esquerdo do operador type_double_result <-- CDouble_object1 <-- operator <-- CDouble_object2 //a ordem não importa quando usa dois objetos CDouble.
Exemplos:
CDouble foo = 3.14; CDouble bar = 10; CDouble foobar = bar + foo; //13.14 CDouble err = bar + foo + foobar; //erro - operação ilegal usada double var = bar / foo;
Resumo do Operador de Comparação de Sobrecarga
Modificador e Tipo | Método | Descrição |
---|---|---|
bool |
Operadores de sobrecarga ==, !=, >, <, >=, <= (double OR CDouble&) |
Pode aceitar o tipo double ou objeto CDouble como argumento. Retorno booleano da comparação do valor Nota: está usando o método <static int>Compare para comparação. |
Exemplos:
CDouble foo = 3.14, bar = 3.139999999999999999999; Print(foo == bar); //verdadeiro Print(foo <= bar); //verdadeiro Print(foo > bar); //falso
Resumo do Método de Instância
Controle de Precisão (padrão): digits = 8; step = 1e-08
- Existem três maneiras de controlar a precisão:: Step, Digits, ou PrecisionMode(ENUM_PRECISION). Qualquer chamada para qualquer um desses métodos setter substituirá as configurações anteriores.
- O Step é o _Point, ou o LOT_STEP, ou ainda, o TickSize; representado como um ponto flutuante (por exemplo 0.00001, 0.025, etc.)
- Não é necessário definir o Step, pois RoundToTick e RoundToLot usam automaticamente os valores de Step apropriados para o retorno do arredondamento.
Modificador e Tipo | Método | Descrição |
---|---|---|
void |
PrecisionMode (const ENUM_PRECISION mode) |
Define o modo padrão para cálculos de arredondamento e ToString. Substitui as configurações existentes do Step e do Digit. Nota: também pode ser definido no construtor. ENUM_PRECISION:
|
ENUM_PRECISION |
PrecisionMode() |
Retorna o modo da precisão do trabalho atual. |
void |
Step (const double step_or_point) |
Define o step para a precisão específica Substitui o modo de precisão. |
double |
Step() |
Retorna o valor atual do Step. |
void |
Digits (const int digits) |
Define a precisão para o número de dígitos específicos. Substitui o modo de precisão e define o step para 1e-(digits). |
int |
Digits() |
Retorna a precisão atual do dígito de trabalho. |
double |
AsRawDouble() |
Retorna o valor bruto do double armazenado. |
double |
AsRounded() |
Retorna o valor arredondado para o step específico mais próximo. padrão = 1e-08. Quando PRECISION_TICK_SIZE, o step é bloqueado para o tamanho do tick. Quando PRECISION_LOT_STEPS, step é bloqueado para lot step. |
double |
AsRoundedUp() |
Retorna o valor arredondado maior para step específico. |
double |
AsRoundedDown() |
Retorna o valor arredondado menor para step específico. |
double |
AsRoundedTick() |
Retorna o valor arredondado para o tick mais próximo - específico pelo tamanho do tick do símbolo. |
double |
AsRoundedLots (bool always_return_valid = true) |
Retorna o valor arredondado para o lot mais próximo - específico pelo tamanho do lot step do símbolo. |
int |
ToInt() |
Retorna o valor int. |
long |
ToLong() |
Retorna o valor long. |
string |
ToStringPrecision() |
Retorna uma string com o deslocamento dos zeros. |
string |
ToString() |
Retorna uma string com deslocamento truncado dos zeros. |
string |
Symbol() |
Retorna o trabalho do símbolo atual. |
string |
Symbol(const string symbol) |
Define o símbolo de trabalho para outro símbolo diferente do símbolo de gráfico após o construtor ter sido chamado. Usado quando se trabalha com multiplos símbolos. |
Exemplos:
CDouble pi2 = 3.14159265359; // obter valor como... double raw_double = pi2.AsRawDouble(); double round_double_to_step = pi2.AsRounded(); double tick_size_double = pi2.AsRoundedTick(); double lot_step_double = pi2.AsRoundedLots(); double rounded_up = pi2.AsRoundedUp(); double rounded_down = pi2.AsRoundedDown(); int double_to_int = pi2.ToInt(); long double_to_long = pi2.ToLong(); string precision_str = pi2.ToStringPrecision(); pi2 = 3.140000000009; pi2.Digits(8); string truncated_str = pi2.ToString();
Resumo do método de instância
Métodos substituídos do CObject:
Modificador e Tipo | Método | Descrição |
---|---|---|
virtual int |
Compare (const CObject *node, const int mode=0) |
Usado para classificar e pesquisar, o método Compare compara o valor AsRounded deste objeto com o valor AsRounded do nó de entrada. |
virtual int |
Type() |
Retorna um int do tipo TYPE_DOUBLE. |
virtual bool |
Save(const int file_handle) |
Serializa e salva as variáveis de membro no arquivo do handle de entrada. |
virtual bool |
Load(const int file_handle) |
Define as variáveis de membros para os valores salvos no arquivo do handle de entrada. |
Como exemplo, veja a classe CDoubleVector a seguir.
CDoubleVector
A classe CDoubleVector é uma coleção especializada de ponteiro de objeto para instâncias dinâmicas CDouble.
Declaração
class CDoubleVector : public CArrayObj
Título
#include <Double.mqh>
Hierarquia de herança
Virtual Methods implemented/overridden from class CArrayObj: CreateElement.
Resumo do Método de Instância
**Ver métodos herdados da classe CArrayObj.
Modificador e Tipo | Método | Descrição |
---|---|---|
CDouble* |
operator[] (const int index) |
Indice do operador de sobrecarga. Retorna o ponteiro para o objeto com "n" índice no vetor. |
bool |
Add(const double value) |
Obtém um double primitivo como argumento, o converte em um objeto CDouble e o adiciona ao final do vetor. |
bool |
AssignDoubleArray (const double &array[]) |
Obtém array doubles e os converte em objetos CDouble e os atribui ao vetor. |
bool |
CopyOut(double &arr[]) |
Copia os valores CDouble no vetor para um array double primitivo. |
bool |
CopyOut(CArrayDouble &arr) |
Copia os valores CDouble no vector à coleção CDoubleArray. |
virtual bool |
Save(const int file_handle) |
Salva o vetor em arquivo específico pelo handle do arquivo de entrada. |
virtual bool |
Load(const int file_handle) |
Carrega o estado do vetor salvo de arquivo específico pelo handle do arquivo de entrada. |
Exemplos:
CDoubleVector *vect = new CDoubleVector; double dubs[]={3.14,1.21,55.555}; vect.AssignDoubleArray(dubs); vect.Add(tick.bid); //chamando o objeto CDouble pelo índice Print(vect[vect.Total()-1].ToString()); //adicionar um novo objeto CDouble CDouble *lot = new CDouble(PRECISION_LOT_STEP); lot = 1.22; vect.Add(lot); //vetor de classificação ascendente vect.Sort(); int total = vect.Total(); //salva vetor para arquivo, incluindo estados e valores do objeto CDouble string f = "testdub.bin"; int h = FileOpen(f,FILE_WRITE|FILE_BIN); if(vect.Save(h)) Print("save successful"); FileClose(h); delete vect; //salva vetor a partir do arquivo CDoubleVector vect_reborn; h=FileOpen(f,FILE_READ|FILE_BIN); if(vect_reborn.Load(h)) Print("load successful"); FileClose(h); total = vect_reborn.Total(); Print("Total vector size = ",sizeof(vect_reborn)," bytes"); for(int i=0;i<vect_reborn.Total();i++) Print(vect_reborn[i].ToString()); //copiar para double arr double arr2[]; vect_reborn.CopyOut(arr2); Print(ArraySize(arr2));
Traduzido do inglês pela MetaQuotes Ltd.
Publicação original: https://www.mql5.com/en/code/19727
Oscilador MACD Squeeze similar ao indicador Trade The Markets Squeeze, mas baseado no MACD.
Hikkake Pattern (Falso Rompimento Interno Dia)O Indicador Hikkake Pattern (Falso Rompimento Dentro do Dia) é uma estratégia de negociação baseada em falsos rompimentos. Traduzido para o código MQL5 do artigo de Dan Chesler, "Trading False Moves with the Hikkake Pattern", publicado em abril de 2004, na revista Active Trader.
Um indicador completo do gráfico Renko com sombras. Configure usando o Tick Size, Pip Size, Points ou R. com reversões assimétricas!
Optimal F para MQL5 (por Ralph Vince)Calculo do valor Optimal f usando a Média Geometrica. Por Ralph Vince, "No trading, podemos contar com nossas vitórias e nossas perdas por quantias variadas. Portanto, as fórmulas de Kelly não poderiam nos fornecer o optimal f ideal." Então, usando as suas equações, eu criei esta biblioteca para a versão do do Optimal F usando a Média Geométrica.