Cosa si dovrebbe aggiungere per un ulteriore supporto dei calcoli matematici universali in MQL5 e MQL5 Cloud Network?

--- 2012.10.31 09:46 #81

Sì, i giochi danno un calcio nelle prestazioni e nella tecnologia. Perché tirano l'hardware ad un livello qualitativo. (Anche se un professore che conosco all'università considerava i giochi come il male universale per qualche motivo :)

Per quanto riguarda l'universalità delle funzioni, ecco le indicazioni per un'ulteriore implementazione passo dopo passo

- previsioni del tempo
- elaborazione di dati scientifici (spazio, fisica nucleare)
- galenica
- Rendering 3D (come applicazione pratica per il denaro)

e poi arriveremo alle previsioni di scambio...

PS.
E con UCI, come ho detto, potrebbe fare una domanda per MT :)

FOREX - Tendenze, previsioni Ecco cosa si può Lega dei sistemi di

Yury Reshetov 2012.10.31 10:01 #82

sergeev:

Le capacità della nuvola sono chiare. Può essere usato anche al di fuori di MT.

Sto parlando di MT.

Non vedo nulla di male nell'organizzare una competizione di chess bot sulla base di MT. E questi stessi bot useranno le risorse di calcolo del cloud.

Serj 2012.10.31 18:14 #83

Forse rinunciare davvero a giocare a forex e giocare a scacchi? Una volta ero abbastanza bravo.

Ma io preferisco il backgammon. Forse qualcuno potrebbe programmare il backgammon su MT5, gliene sarei eternamente grato.

Aleksey 2012.10.31 18:57 #84

Poker! Facciamo a pezzi l'EPT!))

TheXpert 2012.10.31 19:02 #85

pronych:
Poker! Facciamo a pezzi l'EPT!)))

Non c'è bisogno di quel tipo di potere lì dentro.

Renat Fatkhullin 2012.10.31 19:30 #86

Implementeremo sicuramenteil progetto neurodrive, mentre siamo impegnati con i segnali. Abbiamo grandi progetti sulle reti neurali in MT5.

Se ci impegniamo, lo facciamo. Per esempio, abbiamo implementato AlgLib interamente da soli, anche se c'era l'idea di coinvolgere la comunità.

Finora, c'è la sensazione che poche persone vogliano davvero partecipare ai progetti oversourced e spendere il loro tempo.

Interessante e umorismo Sistema di lavaggio del Sviluppo collaborativo del progetto

--- 2012.10.31 19:40 #87

Renat:

Finora, c'è la sensazione che poche persone vogliano davvero essere coinvolte nei progetti di oversourced e perdere il loro tempo.

Non ho nessuna esperienza. Pensavo che avessi promesso di fare di qualcuno del tuo team un mentore per il progetto all'epoca.

E senza un pastore, le pecore si disperderanno. Quindi, se qualcuno fa qualcosa nella comunità, è l'unico responsabile del suo lavoro.

