programmation
Maintenant vous lisez
MQL pratiquement. Algo Trader cz. I [cours de programmation]
0

MQL pratiquement. Algo Trader cz. I [cours de programmation]

établi Radek SzafronJuillet 4 2019

Dans l'épisode d'aujourd'hui, nous allons commencer à travailler sur un logiciel qui vous permettra de tirer parti des possibilités offertes par le trading algorithmique tout en maintenant un contrôle maximal sur le déroulement des événements. Nous nous concentrerons sur des idées qui vous permettront d’engager de véritables transactions en optimisant le fonctionnement intuitif et la flexibilité de la fonction. Dans le logiciel, nous utilisons une interface, considérée par beaucoup comme étant la norme dans l’industrie du day trading et souvent appelée échelle de prix

algotrader

Algo Trader - Interface

Plan de projet

Nous allons diviser le travail en plusieurs étapes, car outre la gestion étendue des commandes, Algo Trader vous permettra d’exécuter des algorithmes qui gèreront automatiquement la position en fonction de diverses combinaisons que vous pourrez créer en fonction de la situation que vous rencontrerez sur le marché.

Dans la partie d’aujourd’hui, nous ferons un premier pas dans le monde de la programmation orientée objet et nous lancerons une partie élémentaire de notre projet relative à l’interface et au fonctionnement des opérations de base.

Dans les prochains épisodes, nous commencerons à travailler sur les premiers algorithmes. Au début, nous allons créer un algorithme GTP qui garantira que la position se ferme avec le profit attendu, quel que soit le nombre de commandes passées. Ensuite, nous allons créer l’algorithme OOO (On ouvre l’autre, donc exactement, cela n’a pas encore été fait), et enfin un algorithme permettant le scalping lors de la présentation de données macro importantes. Avec les algorithmes, ici et là, nous allons ajouter de jolis gadgets.

Contexte technique

Vous trouverez le paquet avec les fichiers dont vous avez besoin pour aujourd'hui en suivant ce lien:

Utiliser le logiciel signifie accepter la licence attachée à l'ensemble de fichiers.

Pour que le logiciel fonctionne correctement, vous devez disposer d'une version Microsoft NET Framework de min. 4.6.1 Runtime, que vous pouvez télécharger ici:

Programmation orientée objet

Nous allons créer notre logiciel en utilisant programmation objet, une méthode de programmation permettant d’ordonner logiquement des fragments d’algorithme dans le objets dont la tâche est d'exécuter des fonctions distinctes et de communiquer avec d'autres objets afin de mettre en œuvre la tâche du programme dans son ensemble. Pour aller plus loin, nous devrons comprendre quels objets sont en pratique et comment ils sont créés. À cette fin, jetez un coup d'œil à l'article suivant de Wikibooks, qui - basé sur l'exemple du langage C ++ sur lequel est basé MQL4 - vous permet de comprendre les bases.

LIRE L'ARTICLE

Première classe

Comme vous pouvez le constater, tout tourne autour du mot clé classe. Il vous permet de définir un objet que vous pouvez ensuite créer avec un mot clé. neufs. Ouvrez le fichier contenant la définition d’une des classes que nous utiliserons aujourd’hui, le fichier ChartOperations.mqhque vous trouverez dans le catalogue MQL4 \ Include \ AlgoTrader_v10.

