ForumSezioni

Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 618

Nuovo commento
Leo59:
Può dirmi perché questo potrebbe essere il caso? :
Fun_1() e Fun_2() sono simili.
Simile senza tipo di funzione e senza ritorni?
Leo59:
Potete dirmi per favore cosa potrebbe essere la causa di questo? :
Fun_1() e Fun_2() sono simili.

accademicamente - le funzioni non sono pure e cambiano lo stato globale.

brevemente - entrambe le funzioni leggono e scrivono una variabile globale o un file.

Maxim Kuznetsov:

accademicamente - le funzioni non sono pure e cambiano lo stato globale.

in breve - entrambe le funzioni leggono e scrivono una variabile globale o un file.

Sì, ognuno scrive un file. Quindi?
Leo59:
Sì, ognuno di loro scrive un file. Quindi?

e non lavorano insieme :-)

PS. è impossibile dire con più precisione la fonte dei colpi sotterranei senza fonti. Da qualche parte c'è un errore - correggilo

Per risparmiare spazio e migliorare la percezione - in una sola funzione. Ancora non funziona.

void Fun_Select_2()                                                   // dSSd Выбор сочетаний из массивов dSe1_Bal_D и dSe1_Bal_W с Proba>67
   {
    // 1. УДАЛЯЕМ старые файлы
    // 2. ПЕРЕБИРАЕМ в поиске соответствия
    // 3. ПЕЧАТАЕМ найденное в файл

    // 1. УДАЛЯЕМ старые файлы
    if(use_Print_Rep_dSS == 1)                                        // =0 -> Условие отключено, =1 -> Печатать в log файл Промежуточные отчёты (dSS)
        {
         LogName="Rep_dSSd "+EN;                                      // (Interum Report) Название ЛОГА + Название ЭТОГО ЭКСПЕРТА, передаваемое в log файл
         // Если файл с таким именем существует, то удаляем его ... 
         ld=log_delete(LogName);                                      // ФЛАГ log файла, удаляемого в директории "logs\\" 
         if(ld==1)
              Alert ("Старый файл dSSd УДАЛЁН");
         LogName="Rep_dSSw "+EN;                                      // (Interum Report) Название ЛОГА + Название ЭТОГО ЭКСПЕРТА, передаваемое в log файл
         // Если файл с таким именем существует, то удаляем его ... 
         ld=log_delete(LogName);                                      // ФЛАГ log файла, удаляемого в директории "logs\\" 
         if(ld==1)
              Alert ("Старый файл dSSw УДАЛЁН");
        }

    // 2. ПЕРЕБИРАЕМ в поиске соответствия
    //    Находим соответствие между [1]-"Num1 А" и [4]-"Num1 B" в массивах dSe1_Bal_D и dSe1_Bal_W
    int t=0;                                                          // Техническая переменная
    int d=0;                                                          // Техническая переменная
    int w=0;                                                          // Техническая переменная
    int D=0;                                                          // Техническая переменная
    int W=0;                                                          // Техническая переменная
    int S=0;                                                          // Техническая переменная

    //    Если есть соответствие тогда записываем её в массив dSSd[][90]
    Count_dSSd=0;                                                     // "Обнуляем" Счётчик записей (строк) в массиве dSSd[][90]
    Range_dSSd_one=0;                                                 // "Обнуляем" Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSd[][90];
    Range_dSSd_two=0;                                                 // "Обнуляем" Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSd[][90];

    for(d=0, t=0; d<Range_dSe1_Bal_D_one; d++)
        {
         for(w=0; w<Range_dSe1_Bal_W_one; w++)
             {
              if( (dSe1_Bal_W[w][1]==dSe1_Bal_D[d][1]) && (dSe1_Bal_W[w][4]==dSe1_Bal_D[d][4]) )
                  {
                   Count_dSSd++;                                      // Счётчик записей (строк) в массиве dSSd[][90]
                   ArrayResize(dSSd, Count_dSSd, 200000);             // Задайм новый размер массива с резервированием памяти на 100000 записей (строк)  
                   for(S=0,  D=0;   D<45;   D++, S++)
                        dSSd[t][S] = dSe1_Bal_D[d][D];                // Значения строки массива dSe1_Bal_D
                   for(S=45, W=0;   W<45;   W++, S++)
                        dSSd[t][S] = dSe1_Bal_W[w][W];                // Значения строки массива dSe1_Bal_W
                   t++;                                               // Увеличили индекс массива dSSd на "1"
                  }
             }
        }
    Range_dSSd_one = ArrayRange(dSSd, 0);                             // Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSd[][90];
    Range_dSSd_two = ArrayRange(dSSd, 1);                             // Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSd[][90];

    //    Если есть соответствие тогда записываем её в массив dSSw[][90]
    Count_dSSw=0;                                                     // "Обнуляем" Счётчик записей (строк) в массиве dSSw[][90]
    Range_dSSw_one=0;                                                 // "Обнуляем" Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSw[][90];
    Range_dSSw_two=0;                                                 // "Обнуляем" Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSw[][90];
    for(d=0, t=0; d<Range_dSe1_Bal_D_one; d++)
        {
         for(w=0; w<Range_dSe1_Bal_W_one; w++)
             {
              if( (dSe1_Bal_W[w][1]==dSe1_Bal_D[d][1]) && (dSe1_Bal_W[w][4]==dSe1_Bal_D[d][4]) )

                  {
                   Count_dSSw++;                                      // Счётчик записей (строк) в массиве dSSw[][90]
                   ArrayResize(dSSw, Count_dSSw, 200000);             // Задайм новый размер массива с резервированием памяти на 100000 записей (строк)  
                   for(S=0,  W=0;   W<45;   W++, S++)
                        dSSw[t][S] = dSe1_Bal_W[w][W];                // Значения строки массива dSe1_Bal_W
                   for(S=45, D=0;   D<45;   D++, S++)
                        dSSw[t][S] = dSe1_Bal_D[d][D];                // Значения строки массива dSe1_Bal_D
                   t++;                                               // Увеличили индекс массива dSSw на "1"
                  }
             }
        }
    Range_dSSw_one = ArrayRange(dSSw, 0);                             // Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSw[][90];
    Range_dSSw_two = ArrayRange(dSSw, 1);                             // Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSw[][90];

    // 3. ПЕЧАТАЕМ найденное в файл
    int LH_Rep=0;                                                     // Хэндл log файла, открытого в директории "logs\\" 
    if(use_Print_Rep_dSS == 1)                                        // =0 -> Условие отключено, =1 -> Печатать в log файл Промежуточные отчёты (dSS)
        {
         if(Count_dSSd>0)
             {
              LogName="Rep_dSSd "+EN;                                 // (Interum Report) Название ЛОГА + Название ЭТОГО ЭКСПЕРТА, передаваемое в log файл
              LH_Rep=log_open(LogName);                               // Хэндл log файла, открытого в директории "logs\\" 
              Fun_Rep_mass90(LH_Rep, dSSd, Count_dSSd);               // Функция F 135 Запись Массива  mass90[][90] в Промежуточный отчёт в *.csv файл
              log_close(LH_Rep);                                      // Закрываем лог-файл этого эксперта
              Alert ("Записан ОТЧЁТ ", LogName);
             }
         if(Count_dSSw>0)
             {
              LogName="Rep_dSSw "+EN;                                 // (Interum Report) Название ЛОГА + Название ЭТОГО ЭКСПЕРТА, передаваемое в log файл
              LH_Rep=log_open(LogName);                               // Хэндл log файла, открытого в директории "logs\\" 
              Fun_Rep_mass90(LH_Rep, dSSw, Count_dSSw);               // Функция F 135 Запись Массива  mass90[][90] в Промежуточный отчёт в *.csv файл
              log_close(LH_Rep);                                      // Закрываем лог-файл этого эксперта
              Alert ("Записан ОТЧЁТ ", LogName);
             }
        }
   }
