Que faut-il ajouter pour une prise en charge supplémentaire des calculs mathématiques universels dans MQL5 et MQL5 Cloud Network ? - page 9

Nouveau commentaire
 

Oui, les jeux donnent un coup de pouce aux performances et à la technologie. Parce qu'ils font passer le matériel à un niveau qualitatif. (Bien qu'un professeur que je connais à l'université considérait les jeux comme le mal universel pour une raison quelconque :)

Quant à l'universalité des fonctions, voici des indications pour une mise en œuvre plus poussée, étape par étape

- prévisions météorologiques
- traitement des données scientifiques (espace, physique nucléaire)
- pharmacie
- Rendu 3D (en tant qu'application pratique pour l'argent)

et alors, vous pourrez arriver à la prévision d'échange...

PS.
Et avec l'UCI, comme je l'ai dit, on pourrait faire une demande pour MT :)

 
sergeev:

Je ne parle pas du nuage. Les capacités du nuage sont claires. Il peut également être utilisé en dehors de MT.

Je parle de MT.

Je ne vois rien de mal à organiser une compétition de robots d'échecs sur la base de MT. Et ces mêmes bots utiliseront les ressources informatiques du nuage.

 

Peut-être qu'en fait, il faut abandonner le forex et jouer aux échecs ? J'étais plutôt bon à ça.

Mais je préfère le backgammon. Peut-être que quelqu'un pourrait programmer le backgammon sur MT5, je lui en serais éternellement reconnaissant.

 
Le poker ! Déchirons l'EPT !))
 
pronych:
Le poker ! Déchirons l'EPT !)))
il n'y a pas besoin de ce genre de pouvoir.
 
Nous allons certainement mettre en œuvre leprojet neurodrive, pendant que nous sommes occupés avec les signaux. Nous avons de grands projets concernant les réseaux neuronaux dans MT5.

. Si nous nous engageons, nous le faisons. Par exemple, nous avons implémenté AlgLib entièrement par nous-mêmes, bien qu'il y ait eu une idée d'impliquer la communauté.

Jusqu'à présent, on a le sentiment que peu de gens veulent vraiment participer aux projets surdimensionnés et y consacrer leur temps.
 
Renat:

Jusqu'à présent, on a le sentiment que peu de gens veulent vraiment participer aux projets surchargés et perdre leur temps.

Je n'ai pas d'expérience. Je pensais que vous aviez promis de faire de quelqu'un de votre équipe un mentor pour le projet à l'époque.

Et sans berger, les moutons se disperseront. Ainsi, si quelqu'un fait quelque chose dans la communauté, il est le seul responsable de son travail.

 
sergeev :

Pas d'expérience. vous avez en quelque sorte promis de faire de quelqu'un de votre équipe un conservateur du projet.

mais sans berger, les brebis seront dispersées. Par conséquent, si quelqu'un fait quelque chose dans la communauté, alors lui seul est responsable de son travail.

Plus qu'une expérience en boltologie. Aveugle comme ça, asseyons-nous comme ça, etc. etc. conformément à la fable du grand-père Krylov appelé le Quatuor. Personne ne fait rien, tout le monde avec des visages intelligents n'exprime que ses opinions.

Aucun curateur n'est nécessaire pour pousser tout le monde avec un bâton. Le chef de projet doit créer les premières lignes de code - les interfaces des futures classes, à partir desquelles il sera déjà plus ou moins clair où danser plus loin, et où est l'impasse. Et puis, un participant au projet justifie exactement ce qu'il va faire, et si son activité potentielle ne contredit pas la direction générale, alors il se voit confier la mise en œuvre de son idée. Ensuite, un autre participant se connecte. Etc. etc.

Ici, par exemple, il y avait du temps libre, ici j'ai jeté quelques croquis de cours pour un programme d'échecs:

 //+------------------------------------------------------------------+
//|                                                    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 ;
        }
     }
  }
//+------------------------------------------------------------------+


Vous pouvez maintenant créer un projet dans le référentiel et y connecter des développeurs supplémentaires. Mais pas tous ceux qui veulent exprimer une opinion là-bas, mais parmi ceux qui vont faire quelque chose de spécifique.

 

Yuri, c'est assez clair avec les moteurs d'échecs - le sujet a été très bien travaillé par d'autres personnes.

Si vous vous lancez dans l'aventure, vous devez utiliser l'expérience accumulée et l'ensemble des optimisations initiales à 10000 pour cent et extrêmement grinçantes (bitcards, presets, etc.).

Vous ne pouvez pas repartir de zéro avec des ABC et des erreurs. Pas de "l'optimisation prématurée est un mal". Ici, vous avez besoin à la fois d'une expérience extrême dans la mise en œuvre de calculs numériques basés sur les échecs.

Heureusement, il existe de nombreux articles, sources et explications détaillées dans le domaine public. En commençant à lire sur le sujet, vous comprendrez immédiatement le niveau extrême des solutions obtenues.

 
Renat:

Yuri, c'est assez clair avec les moteurs d'échecs - le sujet a été très bien travaillé par d'autres personnes.

Si vous l'assumez, vous devez utiliser l'expérience accumulée et le jeu de 10000 pour cent d'optimisations initiales et extrêmement dentées (bitcards, presets, etc.).

On ne peut pas repartir de zéro avec des ABC et des erreurs. Pas de "l'optimisation prématurée est un mal". Ici, vous avez besoin à la fois d'une expérience extrême dans la mise en œuvre de calculs numériques basés sur les échecs.

Heureusement, il existe de nombreux articles, sources et explications détaillées dans le domaine public. Dès que vous commencerez à lire sur le sujet, vous comprendrez immédiatement le niveau extrême des solutions atteintes.

J'ai aussi de la littérature, et Botvinnik est toujours sous forme de papier. Et j'ai quelques développements, bien sûr, pas dans MQL5, mais dans muLisp.

J'ai essayé de montrer à certains développeurs locaux, qu'ils n'ont pas besoin de superviseurs pour leurs projets. J'ai besoin d'une équipe de développeurs spécifiques, qui ne sont peut-être pas experts dans toutes les technologies, et peuvent même être des spécialistes dans leur domaine, mais qui sont néanmoins compétents dans leur domaine. Et vous avez besoin d'un chef de projet qui, dans un premier temps, réfléchira à tout cela et le préparera pour le reste de l'équipe, afin que le projet ne parte pas de zéro et que vous puissiez vous y mettre tout de suite, après l'excursus introductif. Sinon, les choses ne décolleront pas.

1234567891011
Nouveau commentaire