classe cChartOperations { publique: cChartOperations(int largeur, int la taille) { // ... } annuler Onclick(int x, int y) { // ... } annuler OnChartChange() { // ... } privé: int Chart_width; int Chart_height; uint Last_click; int Last_click_x, Last_click_y; bool IsDoubleClick(int x, int y) { // ... } };

 

 

Chaque classe a un constructeur qui, en pratique, est une fonction appelée automatiquement lors de la création de l'objet. Le constructeur porte le même nom que l'objet et peut prendre des paramètres. Dans l'extrait de code ci-dessus, nous créons un constructeur comme suit:

cChartOperations(int largeur, int la taille) { }

 

Après avoir créé le constructeur, nous pouvons définir les composants de la classe, à savoir les fonctions et les variables. Elles sont définies exactement comme dans le cas de fonctions ordinaires et de variables, à la différence de celles du corps de la classe. Faites attention à vos mots-clés publique: oraz privé:. Toutes les fonctions et variables après le mot publique: sera disponible pour les fonctions présentes dans d'autres parties du logiciel, par exemple dans la fonction API OnTick () ou d'autres objets. Chef Cependant, il informe le compilateur que les éléments définis dans cette partie sont strictement confidentiels et que personne, à l'exception d'un objet donné, n'y a naturellement accès.

Applications d'objets

Qu'est-ce qui crée des objets si utiles? Entre autres choses, c’est qu’une fois que l’objet défini peut être créé en un nombre quelconque de copies, il se comportera différemment, en fonction des paramètres qui lui sont transmis, mais d’une manière que nous pourrons analyser et contrôler. De plus, les objets permettent une organisation lisible du code en divisant les composants de l'algorithme en éléments extraits, et un objet correctement conçu peut être utilisé dans un logiciel complètement différent, ce qui vous permet de créer efficacement des applications complexes.


conseillers experts


Nous commençons le premier objet

Passons au fichier principal de notre logiciel, fichier AlgoTrader_v10.mq4que vous trouverez dans le catalogue MQL4 \ experts \.

Jetons un coup d'oeil à la définition de l'API ci-dessous OnInit ():

cChartOperations* ChartOperations = NULL; int OnInit() { // (...) int chart_width = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); int chart_height = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS); ChartOperations = neufs cChartOperations(chart_width, chart_height); retourner(INIT_SUCCEEDED); }

Aiguille

Dans la partie du fichier chargée de la définition des variables globales à l'aide d'un fragment de code ...

cChartOperations* ChartOperations = NULL;

 

... nous créons le soi-disant aiguille C'est à dire, un pointeur qui contiendra une adresse à un endroit dans la mémoire de l'ordinateur, où notre objet sera créé plus tard. En utilisant le pointeur, nous pourrons nous référer à l'objet et appeler ses fonctions. pointeurs nous définissons de manière similaire aux variables, le premier élément de la notation est le type d'objet, puis nous plaçons l'astérisque * , après quoi nous donnons un nom unique à l’objet, que nous utiliserons plus tard pour les références. À la nôtre aiguille nous assignons une variable NULL, qui dit qu’au stade actuel, il n’indique pas encore d’objet.

constructeur

Plus tard dans le code, dans le corps de la fonction OnInit () nous créons le bon objet en utilisant un mot clé neufs.

ChartOperations = neufs cChartOperations(chart_width, chart_height);

 

Po neufs nous appelons le constructeur de l'objet, qui dans notre cas prend deux variables informant l'objet sur les dimensions de notre graphique, car nous en avons besoin pour positionner correctement notre interface. Le constructeur appelé transmet l'adresse de l'objet nouvellement créé dans la mémoire de l'ordinateur. aiguille nommé ChartOperations.

destructeur

Les objets sont un type particulier de données. Si nous les créons, nous devons nous assurer que ces données sont finalement supprimées de la mémoire de l'ordinateur. Tout cela pour que devant votre ordinateur portable, vous ne deviez pas être un énorme serveur qui rassemble des données créées précédemment qui ne sont plus nécessaires pour personne.

Pour supprimer des objets, nous utilisons le mot clé effacer, après quoi nous plaçons notre nom poinera indiquant quel objet nous voulons dire. Nous supprimons notre objet uniquement dans la fonction API OnDeinit (...)parce que nous en avons besoin pendant tout le cycle de vie de l'application, jusqu'à ce que le logiciel soit désactivé.

annuler OnDeinit(const int raison) { // (...) effacer ChartOperations; }

Travailler avec des objets

Voyons maintenant comment nous pouvons utiliser notre objet créé pour les besoins de notre application. À cette fin dans le corps de la classe cChartOperations Nous avons défini plusieurs fonctions. Regardons l'un d'entre eux:

annuler Onclick(int x, int y) { if(IsDoubleClick(x, y)) GoToPrice(x, y); }

 

fonction Sur clic (...) nous en avons besoin pour communiquer à notre interface les niveaux de prix qui nous intéressent actuellement. En double-cliquant sur le graphique, l'algorithme définira notre échelle de prix à l'endroit indiqué. Pour que notre fonction fonctionne, nous devons détecter le moment où nous cliquons sur le graphique. La fonction API aide ici. OnChartEvent (...)

annuler OnChartEvent(const int ça const Long & lparam, const double & dparam, const un magnifique & spar) { // (...) if(id == CHARTEVENT_CLICK) ChartOperations.OnClick((int)lParam (int)dparam); }

 

L'extrait de code ci-dessus reconnaît le moment où l'utilisateur clique sur le graphique, puis appelle la fonction qui se trouve dans notre objet créé précédemment. Appeler une fonction consiste à placer un point après notre nom aiguille à l'objet, puis en passant le nom de la fonction qui nous intéresse avec les paramètres nécessaires, qui dans notre cas indiquent les coordonnées x et y de la place dans la carte dans laquelle le clic a été effectué.

Premiers effets

Les procédures créées par nous ont lancé la première fonctionnalité du logiciel, que nous pouvons tester en compilant notre programme et en cliquant sur un autre graphique. Vous trouverez ci-dessous un graphique présentant quelques fonctions vous permettant de manipuler les niveaux de prix affichés dans notre interface graphique.

programmation mql

Algo Trader - Souris et niveaux de prix

Deuxième classe

Étant donné que vous avez été promu au second degré et que nos clics ne sont pas vains, nous allons concevoir un deuxième établissement qui vous permettra de passer des commandes au niveau de notre échelle. À cette fin, nous avons préparé la classe appropriée, que vous trouverez dans le fichier MQL4 \ Include \ AlgoTrader_v10 \ OrderOperations.mqh

classe cOrderOperations { publique: cOrderOperations(int position_id) { Position_id = position_id; } annuler OnTimer200ms() { ProcessOrderRequests(); } privé: int Position_id; annuler ProcessOrderRequests() { sOrderRequest nécessaire = ReadOrderRequest(); if(request.Request_id <= 0) retour; if(request.Order_symbol != Symbole() || request.Position_id != Position_id) { request.Request_status = ORDER_REQUEST_STATUS_FAILED; request.Request_error = ORDER_REQUEST_ERROR_WRONG_POSITION; retour; } if(OrderSend(request.Order_symbol, request.Order_type, request.Order_volume, request.Order_price, 0, 0, 0, request.Order_comment, request.Position_id) > 0) { request.Request_status = ORDER_REQUEST_STATUS_COMPLETED; } d'autre { request.Request_status = ORDER_REQUEST_STATUS_FAILED; request.Request_error = _LastError; } UpdateOrderRequest(nécessaire); } };

Dans le code ci-dessus, vous pouvez voir la définition complète de l'objet cOrderOperationsqui sera utilisé pour traiter les commandes que nous placerons sur notre échelle de prix. Faites attention à la fonction ProcessOrderRequests ()dans lequel notre programme communique avec la bibliothèque dll en utilisant la fonction ReadOrderRequest ().

structures

fonction ReadOrderRequest () à la suite de son action renvoie une structure de type sOrderRequest, qui est un ensemble de données défini par nous avec une commande passée via l’interface.

annuler ProcessOrderRequests() { sOrderRequest nécessaire = ReadOrderRequest(); // (...) }

Les structures sont des soeurs plus jeunes de classes qui vous permettent de créer un bloc de données contenant de nombreuses variables. Cela permet un ordre logique des informations relatives à un problème donné. Dans notre cas, la structure collecte des données sur la commande envoyée par notre interface graphique, telles que le prix d'ouverture ou le volume. Nous définissons une structure en faisant précéder son nom d'un mot clé structpuis nous établissons une liste des données dont nous avons besoin.

struct sOrderRequest { int request_id; int Position_id; int ORDER_TYPE; double Order_volume; double Order_price; double Order_range; un magnifique Order_symbol; un magnifique Order_comment; int Request_status; int Request_error; };

 

La définition ci-dessus peut être trouvée dans le fichier MQL4 \ Include \ AlgoTrader_v10 \ Definitions.mqh.

Nous utilisons les structures de la même manière que les variables. Dans un premier temps, nous devons les créer en spécifiant le type de structure, puis lui attribuer un nom unique, auquel nous pourrons nous référer ultérieurement. Dans l'exemple suivant, nous créons une structure de type sOrderRequest et nous lui donnons un nom unique nécessairepuis nous assignons des données de notre interface en utilisant des fonctions ReadOrderRequest ().

annuler ProcessOrderRequests() { sOrderRequest nécessaire = ReadOrderRequest(); // (...) }

 

L'accès aux données stockées dans la structure est analogue à l'utilisation de variables car, en pratique, la structure n'est qu'un ensemble de variables cachées sous un identifiant commun. Pour lire ou écrire des données dans la structure, il suffit après le nom que nous lui avons donné de mettre un point, puis d’indiquer le nom de la variable qui nous intéresse. Dans le fragment de code suivant, nous lisons les données stockées dans la structure pour envoyer la commande, puis sauvegardons les informations sur le résultat de l'opération.

if(OrderSend(request.Order_symbol, request.Order_type, request.Order_volume, request.Order_price, 0, 0, 0, request.Order_comment, request.Position_id) > 0) { request.Request_status = ORDER_REQUEST_STATUS_COMPLETED; }

Exécution des ordres

Pour que notre logiciel puisse passer des commandes, nous devons implémenter l’objet créé à partir de la classe. cOrderOperations. Parce que nous aurons besoin de l'objet dès le lancement de notre programme, nous le créons dans la fonction API OnInit ().

contribution int Position_id = 8821; // L'identifiant unique de l'article cOrderOperations* OrderOperations = NULL; int OnInit() { EventSetMillisecondTimer(200); // (...) OrderOperations = neufs cOrderOperations(Position_id); retourner(INIT_SUCCEEDED); }

 

Dans le constructeur cOrderOperations nous plaçons une variable Position_id, qui fait partie des paramètres de notre application disponibles dans la fenêtre de la plateforme MetaTrader par défaut. L'identifiant permet à notre logiciel de reconnaître ses propres commandes afin d'éviter toute confusion avec les commandes d'autres sources.

Nous avons également lancé le code ci-dessus Minuteur avec l'intervalle ms 200, car notre objet doit vérifier périodiquement si l'interface envoie des informations sur la commande entrante.

annuler OnTimer() { // (...) OrderOperations.OnTimer200ms(); }

 

La fonction de l'objet OnTimer200ms () appellera une fonction ProcessOrderRequests ()qui passera la commande lorsqu'il recevra les données appropriées de l'interface.

classe cOrderOperations { publique: cOrderOperations(int position_id) { Position_id = position_id; } annuler OnTimer200ms() { ProcessOrderRequests(); } // (...) };

effets

Notre logiciel peut déjà communiquer avec l'interface graphique et nous pouvons faire ce que nous voulons faire le plus, c'est-à-dire compiler l'algorithme et soumettre une nouvelle commande. Pour vous aider à démarrer les premières étapes ci-dessous, vous trouverez quelques conseils qui illustrent les fonctions cachées sous différentes touches.

Contrôle du volume

volume de trading forex

Algo Trader - Gestion du volume

Types de commandes

algo trading

Algo Trader - Traitement des commandes

Résumé

C'est tout pour aujourd'hui, mais ce n'est que le début de l'aventure avec Marchand d'Algo. Dans le prochain épisode, nous passerons à l'implémentation de fonctions avancées liées au support des algorithmes. Algo Trader sera créé avec vous et nous vous serons reconnaissants pour toutes les idées et commentaires qui pourraient vous aider. Nous serions ravis de vous entendre à biuro@expertadvisors.pl .

Qu'en penses-tu?
Je
70%
intéressant
20%
Heh ...
10%
Shock!
0%
Je n'aime pas
0%
blessure
0%
À propos de l'auteur
Radek Szafron
L'auteur de cette publication est Radek Szafron, propriétaire de la société Expert Advisors, qui accompagne les investisseurs depuis de nombreuses années en fournissant des technologies dédiées au marché des changes. L'auteur est diplômé de la Warsaw School of Economics avec la spécialisation "marchés financiers" et programmeur avec une expérience estivale proche de 20. La société implémente des conceptions d'algorithmes et d'applications écrites dans toutes les langues de la famille "C", y compris les plateformes populaires Meta Trader 4 et 5. Des conseillers experts peuvent être trouvés sur www.expertadvisors.pl.