Leo59:
Per risparmiare spazio e migliorare la percezione - in una sola funzione. Ancora non funziona.

per il futuro - se avete bisogno del risultato della funzione (almeno lavorato/non lavorato), non rendetelo nullo. Ad uno sguardo superficiale è difficile determinare che c'è un criterio di "innescato" - è vuoto, non importa come si lancia tutto è buono.

sui diritti del debugger:

Hai un mucchio di variabili globali Count_XXX, Range_XXX, che converti (più gli array dSSxx[]), li usi per decidere se registrare o meno e poi li passi da qualche parte, o per riferimento o per valore...

c'è ovviamente qualcosa di sbagliato nel loro ricalcolo - Count_dSS ottiene 0 quando lo chiami di nuovo. La stampa può aiutare a capirlo o i punti di rottura e guardare.

Maxim Kuznetsov:

per il futuro - se avete bisogno del risultato della funzione (almeno ha funzionato o no), non rendetelo nullo. A colpo d'occhio, è difficile determinare quale sia il criterio di "innescato" - è vuoto, non importa come lo lanci, tutto è buono.

sui diritti del debugger:

avete un mucchio di variabili globali Count_XXX, Range_XXX, che convertite (più gli array dSSxx[]), in base ad esse decidete se registrare o meno e poi passate da qualche parte o per riferimento o per valore...

