ForumSezioni

Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - pagina 131

Nuovo commento
Sepulca:

Un buon compito per il cervello. Potete provare così:

Risultato del test per la dimensione 4. Se l'elemento X dell'array non è selezionato, altrimenti usa array[digit] e frammento per la dimensione 6:


Ho guardato il tuo codice, ma quello che non capisco è che non hai letto i dati dell'array originale in nessuna fase. solo il numero di elementi in esso
//chief2000:

Ho guardato il tuo codice, ma quello che non capisco è il seguente - non hai letto i dati dell'array originale in nessuno dei passi. solo il numero di elementi in esso


Perché ho bisogno dei dati dell'array originale? Sto solo campionando gli elementi dell'array secondo la tua idea. E sta a voi decidere cosa fare con i dati campionati. Cioè se N[0]=3, se N[1]=2, se N[2]=1, se N[3]=0, usiamo array[N[0]], array[N[1]], array[N[2]], array[N[3]] per ulteriori analisi, e se N[0]=3, N[1]=2, N[2]<0, N[3]<0, allora per ulteriori analisi usiamo solo array[N[0]], array[N[1]] perché N[2]<0 e N[3]<0. Proviamo tutte le combinazioni possibili che non si ripetono secondo il tuo post (tenendo conto che la numerazione dell'array inizia da 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 poi agisci secondo il tuo 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:


Perché ho bisogno dei dati dell'array originale? Sto semplicemente campionando gli elementi dell'array secondo la vostra idea. E sta a voi decidere cosa fare con i dati campionati. Cioè se N[0]=3, se N[1]=2, se N[2]=1, se N[3]=0, usiamo array[N[0]], array[N[1]], array[N[2]], array[N[3]] per ulteriori analisi, e se N[0]=3, N[1]=2, N[2]<0, N[3]<0, allora per ulteriori analisi usiamo solo array[N[0]], array[N[1]] perché N[2]<0 e N[3]<0. Enumeriamo tutte le combinazioni possibili che non si ripetono secondo il tuo post (tenendo conto che la numerazione dell'array inizia da 0 a ArraySize(array)-1):

E poi procedete secondo il vostro algoritmo:


Ora è chiaro (ho letto i dati nel passo successivo, solo che non sono abituato a lavorare con codice non mio).
Grazie mille!

Aiutami a trovare un errore nella funzione.

Il problema è che se si contano le barre sopra la MA, la funzione restituisce il valore corretto.

Ma se è sotto il MA, la funzione restituisce sempre 1 (uno)

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:

Aiutami a trovare un errore nella funzione.

Il problema è che se si contano le barre sopra la MA, la funzione restituisce il valore corretto.

Ma se è sotto il MA, la funzione restituisce sempre 1 (uno)

A prima vista questo è meglio, anche se il codice può essere notevolmente ottimizzato, dato che ho solo corretto la grammatica:

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:

Per il tuo esempio in realtà non fa alcuna differenza, ma devi comunque specificare l'inizio e la fine dell'array.

L'inizio fa la differenza se l'array è grande. Per esempio, se la condizione viene attivata come regola alla fine dell'array, è meglio iniziare dalla fine. Questo esempio è tipico della ricerca di ordine/posizione. Naturalmente, se si fa prima la ricerca in questo caso, il programma arriverà comunque a questo punto, ma richiederà più risorse.


Grazie ancora! Ora ho provato a rendere ottimizzabile il numero di barre "controllabili", ma i risultati nella finestra proprio non ci sono. Ho cercato di iniziare a contare sia dall'inizio che dalla fine, ma invano.

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:
A prima vista questo è meglio, anche se il codice potrebbe essere notevolmente ottimizzato:


Questo funziona... Grazie!

Devo solo capire perché la mia versione non vuole funzionare...

MarkTrade:


Funziona così... Grazie!

Vorrei solo capire perché la mia versione non vuole funzionare...


Dai un'occhiata più da vicino al tuo codice

 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))
    
State semplicemente confrontando il primo termine con zero, cioè vero o falso.
MarkTrade:


Funziona... Grazie!

Vorrei solo capire perché la mia versione non vuole funzionare...

Il tuo codice:

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);
   }

Forse è più facile da capire...

Ops... ti è già stato detto che puoi farlo senza normalizzazione...

Roger:


Dai un'occhiata più da vicino al tuo codice

Si confronta semplicemente il primo termine con zero, cioè vero o falso.


Quindi l'espressione "se a e c sono maggiori di c" non è corretta, ma "se a è maggiore di c e c è maggiore di c" è corretta?
1...124125126127128129130131132133134135136137138...1178
Nuovo commento