Quali sono le opzioni [Qualsiasi domanda da principiante, Bisogno di aiuto con

Yury Reshetov 2012.10.31 20:32 #88

sergeev :

nessuna esperienza. hai in qualche modo promesso di nominare qualcuno della tua squadra curatore del progetto.

ma senza pastore le pecore saranno disperse. Pertanto, se qualcuno fa qualcosa nella comunità, solo lui solo è responsabile del suo lavoro.

Più che esperienza in Boltologia. Diventiamo ciechi così, sediamoci così, ecc. eccetera. secondo la favola del nonno Krylov chiamato il Quartetto. Nessuno fa niente, tutti quelli con la faccia intelligente esprimono solo le proprie opinioni.

Non c'è bisogno di un curatore per spingere tutti ad andare avanti con un bastone. Il project manager deve creare le prime righe di codice: le interfacce delle classi future, da cui sarà già più o meno chiaro dove ballare ulteriormente e dove si trova il vicolo cieco. E poi, un partecipante al progetto giustifica esattamente cosa farà, e se la sua potenziale attività non contraddice la direzione generale, allora gli viene affidata l'attuazione della sua idea. Quindi un altro partecipante si connette. Eccetera. eccetera.

Qui, ad esempio, c'era del tempo libero, qui ho lanciato alcuni schizzi di lezioni per un programma di scacchi:

 //+------------------------------------------------------------------+
//|                                                    CChessman.mqh |
//|                                 Copyright 2012, Yury V. Reshetov |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Yury V. Reshetov"
#property link       "http://www.mql5.com"

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CChessman // Класс: шахматная фигура
  {
private :
   int                type; // Тип фигуры: 
                           // 0 - пешка,
   // 1 - ладья
   // 2 - конь
   // 3 - слон
   // 4 - ферзь
   // 5 - король
   int                c; // Цвет фигуры: 0 - белый, 1 - черный 
   int                h; // Положение фигуры по горизонтали
   int                v; // Положение фигуры по вертикали
   bool               state; // Состояние фигуры: true - на доске, false - взята противником

public :
   void               CChessman( int t, int horisontal, int vertical, int group ); // Конструктор
   void              ~CChessman(); // Деструктор
                                   // Изменение местонахождения фигуры на доске
   // Возвращает результат, если изменение корректно и было выполнено
   bool               setPosition( int horisontal, int vertical); // Изменение позиции фигуры на доске
   void               erase(); // Вызывается, если фигура взята противником
   int                getType(); // Возвращает тип фигуры
   int                getHPosition(); // Возвращает положение фигуры на доске по вертикали
   int                getVPosition(); // Возвращает положение фигуры на доске по горизонтали
   int                getColor(); // Возвращает цвет фигуры
   bool               getState(); // Возвращает текущий статус фигуры
  };
//+------------------------------------------------------------------+
//|    Конструктор                                                   |
//+------------------------------------------------------------------+
void CChessman::CChessman( int t, int horisontal, int vertical, int group ) 
  {
   state= true ;
   type = t;
   h = horisontal;
   v = vertical;
   c = group ;
  }
//+------------------------------------------------------------------+
//|      Изменение позиции фигуры на доске                           |
//+------------------------------------------------------------------+
bool CChessman::setPosition( int horisontal, int vertical) 
  {
   if (!state) 
     {
       return ( false );
     }
   if (horisontal< 0 ) 
     {
       return ( false );
     }
   if (horisontal> 7 ) 
     {
       return ( false );
     }
   if (vertical< 0 ) 
     {
       return ( false );
     }
   if (vertical> 7 ) 
     {
       return ( false );
     }
   h = horisontal;
   v = vertical;
   return ( true );
  }
//+------------------------------------------------------------------+
//|       Удаление фигуры с доски                                    |
//+------------------------------------------------------------------+
void CChessman::erase( void ) 
  {
   state= false ;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CChessman::getType( void ) 
  {
   return (type);
  }
//+------------------------------------------------------------------+
//|         Возвращает горизонтальное положение фигуры на доске      |
//+------------------------------------------------------------------+
int CChessman::getHPosition( void ) 
  {
   return (h);
  }
//+------------------------------------------------------------------+
//|         Возвращает вертикальное положение фигуры на доске        |
//+------------------------------------------------------------------+
int CChessman::getVPosition( void ) 
  {
   return (v);
  }
//+------------------------------------------------------------------+
//|        Возвращает цвет фигуры                                    |
//+------------------------------------------------------------------+
int CChessman::getColor( void ) 
  {
   return (c);
  }
//+------------------------------------------------------------------+
//|         Возвращает статус фигуры                                 |
//+------------------------------------------------------------------+
bool CChessman::getState( void ) 
  {
   return (state);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                              CChessmansArray.mqh |
//|                                 Copyright 2012, Yury V. Reshetov |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Yury V. Reshetov"
#property link       "http://www.mql5.com"
#include <Chess/CChessman.mqh>
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CChessmansArray // Класс: Шахматная доска
  {
private :
   CChessman        *table[]; // Массив шахматных фигур

public :
   void               CChessmansArray(); // Конструктор
   void              ~CChessmansArray(); // Деструктор
   CChessman        *getChessman( int i);
   void               goWhite(); // Ход белых
   void               goBlack(); // Ход черных
  };
//+------------------------------------------------------------------+
//|          Конструктор                                             |
//+------------------------------------------------------------------+
void CChessmansArray::CChessmansArray( void ) 
  {
   ArrayResize (table, 32 );

   table[ 0 ] = new CChessman( 1 , 0 , 0 , 1 ); // Левая белая ладья
   table[ 1 ] = new CChessman( 2 , 1 , 0 , 1 ); // Левый белый конь
   table[ 2 ] = new CChessman( 3 , 2 , 0 , 1 ); // Левый белый слон
   table[ 3 ] = new CChessman( 4 , 3 , 0 , 1 ); // Белый ферзь
   table[ 4 ] = new CChessman( 5 , 4 , 0 , 1 ); // Белый король
   table[ 5 ] = new CChessman( 3 , 5 , 0 , 1 ); // Правый белый слон
   table[ 6 ] = new CChessman( 2 , 6 , 0 , 1 ); // Правый белый конь
   table[ 7 ] = new CChessman( 1 , 7 , 0 , 1 ); // Правая белая ладья

   table[ 0 ] = new CChessman( 0 , 0 , 1 , 1 ); // Белая пешка
   table[ 1 ] = new CChessman( 0 , 1 , 1 , 1 ); // Белая пешка
   table[ 2 ] = new CChessman( 0 , 2 , 1 , 1 ); // Белая пешка
   table[ 3 ] = new CChessman( 0 , 3 , 1 , 1 ); // Белая пешка
   table[ 4 ] = new CChessman( 0 , 4 , 1 , 1 ); // Белая пешка
   table[ 5 ] = new CChessman( 0 , 5 , 1 , 1 ); // Белая пешка
   table[ 6 ] = new CChessman( 0 , 6 , 1 , 1 ); // Белая пешка
   table[ 7 ] = new CChessman( 0 , 7 , 1 , 1 ); // Белая пешка

   table[ 0 ] = new CChessman( 1 , 0 , 7 , - 1 ); // Левая черная ладья
   table[ 1 ] = new CChessman( 2 , 1 , 7 , - 1 ); // Левый черный конь
   table[ 2 ] = new CChessman( 3 , 2 , 7 , - 1 ); // Левый черный слон
   table[ 3 ] = new CChessman( 4 , 3 , 7 , - 1 ); // Черный ферзь
   table[ 4 ] = new CChessman( 5 , 4 , 7 , - 1 ); // Черный король
   table[ 5 ] = new CChessman( 3 , 5 , 7 , - 1 ); // Правый черный слон
   table[ 6 ] = new CChessman( 2 , 6 , 7 , - 1 ); // Правый черный конь
   table[ 7 ] = new CChessman( 1 , 7 , 7 , - 1 ); // Правая Черная ладья

   table[ 0 ] = new CChessman( 0 , 0 , 6 , - 1 ); // Черная пешка
   table[ 1 ] = new CChessman( 0 , 1 , 6 , - 1 ); // Черная пешка
   table[ 2 ] = new CChessman( 0 , 2 , 6 , - 1 ); // Черная пешка
   table[ 3 ] = new CChessman( 0 , 3 , 6 , - 1 ); // Черная пешка
   table[ 4 ] = new CChessman( 0 , 4 , 6 , - 1 ); // Черная пешка
   table[ 5 ] = new CChessman( 0 , 5 , 6 , - 1 ); // Черная пешка
   table[ 6 ] = new CChessman( 0 , 6 , 6 , - 1 ); // Черная пешка
   table[ 7 ] = new CChessman( 0 , 7 , 6 , - 1 ); // Черная пешка

  }
//+------------------------------------------------------------------+
//|       Возвращает объект фигуры по индексу в массиве              |
//+------------------------------------------------------------------+
CChessman *CChessmansArray::getChessman( int i) 
  {
   return (table[i]);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                    CChessBot.mqh |
//|                                 Copyright 2012, Yury V. Reshetov |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Yury V. Reshetov"
#property link       "http://www.mql5.com"
#include <Chess/CChessman.mqh>
#include <Chess/CChessmansArray.mqh>
//+------------------------------------------------------------------+
//|      Класс: бот-шахматист                                        |
//+------------------------------------------------------------------+
class CChessBot // Класс: бот-шахматист
  {
private :
   CChessman        *chessmans[]; // Шахматные фигуры
   int                table[]; // Шахматная доска
   int                c; // Цвет фигур: 0 - белый, 1 - черный

public :
   void               CChessBot( int group); // Конструктор
   void              ~CChessBot(); // Деструктор
   void               setTable(CChessmansArray *t); // Расставляет фигуры
   int                go(); // Ход. Возвращает индекс своей фигуры, которой был сделан ход. 
   int                analitic(); // Анализ ходов 
  };
//+------------------------------------------------------------------+
//|                  Конструктор                                     |
//+------------------------------------------------------------------+
void CChessBot::CChessBot( int group) 
  {
   c=group;
  }
//+------------------------------------------------------------------+
//|                  Расстановка фигур на шахматной доске            |
//+------------------------------------------------------------------+
void CChessBot::setTable(CChessmansArray *mans) 
  {
   ArrayResize (chessmans, 32 );
   ArrayResize (table, 64 );
   for ( int i= 0 ; i< 32 ; i++) 
     {
      chessmans[i]=mans.getChessman(i);
      table[chessmans[i].getHPosition() * 8 + chessmans[i].getVPosition()] = chessmans[i].getType() * 2 + chessmans[i].getColor();
     }
  }
//+------------------------------------------------------------------+
//|             Полуход                                              |
//+------------------------------------------------------------------+
int CChessBot::go( void ) 
  {
   return ( 0 );
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                   CChessGame.mqh |
//|                                 Copyright 2012, Yury V. Reshetov |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Yury V. Reshetov"
#property link       "http://www.mql5.com"
#include <Chess/CChessBot.mqh>
#include <Chess/CChessmansArray.mqh>
#include <Chess/CChessman.mqh>
//+------------------------------------------------------------------+
//|    Класс: Шахматная доска                                        |
//+------------------------------------------------------------------+
class CChessGame  
  {
private :
   CChessmansArray  *chessmans; // Шахматная массив шахматных фигур
   CChessBot        *whitebot; // Бот, играющий белыми
   CChessBot        *blackbot; // Бот, играющий черными

public :
   void               CChessGame(CChessBot *w,CChessBot *b); // Конструктор
   void              ~CChessGame(); // Деструктор
   void               game();   // Игра
   int                goWhite(); // Ход белых
   int                goBlack(); // Ход черных
  };
//+------------------------------------------------------------------+
//|                 Конструктор                                      |
//+------------------------------------------------------------------+
void CChessGame::CChessGame(CChessBot *w,CChessBot *b)
  {
   chessmans= new CChessmansArray();
   whitebot=w;
   whitebot.setTable(chessmans);
   blackbot=b;
   blackbot.setTable(chessmans);
  }
//+------------------------------------------------------------------+
//|           Полуход белых                                          |
//+------------------------------------------------------------------+
int CChessGame::goWhite( void )
  {
   return (whitebot.go());
  }
//+------------------------------------------------------------------+
//|         Полуход черных                                           |
//+------------------------------------------------------------------+
int CChessGame::goBlack( void )
  {
   return (blackbot.go());
  }
//+------------------------------------------------------------------+
//|            Игра                                                  |
//+------------------------------------------------------------------+
void CChessGame::game( void )
  {
   bool stopflag= false ;
   while (!stopflag)
     {
       if (goWhite()>= 0 )
        {
         if (goBlack()>= 0 )
           {
             // ...
           } else {
                  stopflag= false ;
           }
        } else {
               stopflag= false ;
        }
     }
  }
//+------------------------------------------------------------------+

Ora puoi creare un progetto nel repository e connettere altri sviluppatori ad esso. Ma non tutti quelli che vogliono esprimere un qualche tipo di opinione lì, ma tra quelli che faranno qualcosa di specifico.

Interessante e umorismo La sezione "Service Desk" Tutte le domande dei

Renat Fatkhullin 2012.10.31 20:39 #89

Yuri, è abbastanza chiaro con i motori a scacchi - l'argomento è stato elaborato da altre persone molto bene.

Se lo prendi, devi usare l'esperienza accumulata e l'insieme del 10000 per cento di ottimizzazioni iniziali ed estremamente dentali (bitcard, preset, ecc.).

Non si può partire da zero con l'ABC e gli errori. Nessuna "ottimizzazione prematura è il male". Qui è necessaria subito un'estrema esperienza nell'implementazione di calcoli numerici basati sugli scacchi.

Fortunatamente ci sono molti articoli, fonti e spiegazioni dettagliate nel pubblico dominio. Quando inizierete a leggere sull'argomento, capirete immediatamente l'estremo livello di soluzioni raggiunte.

Il terminale MT5 è [Archivio!] Scriverò un consulente I vostri simboli e

Yury Reshetov 2012.10.31 20:54 #90

Renat:

Yuri, è abbastanza chiaro con i motori a scacchi - l'argomento è stato elaborato da altre persone molto bene.

Se lo si assume, si deve usare l'esperienza accumulata e il 10000 per cento di ottimizzazioni iniziali ed estremamente dentate (bitcard, preset, ecc.).

Non si può partire da zero con l'ABC e gli errori. Nessuna "ottimizzazione prematura è il male". Qui è necessaria subito un'estrema esperienza nell'implementazione di calcoli numerici basati sugli scacchi.

Fortunatamente ci sono molti articoli, fonti e spiegazioni dettagliate nel pubblico dominio. Non appena inizierete a leggere sull'argomento capirete immediatamente l'estremo livello di soluzioni raggiunte.

Ho anche della letteratura, e Botvinnik è ancora in forma cartacea. E ho alcuni sviluppi, ovviamente, non in MQL5, ma in muLisp.

Ho cercato di mostrare ad alcuni sviluppatori locali che non hanno bisogno di supervisori per i loro progetti. Ho bisogno di un team di sviluppatori specifici, che possono non essere esperti in tutte le tecnologie, e possono anche essere specialisti nel loro campo, ma comunque sono competenti nel loro campo. E avete bisogno di un project manager che inizialmente pensi e prepari tutto questo per il resto della squadra, in modo che il progetto non parta da zero, e possiate mettervi subito al lavoro, dopo l'excursus introduttivo. Altrimenti, le cose non decolleranno.

OOP vs programmazione procedurale ASAR Come assicurarsi che l'EA

Cosa si dovrebbe aggiungere per un ulteriore supporto dei calcoli matematici universali in MQL5 e MQL5 Cloud Network? - pagina 9