c'è ovviamente qualcosa di sbagliato nel loro ricalcolo - Count_dSS ottiene 0 quando lo chiami di nuovo. La stampa può aiutare a capirlo o i punti di rottura e guardare.

A quale callback ti riferisci?
Una versione semplificata:
double   dSSd[][90];                   // Динамический Массив SelectSort соответствия пары массива dSe1_Bal_W паре массива dSe1_Bal_D
int      Count_dSSd=0;                 // Счётчик записей (строк) в массиве dSSd[][90]
int      Range_dSSd_one=0;             // = ArrayRange(dSS, 0);  Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSd[][90];
int      Range_dSSd_two=0;             // = ArrayRange(dSS, 1);  Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSd[][90];

double   dSSw[][90];                   // Динамический Массив SelectSort соответствия пары массива dSe1_Bal_W паре массива dSe1_Bal_D
int      Count_dSSw=0;                 // Счётчик записей (строк) в массиве dSSw[][90]
int      Range_dSSw_one=0;             // = ArrayRange(dSS, 0);  Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSw[][90];
int      Range_dSSw_two=0;             // = ArrayRange(dSS, 1);  Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSw[][90];

int init()
   {
    ArrayResize(dSSd, 200000, 200000);                                // Задаём новый размер массива с резервированием памяти на 200000 записей (строк)  
    ArrayResize(dSSw, 200000, 200000);                                // Задаём новый размер массива с резервированием памяти на 200000 записей (строк)  
    Fun_Select_2();
    return(0);
   }

void Fun_Select_2()                                                   
   {
    //    Находим соответствие между [1]-"Num1 А" и [4]-"Num1 B" в массивах dSe1_Bal_D и dSe1_Bal_W
    int t=0;                                                          // Техническая переменная
    int d=0;                                                          // Техническая переменная
    int w=0;                                                          // Техническая переменная
    int D=0;                                                          // Техническая переменная
    int W=0;                                                          // Техническая переменная
    int S=0;                                                          // Техническая переменная

    //    Если есть соответствие тогда записываем её в массив dSSd[][90]

    for(d=0, t=0; d<Range_dSe1_Bal_D_one; d++)
        {
         for(w=0; w<Range_dSe1_Bal_W_one; w++)
             {
              if( (dSe1_Bal_W[w][1]==dSe1_Bal_D[d][1]) && (dSe1_Bal_W[w][4]==dSe1_Bal_D[d][4]) )
                  {
                   Count_dSSd++;                                      // Счётчик записей (строк) в массиве dSSd[][90]
                   ArrayResize(dSSd, Count_dSSd, 200000);             // Задаём новый размер массива с резервированием памяти на 100000 записей (строк)  
                   for(S=0,  D=0;   D<45;   D++, S++)
                        dSSd[t][S] = dSe1_Bal_D[d][D];                // Значения строки массива dSe1_Bal_D
                   for(S=45, W=0;   W<45;   W++, S++)
                        dSSd[t][S] = dSe1_Bal_W[w][W];                // Значения строки массива dSe1_Bal_W
                   t++;                                               // Увеличили индекс массива dSSd на "1"
                  }
             }
        }
    Range_dSSd_one = ArrayRange(dSSd, 0);                             // Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSd[][90];
    Range_dSSd_two = ArrayRange(dSSd, 1);                             // Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSd[][90];

    //    Если есть соответствие тогда записываем её в массив dSSw[][90]
   for(d=0, t=0; d<Range_dSe1_Bal_D_one; d++)
        {
         for(w=0; w<Range_dSe1_Bal_W_one; w++)
             {
              if( (dSe1_Bal_W[w][1]==dSe1_Bal_D[d][1]) && (dSe1_Bal_W[w][4]==dSe1_Bal_D[d][4]) )
                  {
                   Count_dSSw++;                                      // Счётчик записей (строк) в массиве dSSw[][90]
                   ArrayResize(dSSw, Count_dSSw, 200000);             // Задаём новый размер массива с резервированием памяти на 100000 записей (строк)  
                   for(S=0,  W=0;   W<45;   W++, S++)
                        dSSw[t][S] = dSe1_Bal_W[w][W];                // Значения строки массива dSe1_Bal_W
                   for(S=45, D=0;   D<45;   D++, S++)
                        dSSw[t][S] = dSe1_Bal_D[d][D];                // Значения строки массива dSe1_Bal_D
                   t++;                                               // Увеличили индекс массива dSSw на "1"
                  }
             }
        }
    Range_dSSw_one = ArrayRange(dSSw, 0);                             // Размер первого измерения (число строк)    с индексом_измерения=[0] массива dSSw[][90];
    Range_dSSw_two = ArrayRange(dSSw, 1);                             // Размер второго измерения (число столбцов) с индексом_измерения=[1] массива dSSw[][90];
   }

