Domande su OOP in MQL5 - pagina 95

Nuovo commento
 
Maxim Kuznetsov:

la GA è più una "parola d'ordine". Come può il codice di Gray aiutare la convergenza? Solo teoricamente...

si potrebbe anche mischiare a caso

Non sto dicendo niente, non credo a tutto quello che viene scritto su internet da molto tempo, cerco di controllare tutto

Ecco un codice di conversione funzionante nel codice di Gray e ritorno

//+------------------------------------------------------------------+
uint IntToGrey(const uint value) // https://e-maxx.ru/algo/gray_code
  {  return(value ^ (value >> 1)); }
//+------------------------------------------------------------------+
uint GreyToInt(const uint value) // https://e-maxx.ru/algo/gray_code
  {
   uint n = 0;
   for(uint g = value; g != 0; g >>= 1)
     {
      n ^= g;
     }
   return(n);
  }
//+------------------------------------------------------------------+
 
E questo come influenzerebbe l'algoritmo genetico? L'algoritmo genetico non dovrebbe rispondere ai valori se è puramente genetico. Se viene utilizzata una media aggiuntiva o la discesa del gradiente, questo può influire su di essa. Ma in questo caso è meglio risolvere il problema in modo diretto - filtrare il parametro attraverso l'array e mescolare l'array. Il valore del parametro ottimizzato dalla finestra delle proprietà è un indice dell'elemento dell'array, e il valore dell'array sarà usato nell'Expert Advisor stesso. Allora l'ottimizzatore può essere ingannato. Ma solo se la convergenza avviene grazie alla media o alla discesa del gradiente. Ma se si tratta di un puro algoritmo genetico, non riesco a immaginare a cosa possa servire. Qual è il punto? Da dove crescono le gambe?
 

c'è questo codice:

class A
{
private:
   const int _a;
public:
   A(const int a): _a(a) { Print(_a); }
};
//+------------------------------------------------------------------+
class B
{
private:
   const A a;
public:
   B(const int b): a(b) {}
};
//+------------------------------------------------------------------+
void OnStart()
{
   B b(3);// 3
}
//+------------------------------------------------------------------+

tutto è OK, ma ho bisogno di un array di oggetti A, cioè ne ho bisogno come questo:

class B
{
private:
   const A a[2];
public:
   B(const int b): a[0](b),a[1](b) {}  //'[' - member(s) initialization expected
                                       // 'a' - explicit initializer for arrays not allowed
};

c'è un modo per chiamare un costruttore per un array di oggetti senza usare puntatori?

 
Igor Makanu:

c'è questo codice:

tutto è OK, ma ho bisogno di un array di oggetti A, cioè ne ho bisogno come questo:

c'è un modo per chiamare un costruttore per un array di oggetti senza usare puntatori?

No, solo attraverso le stampelle.
 

È possibile per questo codice:

//+------------------------------------------------------------------+
struct LIST;
struct MyStruct
{
   double            d_data;
   int               i_data;
   MyStruct() {}
   MyStruct(const int i_v, const double d_v): d_data(d_v), i_data(i_v) {}
   LIST              operator+(MyStruct &value)
   {
      LIST result;
      ArrayResize(result.arr, 2, 10);
      result.arr[0] = this;
      result.arr[1] = value;
      return(result);
   }
   MyStruct          operator*(const double mult)
   {
      MyStruct result = this;
      result.d_data *= mult;
      return(result);
   }
};
//+------------------------------------------------------------------+
struct LIST
{
   MyStruct          arr[];
   LIST              operator+(MyStruct &value)
   {
      int last = ArraySize(this.arr);
      ArrayResize(this.arr, last + 1, 10);
      this.arr[last] = value;
      return(this);
   }
};
//+------------------------------------------------------------------+
void OnStart()
{
   MyStruct a(1, 1.11), b(2, 2.22), c(3, 3.33);
   LIST x = a + b + c * 2;
   ArrayPrint(x.arr);
//    [d_data] [i_data]
//[0]  1.11000        1
//[1]  2.22000        2
//[2]  6.66000        3
}
//+------------------------------------------------------------------+

per LISTA per fare un modello / template ?

Non ha funzionato la prima volta ((().

 
Igor Makanu:

È possibile per questo codice:

per LISTA per fare un modello / template ?

non ha funzionato la prima volta ((.

questo. rimuovere

UPD: hmm... hai capito tutto))))

UPD: ottenere il yum))))

//+------------------------------------------------------------------+
template<typename T>
struct LIST
{
   T          arr[];
   LIST<T>              operator+(T &value)
   {
      int last = ArraySize(arr);
      ArrayResize(arr, last + 1, 10);
      arr[last] = value;
      return(this);
   }
};
//+------------------------------------------------------------------+
struct MyStruct
{
   double            d_data;
   int               i_data;
   MyStruct() {}
   MyStruct(const int i_v, const double d_v): d_data(d_v), i_data(i_v) {}
   LIST<MyStruct>              operator+(MyStruct &value)
   {
      LIST<MyStruct> result;
      ArrayResize(result.arr, 2, 10);
      result.arr[0] = this;
      result.arr[1] = value;
      return(result);
   }
   MyStruct          operator*(const double mult)
   {
      MyStruct result = this;
      result.d_data *= mult;
      return(result);
   }
};
//+------------------------------------------------------------------+
void OnStart()
{
   MyStruct a(1, 1.11), b(2, 2.22), c(3, 3.33);
   LIST<MyStruct> x = a + b + c * 2;
   ArrayPrint(x.arr);
//    [d_data] [i_data]
//[0]  1.11000        1
//[1]  2.22000        2
//[2]  6.66000        3
}
 
Vladimir Simakov:

questo. rimuovere

UPD: hmmm... hai capito tutto))))

UPD: prendere lo yum-yum)))

Grazie! - funziona!

il codice è minimalista, funziona - voglio un array di strutture, le liste non sono sempre convenienti, tutto funziona, è chiaro che situazioni non standard utilizzando questo codice possono essere simulate, ma il codice una dozzina di righe

 

perché questo codice non dà un errore del compilatore quando si accede al campo privato di qualcun altro:

class A
{
private:
   int _value;
public:
  void set(const int value)      { _value = value;    }
  int  get()                     { return(_value);    }
  void set(A &a, const int value){ a._value = value;  }
};

void OnStart()
{
  A x,y;
  x.set(10);
  y.set(20);
  Print("x = ",x.get());   // 10
  Print("y = ",y.get());   // 20
  y.set(x,777);
  Print("x = ",x.get());   // 777
  Print("y = ",y.get());   // 20
}
//+------------------------------------------------------------------+
 
è il suo campo privato
 
Andrei Trukhanovich:
questo è il suo campo privato

OK, grazie!

Ma se una classe derivata in una classe madre cambia i campi privati allo stesso modo, è "legale"?

cioè in un modo simile:

class B: private A
{
        A a;
        void setA(A &obj, const int value) { a.set(obj,value); }
}
....
A x;
B y;
y.(x.55)
1...888990919293949596
Nuovo commento