FórumSeções

Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 6. - página 131

Novo comentário
Sepulca:

Uma boa tarefa para o cérebro. Você pode tentar desta forma:

Resultado do teste para a dimensão 4. Se X elemento de matriz não for selecionado, use matriz[dígito] e fragmento para a dimensão 6:


Eu olhei para seu código, mas o que eu não entendo é que você não leu os dados da matriz original em nenhuma etapa. apenas o número de elementos nela contidos
//chief2000:

Eu olhei seu código, mas o que eu não entendo é o seguinte - você não leu os dados do array original em nenhuma das etapas. você leu apenas o número de elementos nele contidos


Por que eu preciso dos dados da matriz original? Estou apenas sampleando os elementos da matriz de acordo com sua idéia. E cabe a você decidir o que fazer com os dados amostrados. Isto é se N[0]=3, se N[1]=2, se N[2]=1, se N[3]=0, usamos array[N[0]], array[N[1]], array[N[2]], array[N[3]] para análise posterior, e se N[0]=3, N[1]=2, N[2]<0, N[3]<0, então para análise posterior usamos apenas array[N[0]], array[N[1]] porque N[2]<0 e N[3]<0. Tentamos todas as combinações possíveis que não se repetem de acordo com seu posto (levando em conta que a numeração dessa matriz começa de 0 a ArraySize(array)-1):

[4] <=> { 1 2 3 4 }

1, 12, 13, 14, 123, 124, 134, 1234, 
2, 23, 24, 234, 
3, 34,
4

E depois aja de acordo com seu algoritmo:

if(NewComb){
// Получили новую комбинацию в массиве N размерностью k    
    
    for(i=0;i<k;i++){// Перебираем массив N. Если N[i]<0 то элемент array[N[i]] не участвует в выборке.
                     // Например, для размерности 4 если N[0]=3,N[1]=1,N[2}<0,N[3]<0 то это выборка array[3] и array[1]
                     //                             если N[0]=3,N[1]=2,N[2]=1,N[3]=0 то это выборка array[3] и array[2] array[1] и array[0]
     if(N[i]>=0){// использовать как-то array[N[i]]}
    }

   }
Sepulca:


Por que eu preciso dos dados da matriz original? Estou simplesmente sampleando elementos da matriz de acordo com sua idéia. E cabe a você decidir o que fazer com os dados amostrados. Isto é se N[0]=3, se N[1]=2, se N[2]=1, se N[3]=0, usamos array[N[0]], array[N[1]], array[N[2]], array[N[3]] para análise posterior, e se N[0]=3, N[1]=2, N[2]<0, N[3]<0, então para análise posterior usamos apenas array[N[0]], array[N[1]] porque N[2]<0 e N[3]<0. Enumeramos todas as combinações possíveis que não são repetidas de acordo com seu posto (levando em conta que a numeração da matriz começa de 0 a ArraySize(array)-1):

E então proceda de acordo com seu algoritmo:


Agora está claro (li os dados na próxima etapa, só não estou acostumado a trabalhar com códigos que não são meus).
Muito obrigado!

Ajude-me a encontrar um erro na função.

O problema é que se você contar as barras acima do MA, a função retorna o valor correto.

Mas se estiver abaixo do MA, a função sempre retorna 1 (um)

int CheckFiltr ()
   {
   int i=1;
   for (;;)
      {
      if (NormalizeDouble(High[i],Norm)&&NormalizeDouble(Low[i],Norm)<NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm)||NormalizeDouble(High[i],Norm)&&NormalizeDouble(Low[i],Norm)>NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm))
         {
         i++;
         Comment ("Фильтр = ", i);         
         }
      else break;
      }
   return (i);
   }
MarkTrade:

Ajude-me a encontrar um erro na função.

O problema é que se você contar as barras acima do MA, a função retorna o valor correto.

Mas se estiver abaixo do MA, a função sempre retorna 1 (um)

À primeira vista isto é melhor, embora o código possa ser significativamente otimizado, já que eu corrigi apenas a gramática:

int CheckFiltr ()
   {
   int i=1;
   int Norm=Digits;
   for (;;)
      {
      if (
           (   NormalizeDouble(High[i],Norm)<NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm)
            && NormalizeDouble(Low[i] ,Norm)<NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm)
           )
          ||
           (   NormalizeDouble(High[i],Norm)>NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm) 
            && NormalizeDouble(Low[i] ,Norm)>NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm)
           )
         )

         {
         i++;
         Comment ("Фильтр = ",i);         
         }
      else break;
      }
   return (i);
   }
paladin80:

Para seu exemplo, isso não faz nenhuma diferença, mas você tem que especificar o início e o fim da matriz de qualquer maneira.

O início faz diferença se o conjunto for grande. Por exemplo, se a condição for acionada como regra no final da matriz, é melhor começar no final. Este exemplo é típico de busca de ordem/posição. Claro que, se você fizer a busca primeiro neste caso, o programa chegará a este ponto de qualquer maneira, mas será preciso mais recursos.


Mais uma vez, obrigado! Agora tentamos otimizar o número de barras "verificáveis", mas os resultados na janela simplesmente não estão lá. Tentei começar a contar tanto do início quanto do fim, mas em vão.

extern int number=3;
//------------------------------------+
for (int x=number; x>=1; x--)
{
 if(Open[x]==Open[x-1]) continue;
    if(Open[x]<Open[x-1])
   {
   //--- action
   }
 else{
    if(Open[x]>Open[x-1])
   {
   //--- action
  }
 }
}
Sepulca:
À primeira vista isto é melhor, embora o código pudesse ser significativamente otimizado:


Isto funciona... Obrigado!

Só preciso entender porque minha versão não quer funcionar...

MarkTrade:


Funciona assim... Obrigado!

Só queria entender porque minha versão não quer funcionar...


Dê uma olhada mais de perto em seu código

 if (NormalizeDouble(High[i],Norm)&&NormalizeDouble(Low[i],Norm)<NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm)
||NormalizeDouble(High[i],Norm)&&NormalizeDouble(Low[i],Norm)>NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm))
    
Você está simplesmente comparando o primeiro termo com zero, ou seja, verdadeiro ou falso.
MarkTrade:


Funciona... Obrigado!

Só queria entender porque minha versão não quer funcionar...

Seu código:

int CheckFiltr ()
   {
   int i=1;
   for (;;)
      {
      if (NormalizeDouble(High[i],Norm)&&
          NormalizeDouble(Low[i],Norm)<NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm)
            ||    
          NormalizeDouble(High[i],Norm)&&
          NormalizeDouble(Low[i],Norm)>NormalizeDouble(iMA(NULL,0,PerMa,0,MetMa,AplPr,i),Norm))
         {
         i++;
         Comment ("Фильтр = ",i);         
         }
      else break;
      }
   return (i);
   }

Talvez seja mais fácil de entender...

Oops... já foi dito, você pode fazer isso sem normalização...

Roger:


Dê uma olhada mais de perto em seu código

Você simplesmente compara o primeiro termo com zero, ou seja, verdadeiro ou falso.


Então a expressão "se a e c são maiores que c" não é correta, mas "se a é maior que c e c é maior que c" é correta?
1...124125126127128129130131132133134135136137138...1178
Novo comentário