// Получаенный результат:

// Count_dSSd     = 280
// Range_dSSd_one = 280
// Range_dSSd_two = 90
// Массив dSSd заполнен правильными значениями

// Count_dSSw     = 280
// Range_dSSw_one = 0
// Range_dSSw_two = 90
// Массив dSSw заполнен "0"
// L'essenza del problema è la seguente:
// Ci sono due array dinamici A[][2] e B[][2]
// stiamo cercando delle corrispondenze per l'indice della prima dimensione "0".
// Matrice A Matrice B
// 31 25 19 66
// 44 15 62 30
// 62 47 54 71
// 31 94
// Vogliamo ottenere:
// Array dSSd[][4] Array dSSw[][4]
// 31 25 31 94 31 94 31 25
// 62 47 62 30 62 30 62 47
Leo59:
Quale richiamo ha in mente?
Una versione semplificata:

Mi riferisco a una funzione simile alla prima (che può essere diversa nei dettagli). Hai fatto la stessa domanda - perché queste funzioni funzionano separatamente, ma una dopo l'altra (indipendentemente dall'ordine) no. Più precisamente, solo la prima funzione funziona e registra qualcosa.

bene - scopa lo stato globale, cioè la prima chiamata della prima di queste funzioni ha cambiato o le variabili globali o il contenuto degli array. Perché? Dovresti saperlo meglio, perché dovrebbe cambiare quando si scrive su un file:-) Onestamente - sfondare 

Range_dSe1_Bal_W_one

Io, per esempio, lo trovo difficile e riluttante. Procuratevi un debugger o mettete già delle stampanti in tutti i posti sospetti. Capite la logica dei nomi e avete un'idea di come dovrebbe funzionare (non coincide con la realtà però :-) ).

PS/ dalla spiegazione di cosa c'è in ingresso e cosa in uscita, vedo che invece di due array dSSx[][4] è sufficiente e uno dSS[][3] :-)

Maxim Kuznetsov:

Mi riferisco a una funzione simile alla prima (che può essere diversa nei dettagli). Hai fatto la stessa domanda - perché queste funzioni funzionano individualmente, ma una dopo l'altra (indipendentemente dall'ordine) no. Più precisamente, solo la prima funzione funziona e registra qualcosa.

Quindi - lo stato globale è fottuto, cioè la prima chiamata della prima di queste funzioni ha cambiato le variabili globali o il contenuto degli array. Forse tu sai meglio perché dovrebbero cambiarlo quando scrivono sul file:-). Onestamente - sfondare

Io, per esempio, lo trovo difficile e riluttante. Procuratevi un debugger o mettete già delle stampanti in tutti i posti sospetti. Capite la logica dei nomi e avete un'idea di come dovrebbe funzionare (che non coincide con la realtà :-) )

PS/ dalla spiegazione di cosa c'è in ingresso e cosa in uscita, vedo che invece di due array dSSx[][4] è sufficiente e uno dSS[][3] :-)

Maxim, grazie per non essere indifferente. Il problema è risolto. Si è rivelata una questione di memoria insufficiente.
1...611612613614615616617618619620621622623624625...1504
Nuovo commento