Erros, bugs, perguntas - página 2451

Novo comentário
 
Um ficheiro com um # no seu nome não pode ser acrescentado ao armazenamento. Este é um comportamento normal ou um insecto?
 

Se estamos a falar de FX, aí os carrapatos não alteram muito o preço (normalmente). Mas em outros mercados uma ordem pode escorregar seriamente com uma abordagem tiquetaque. Ainda sou a favor de tentar entre carrapatos - não vejo qualquer dano, o benefício potencial está lá.

Temos de tentar...

 
Histerese em acção... sobre um exemplo de como um operador de cópia de atribuição implícita funciona em estruturas.

#define  PRINT(x) Print(#x, ":", string(x))

struct MyArray{
   uchar data[];
};


void OnStart(){
   MyArray tmp_arr;
   
   MyArray huge_arr;
   ArrayResize(huge_arr.data, 1000);
   ArrayInitialize(huge_arr.data, 0x8);
   
   MyArray small_arr;
   ArrayResize(small_arr.data, 10);
   ArrayInitialize(small_arr.data, 0x1);
   
   
   tmp_arr = small_arr;
   Print("\r\nTest with small_arr");
   PRINT(ArraySize(tmp_arr.data));
   PRINT(tmp_arr.data[0]);
   PRINT(tmp_arr.data[ArraySize(tmp_arr.data)-1]);
   
   tmp_arr = huge_arr;
   Print("\r\nTest with huge_arr");
   PRINT(ArraySize(tmp_arr.data));
   PRINT(tmp_arr.data[0]);
   PRINT(tmp_arr.data[ArraySize(tmp_arr.data)-1]);
   
   tmp_arr = small_arr;
   Print("\r\nTest with small_arr");
   PRINT(ArraySize(tmp_arr.data));
   PRINT(tmp_arr.data[0]);
   PRINT(tmp_arr.data[ArraySize(tmp_arr.data)-1]);
}

Resultado:
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   Test with small_arr
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   ArraySize(tmp_arr.data):10
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[0]:1
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[ArraySize(tmp_arr.data)-1]:1
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   Test with huge_arr
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   ArraySize(tmp_arr.data):1000
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[0]:8
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[ArraySize(tmp_arr.data)-1]:8
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   Test with small_arr
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   ArraySize(tmp_arr.data):1000
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[0]:1
2019.05.03 14:29:14.005 Test_push (EURUSD,H1)   tmp_arr.data[ArraySize(tmp_arr.data)-1]:8
 
Sergey Dzyublik:
Histerese em acção... por um exemplo de como funciona um operador de cópias implícitas em estruturas.

Provavelmente, para detectar tal coisa, era necessário atingir um estado/estupidez interna de "nada pode não funcionar aqui, mas vou verificar na mesma" em busca de um erro no próprio código.

 
fxsaber:

Acho que para detectar tal coisa, teve de chegar ao estado/estupidez interna de "nada pode correr mal aqui, mas vou verificar de qualquer forma" em busca de um bug no seu código.

O código estava a analisar o fluxo de bytes para um determinado protocolo.
Os dados desembalados e desembalados (dados para o próximo nível de encapsulamento) não corresponderam.

 
Sergey Dzyublik:

O código estava a analisar o fluxo de bytes para um protocolo específico.
Os dados desembalados e desembalados (dados para o próximo nível de encapsulamento) não corresponderam.

Não é difícil detectar uma tal tarefa. Sorte.
 
Sergey Dzyublik:
Histerese em acção... Um exemplo de como um operador de cópias implícitas funciona em estruturas.

Qual é a questão?

void OnStart()
{
        int a[]; ArrayResize( a, 3 ); ArrayInitialize( a, 3 );
        int b[]; ArrayResize( b, 2 ); ArrayInitialize( b, 2 );

Em MQL, uma entrada condicional

//                 a = b;

igual a

        ArrayCopy( a,  b );

Resultado:

        ArrayPrint( a );
}

2 2 3

 
A100:

Qual é a questão?


Na minha opinião, o operador da cópia de atribuição deve copiar não só os próprios elementos da matriz, mas também o seu número, deixando válida a quantidade de memória reservada.

E agora é praticamente o seguinte:

int size;
size = 4; // size == 4
size = 8; // size == 8
size = 4; //  size == 8



Código fonte:

struct MyArray{
   uchar data[];
}

MyArray GetArray(int i){
   MyArray arr;
   
   if (i%2 == 0){
      ArrayResize(arr.data, 8);
      ArrayInitialize(arr.data, 0x8);
   }else{
      ArrayResize(arr.data, 4);
      ArrayInitialize(arr.data, 0x4);
   }
   return arr;
}

void OnStart(){
   MyArray arr_1 = GetArray(1);
   ArrayPrint(arr_1.data);		// 4 4 4 4
   
   MyArray arr_2 = GetArray(2);         
   ArrayPrint(arr_2.data);              // 8 8 8 8 8 8 8 8
   
   arr_2 = arr_1;
   ArrayPrint(arr_2.data);              // 4 4 4 4 8 8 8 8
}
 
Sergey Dzyublik:


O operador de cópia deve copiar não só os próprios elementos da matriz, mas também o seu número, deixando intacta a quantidade de memória reservada.

Porquê então

struct MyArray {
        uchar data[];
};
void OnStart()
{
        { uchar   a[], b[]; a = b; } //(1) Error
        { MyArray a,   b;   a = b; } //(2) нормально
}

em (1) o erro e em (2) está bem!? Qual é a diferença?

A diferença é que as matrizes são copiadas não pelas regras a = b, mas pelas regras ArrayCopy( a, b )

Não pelas regras a = b, porque não existe, e se existisse, o erro (1) não existiria


 
Igor Zakharov:

A contagem de cada carrapato é intensiva em recursos, especialmente no testador de estratégias. Não seria mais correcto recalcular apenas o evento comercial, ou seja, quando algo na lista de posições em aberto muda de facto? Com a OnTradeTransaction(), é mais fácil controlar a intervenção do utilizador na EA. (Há alguns precedentes :)

Neste robô comercial estava a testar a possibilidade de fechar a grelha pelo esquema: Perda + lucro > X , depois fechar ambos (normalmente em símbolos diferentes). Mas ocorre uma falha, porque mesmo estando fechados, o testador não tem conhecimento disso, e prossegue para a iteração seguinte, "emparelhando" erradamente os existentes com os já fechados. Isto é, tive de acrescentar um novo cálculo após cada encerramento.

Tenho de recalcular com o contador reiniciado e em todos os abertos primeiro, não +1 / -1

Concordo, foi arriscado utilizar inicialmente a OnTradeTransaction() Na verdade, provavelmente recusarei a sua utilização nos casos em que os meus pedidos não sejam assíncronos - causam apenas problemas.

Não é de todo arriscado. A única questão está em organizar a sequência de acções e eventos. O conselho do tolo é correcto - fechar o par e deixar o laço até ao próximo tique. No tick seguinte, os preços não são necessariamente piores do que são. Talvez seja melhor fechá-lo um pouco mais tarde, mas não haverá confusão sobre o que fechou com o quê.

A segunda variante: organizar o laço não por PositionsTotal, mas pela matriz criada de antemão. E ao fechar alguns pares, estes bilhetes devem ser retirados da matriz. Isto não permitirá que as posições fechadas sejam novamente encerradas. Em geral, um voo de fantasia e lógica de acções.

1...244424452446244724482449245024512452245324542455245624572458...3184
Novo comentário
Razão: