Was sollte zur zusätzlichen Unterstützung von universellen mathematischen Berechnungen in MQL5 und MQL5 Cloud Network hinzugefügt werden? - Seite 9

Neuer Kommentar
 

Ja, Spiele geben einen Kick in Sachen Leistung und Technik. Denn sie bringen die Hardware auf ein qualitatives Niveau. (Obwohl ein Professor, den ich an der Uni kenne, Spiele aus irgendeinem Grund als das universelle Böse betrachtet :)

Was die Universalität der Funktionen betrifft, so finden Sie hier Hinweise für die weitere schrittweise Umsetzung

- Wettervorhersage
- wissenschaftliche Datenverarbeitung (Raumfahrt, Kernphysik)
- Pharmazie
- 3D-Rendering (als praktische Anwendung für Geld)

und dann kommen Sie vielleicht zur Börsenprognose...

PS.
Und mit UCI, wie ich sagte, könnte einen Antrag für MT machen :)

 
sergeev:

Ich spreche nicht von der Cloud, denn deren Möglichkeiten sind klar. Es kann auch außerhalb von MT verwendet werden.

Ich spreche von MT.

Ich sehe nichts Falsches daran, einen Schachbot-Wettbewerb auf der Grundlage von MT zu veranstalten. Und genau diese Bots werden die Rechenressourcen der Cloud nutzen.

 

Vielleicht sollten Sie tatsächlich das Forex-Spielen aufgeben und stattdessen Schach spielen? Ich war früher ziemlich gut darin.

Aber ich mag Backgammon lieber. Vielleicht könnte jemand Backgammon auf MT5 programmieren, ich wäre ewig dankbar.

 
Poker! Lasst uns die EPT aufmischen!))
 
pronych:
Poker! Lasst uns die EPT aufmischen!)))
Es gibt keinen Grund für diese Art von Macht dort.
 
Wir werdendas Neurodrive-Projekt auf jeden Fall umsetzen, während wir mit Signalen beschäftigt sind. Wir haben große Pläne für neuronale Netze im MT5.

Wenn wir es in Angriff nehmen, ziehen wir es auch durch. Zum Beispiel haben wir AlgLib komplett selbst implementiert, obwohl es die Idee gab, die Gemeinschaft mit einzubeziehen.

Bisher hat man das Gefühl, dass nur wenige Leute wirklich an den überfinanzierten Projekten teilnehmen und ihre Zeit investieren wollen.
 
Renat:

Bislang hat man das Gefühl, dass nur wenige Menschen wirklich an den überlasteten Projekten teilnehmen und ihre Zeit verschwenden wollen.

Ich habe keine Erfahrung. Ich dachte, Sie hätten damals versprochen, jemanden aus Ihrem Team als Mentor für das Projekt einzusetzen.

Und ohne einen Hirten werden sich die Schafe zerstreuen. Wenn also jemand etwas in der Gemeinschaft tut, ist er allein für seine Arbeit verantwortlich.

 
sergeev :

keine Erfahrung. Sie haben gewissermaßen versprochen, jemanden aus Ihrem Team zum Kurator für das Projekt zu machen.

aber ohne Hirten werden die Schafe zerstreut. Wenn also jemand etwas in der Gemeinschaft tut, dann ist nur er allein für seine Arbeit verantwortlich.

Mehr als Erfahrung in der Boltologie. Lass uns so blenden, lass uns so sitzen usw. usw. in Übereinstimmung mit der Fabel von Großvater Krylov namens Quartett. Niemand tut etwas, alle mit klugen Gesichtern äußern nur ihre Meinung.

Es braucht keinen Kurator, der alle mit einem Stock antreibt. Der Projektleiter muss die ersten Codezeilen erstellen – die Schnittstellen zukünftiger Klassen, ab denen schon mehr oder weniger klar ist, wo weiter getanzt werden muss und wo die Sackgasse ist. Und dann begründet irgendein Projektbeteiligter, was er genau vorhat, und wenn seine potenzielle Tätigkeit der allgemeinen Richtung nicht widerspricht, wird er mit der Umsetzung seiner Idee betraut. Dann verbindet sich ein anderer Teilnehmer. Usw. usw.

Hier gab es zum Beispiel Freizeit, hier habe ich einige Skizzen von Klassen für ein Schachprogramm geworfen:

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


Jetzt können Sie ein Projekt im Repository erstellen und weitere Entwickler damit verbinden. Aber nicht alle, die dort irgendeine Meinung äußern wollen, sondern diejenigen, die etwas Bestimmtes tun werden.

 

Yuri, bei den Schachengines ist es ziemlich klar - das Thema ist von anderen Leuten sehr gut ausgearbeitet worden.

Wenn man sich darauf einlässt, muss man die gesammelten Erfahrungen und die 10000-prozentige Menge an anfänglichen und extrem zermürbenden Optimierungen (Bitkarten, Voreinstellungen usw.) nutzen.

Mit dem ABC und Fehlern kann man nicht von vorne anfangen. Keine "vorzeitige Optimierung ist böse". Hier brauchen Sie sofort eine extreme Erfahrung in der Durchführung von schachbasierten numerischen Berechnungen.

Glücklicherweise gibt es viele Artikel, Quellen und ausführliche Erklärungen dazu im öffentlichen Bereich. Wenn Sie mit der Lektüre des Themas beginnen, werden Sie sofort verstehen, welch extremes Niveau an Lösungen erreicht wurde.

 
Renat:

Yuri, bei den Schachengines ist es ziemlich klar - das Thema ist von anderen Leuten sehr gut ausgearbeitet worden.

Wenn man sich darauf einlässt, muss man die gesammelten Erfahrungen und die 10000-prozentige Menge an anfänglichen und extrem zermürbenden Optimierungen (Bitkarten, Voreinstellungen usw.) nutzen.

Mit ABC und Fehlern kann man nicht bei Null anfangen. Keine "vorzeitige Optimierung ist böse". Hier brauchen Sie sofort eine extreme Erfahrung in der Durchführung von schachbasierten numerischen Berechnungen.

Glücklicherweise gibt es viele Artikel, Quellen und ausführliche Erklärungen dazu im öffentlichen Bereich. Sobald Sie anfangen, über dieses Thema zu lesen, werden Sie sofort verstehen, dass die Lösungen extrem hoch sind.

Ich habe auch etwas Literatur, und Botvinnik ist noch in Papierform. Und ich habe einige Entwicklungen, natürlich nicht in MQL5, sondern in muLisp.

Ich habe versucht, einigen lokalen Projektträgern zu zeigen, dass sie für ihre Projekte keine Aufsichtspersonen brauchen. Ich benötige ein Team von spezifischen Entwicklern, die vielleicht nicht alle Technologien beherrschen und sogar Spezialisten auf ihrem Gebiet sein können, aber dennoch kompetent auf ihrem Gebiet sind. Und Sie brauchen einen Projektleiter, der all dies zunächst durchdenkt und für den Rest des Teams vorbereitet, damit das Projekt nicht bei Null anfängt und Sie nach dem einleitenden Exkurs gleich loslegen können. Andernfalls werden die Dinge nicht in Gang kommen.

1234567891011
Neuer Kommentar
Grund der Beschwerde: