Comment écrire des algorithmes pour ATAS

La plateforme ATAS, en plus de tous ses indicateurs et graphiques en clusters utiles, a la possibilité très cool de connecter vos propres algorithmes via l’API. Elle ouvre la voie à des options illimitées pour utiliser la puissance d’ATAS : 

À la fin de l’article, vous recevrez un fichier pour Visual Studio avec le code source utilisé dans le texte. Si vous avez des questions — posez-les dans les commentaires.

Allons-y !

Par où commencer

Vous devez commencer par installer Microsoft Visual Studio – c’est un environnement dans lequel divers produits sont développés en langage C#, y compris des bibliothèques dll. C’est au format de bibliothèque dll que vous pouvez connecter vos propres algorithmes à ATAS.

Vous pouvez télécharger le package de distribution du programme Visual Studio Community (version gratuite, cela suffira) sur visualstudio.microsoft.com//downloads/

Installez Visual Studio sur votre ordinateur comme n’importe quel autre logiciel. Il est préférable de choisir la version anglaise. Nous utilisons l’anglais dans les captures d’écran.

Lancez le logiciel. Sélectionnez Create Class Library / Créer une bibliothèque de classes (.NET Standard).

Veuillez noter que dans la plupart des cours de langage C#, la formation commence par la création de l’application Console App. Et nous, nous avons choisi de créer Class Library, car elle est nécessaire pour se connecter à ATAS.

Class Library, en quoi consiste-t-elle ? Il s’agit d’une composante distincte d’un grand logiciel. Dans notre cas, vous allez créer un fichier dll avec vos propres classes, afin de pouvoir le connecter ultérieurement en tant que composant à la plateforme ATAS. 

Vous verrez bientôt comment ça se passe.

Choisissez un nom pour le projet Lesson1. Cliquez sur Create.

Visual Studio va se lancer et créer un modèle de bibliothèque de classes vide pour nous (dans la capture d’écran ci-dessous).

En bref à propos de l’interface. Sur la droite (1) se trouve une fenêtre appelée Navigateur de solutions. Elle montre la structure de votre projet et ses éléments (si elle ne s’affiche pas chez vous, vous pouvez l’ouvrir depuis le menu View/Affichage). On peut également y ouvrir/fermer d’autres fenêtres).

Sur la gauche se trouve une grande zone où le code du logiciel est édité, dans ce cas, l’éditeur de classe Class1.cs.

Ce que notre code contient après la création du modèle :

• using est un mot clé qui signifie que nous connectons des sources supplémentaires (espaces de noms). Using System (2) est suggérée par défaut, car il contient les bases que nous utiliserons sûrement.
• namespace Lesson1 est votre espace de noms. Il dessine une sorte de frontière entre les différentes parties du code afin qu’elles n’entrent pas en conflit en raison des mêmes noms. 
• public class Class1 est une ébauche pour votre classe. C# est un langage de programmation orienté objet (POO) et la classe est son élément requis. 

Premiers pas

Établissez une connexion avec ATAS.

Pour ce faire, il faut ajouter à notre projet un lien vers la bibliothèque ATAS.Indicators.dll, qui se trouve dans le dossier avec la plateforme ATAS installée.

Dans le menu Project, choisissez Add References (ou cliquez avec le bouton droit sur l’onglet Dependencies dans la Fenêtre du navigateur).

ATAS.Indicators (1) apparaîtra dans la fenêtre du navigateur.

Ensuite, modifiez le code, comme indiqué dans la capture d’écran (2) :

Écrivez namespace ATAS.Indicators.Technical  – car vous allez créer votre propre algorithme dans l’espace d’autres indicateurs techniques ATAS.

Ajoutez using ATAS.Indicators – lors de la création d’algorithmes pour ATAS, vous utiliserez toujours cette référence (un exemple est décrit ultérieurement).

Modifiez public class Example1_1 : Indicator. Dans cette ligne Example1_1 les chiffres signifient qu’on fait le premier exemple de la première leçon (vous pouvez écrire n’importe quel autre nom, il sera alors affiché dans la liste des indicateurs ATAS).

Mais, les deux-points et le mot Indicatoront une signification importante. Ainsi, on indique que la classe Indicator (elle est contenue dans ATAS.Indicators.dll) est la classe « parent ». Et, la classe Example1_1 hérite de tout ce qui est dans la parente. Cela signifie que l’on a accès à toutes les fonctionnalités autorisées aux descendants de la classe Indicator, c’est-à-dire des opérations avec des prix, des clusters, des valeurs d’autres indicateurs, etc. 

Ensuite, écrivez protected override void OnCalculate(int bar, decimal value) et deux accolades. Ce morceau de code s’appelle la méthode OnCalculate.

Une méthode est, en termes simples, un ensemble de commandes qu’un ordinateur doit exécuter. À l’intérieur du parent, la méthode OnCalculate est déclarée comme requise. Lorsque vous ajoutez votre indicateur au graphique, la plateforme exécute les commandes que vous écrivez entre accolades. Et, si vous n’avez pas la méthode OnCalculate, Visual Studio ne vous permettra pas de compiler le code dans un fichier dll, car cette méthode est requise. Sinon, ATAS ne comprendra pas ce qu’il doit faire.

Si vous avez tout fait correctement, en bas, vous verrez la phrase No issues found (3). Si des erreurs y sont affichées, essayez de comprendre quelle en est la cause. Ce qui peut mal tourner :

• C# est un langage sensible au registre. Cela signifie que les lettres majuscules et minuscules sont différentes dans le code.
• Les accolades, les points-virgules, les guillemets et autres caractères sont tous importants. Si vous avez oublié ou perdu quelque chose, Visual Studio vous en informera.

Maintenant que vous avez un code sans erreur, compilez-le. Pour ce faire, sélectionnez Build Lesson1 dans le menu Build (ou appuyez sur Ctrl + B), et un message devrait apparaître dans la fenêtre output indiquant que la compilation du code dans un fichier a réussi.

Comme vous pouvez le voir, notre projet a été compilé dans Lesson1.dll. Allez dans le dossier spécifié, sélectionnez le fichier, copiez-le dans C:UsersUserDocumentsATASIndicators (dans votre cas, le chemin vers le dossier Documents peut être différent). Intercalez-y Lesson1.dll. 

Lancez ATAS, ouvrez le graphique, chargez les données sur l’instrument, appelez la fenêtre du gestionnaire d’indicateurs. Et, qu’est-ce qu’il y a là-bas ?

Votre propre indicateur Example1_1 est apparu dans la liste des indicateurs techniques ! (Si non trouvé, essayez le formulaire de recherche).

Faites attention. Même si vous n’avez presque pas écrit de code, votre indicateur contient :

• possibilité de sélectionner la source Source ;
• sélection d’un panneau à afficher ;
• paramètres d’affichage (couleur, type de ligne et autres).

Votre indicateur a hérité de tous ces paramètres de la classe « parent » Indicator. On peut les changer, mais pour l’instant, laissez-les tels quels.

Si l’on ajoute Example1_1 au graphique, l’indicateur apparaîtra dans la liste des ajoutés, mais en fait rien ne changera, car il n’y a pas de code dans la méthode OnCalculate. Il n’y a aucune commande à exécuter.

Et, si l’on change le panneau pour afficher l’indicateur et spécifie New Panel au lieu de Chart, alors vous verrez ceci :

Une ligne horizontale rouge s’affichera sur le panneau inférieur. C’est quoi, cette ligne et pourquoi des zéros ?

Parce que quand vous créez votre classe Example1_1 et que vous l’héritez de la classe « parent » Indicator, un tableau de données est automatiquement ajouté à votre classe. C’est ce qu’on appelle la Dataserie. Ce tableau contient les valeurs de votre indicateur pour chaque barre.

Supposons que nous ajoutions l’indicateur Example1_1 au graphique, qui se compose de 458 barres.

Un tableau sera créé en mémoire, où l’ordinateur attribuera le numéro 0 à la barre la plus ancienne (à gauche sur le graphique), le numéro 1 à la suivante, et ainsi de suite. La dernière barre (à droite) sera numérotée 457. 

Et, la ligne Example1_1 stockera les valeurs de l’indicateur. Mais, comme vous n’avez écrit aucun code pour les calculer, les valeurs par défaut y sont stockées – et ce sont des zéros.

Si vous avez fait attention, dans le code la méthode OnCalculate a des paramètres (int bar, decimal value). Les voilà :

• bar est une variable de type integer (un nombre entier). Le numéro de série de la barre est stocké ici ;
• value est une variable de type decimal (un nombre décimal). La valeur de l’indicateur correspondant à cette barre est stockée ici.

Tout cela semble probablement trop compliqué pour un débutant. C’est pourquoi, nous reviendrons au calcul des valeurs des indicateurs une autre fois, mais pour l’instant, nous ferons quelque chose de très élémentaire.

Premier programme

En tant que premier programme, ceux qui commencent à apprendre le langage de programmation C# affichent généralement le message « Hello, world ! » à l’écran. 

Mais, puisque vous créez une bibliothèque pour ATAS, vous allez afficher ce message dans la fenêtre du journal. C’est quasiment la même chose. 

Pour implémenter l’idée, ajoutez au projet la référence Utils.Common.dll du dossier où ATAS est installé. Tout comme vous avez ajouté ATAS.Indicators.dll.

Si vous avez tout fait correctement, alors Utils.Common apparaîtra dans la fenêtre du Navigateur de solutions (comme indiqué par le numéro 1 dans la capture d’écran ci-dessous).

Ensuite, modifiez le code.

Ajoutez using Utils.Common.Logging;  – ceci est nécessaire pour que l’indicateur puisse afficher des messages dans la fenêtre de journal de la plateforme ATAS.

Ajoutez this.LogInfo($ »Hello World 1″); dans le corps de la méthode OnCalculate. C’est la commande pour afficher la phrase de texte « Hello World 1 » dans la fenêtre du journal

Créez également une autre méthode protected override void OnInitialize() – vous comprendrez bientôt pourquoi. Dans le corps de la méthode, écrivez  this.LogInfo($ »Hello World 2″);

Ensuite, compilez.

Copiez Lesson1.dll mis à jour à partir du dossier du projet et collez-le avec le remplacement dans le dossier DocumentsATASIndicators

Et, si vous avez ATAS en cours d’exécution, vous en verrez une notification :

Certaines bibliothèques ont été modifiées. Vous pouvez réinitialiser les stratégies dans la barre d’état de la fenêtre principale.

N’ayez pas peur, c’est une excellente nouvelle ! Lorsque vous mettez à jour votre dll dans le dossier Indicators, vous n’avez pas besoin de redémarrer la plateforme (cela peut prendre un certain temps).

Cliquez simplement sur cette icône et ATAS mettra à jour les bibliothèques sans redémarrer. Cela vous fera gagner de nombreuses minutes si vous faites souvent de petits changements.

Ensuite, ouvrez un graphique journalier (par exemple, ED), et dans la fenêtre des paramètres de la période, spécifiez Days Count = 5, de sorte qu’il n’y ait que 5 bougies sur le graphique. Ajoutez l’indicateur Example1_1 au graphique et regardez la fenêtre du journal :

« Hello World 1 » a été affiché 5 fois et « Hello World 2 » a été affiché 1 fois.

Cela signifie que :

• les commandes à l’intérieur de la méthode OnCalculate sont exécutées pour chaque barre, puis la méthode continue à être exécutée à chaque nouveau tick, afin de calculer les valeurs de l’indicateur en temps réel. 
• Et, la méthode OnInitialize n’est exécutée qu’une seule fois, lors de l’initialisation de l’indicateur. Cela se produit avant l’exécution des commandes de la méthode OnCalculate. 

Bravo, votre premier programme « Hello World » fonctionne ! Compliquons la tâche maintenant.

Deuxième programme

Vous allez créer un indicateur qui affichera des informations sur la dernière barre dans la fenêtre du journal – est-elle haussière (Close>Open / Fermer>Ouvrir) ou baissière (Close

Dans le menu Project / Projet, sélectionnez Add Class / Ajouter une classe, laissez son nom rester Class2.cs. Après l’ajout, une nouvelle Classe (1) apparaîtra dans la fenêtre de votre navigateur. Un double-clic dessus ouvrira l’éditeur de code correspondant.

Dans l’éditeur, copiez le code de Example1_1 et collez-le ici. Vous devriez obtenir une erreur en raison d’un conflit de nom. Changez le nom (2) de la classe en Example1_2, laissez toutes les lignes using, supprimez le code de la méthode OnCalculate, et écrivez des commandes pour résoudre ce problème dans la méthode OnInitialize.

var candle = GetCandle(CurrentBar-1);
Que signifie cette ligne ? Lisons-le de droite à gauche.

• CurrentBar est une variable égale au nombre de bougies sur le graphique. Mais comme la numérotation commence à zéro, la dernière bougie du tableau porte le numéro CurrentBar-1.
• GetCandle est une méthode (commande) de la classe parent Indicator. En exécutant cette commande, l’ordinateur lit toutes les informations disponibles sur la bougie sur le graphique sous le numéro indiqué entre parenthèses.
• var candle – c’est ainsi que nous déclarons un nouvel objet à utiliser dans le programme. Lorsque nous déclarons un nouvel objet, il est préférable de lui attribuer immédiatement une valeur. Cela se fait avec le signe « égal ».

Et ensemble, nous déclarons la variable candle et y mettons des informations sur la dernière bougie du graphique. Maintenant, nous pouvons opérer avec ces informations. Dans notre cas, il s’agit de faire une construction conditionnelle if-else (pour effectuer une opération de comparaison).

Si le prix de clôture (Close) de notre bougie est supérieur au prix d’ouverture (Open), nous écrivons “Last bar is Bullish” (« La dernière barre est haussière ») dans le journal. Sinon (si inférieur ou égal) – écrivons “Last bar is Bearish” (« La dernière barre est baissière ») dans le journal.

Compilez le fichier dll via le menu Build, collez le fichier Lesson1.dll dans le répertoire avec les indicateurs. Cliquez sur l’icône dans ATAS pour que la plateforme mette à jour les bibliothèques. Ouvrez le graphique :

Qu’est-ce qu’il signifie ?

Nous avons ajouté deux variables q_Green et q_Red. Les deux sont de type int (integer – un entier) et les deux sont égales à zéro. Nous les utiliserons pour compter.

Vient ensuite la boucle for. Cette boucle convient lorsqu’une opération doit être effectuée un nombre connu de fois. Dans notre cas, le nombre d’itérations est égal au nombre de barres sur le graphique, qui est stocké dans CurrentBar. La variable i est un compteur, au départ, elle est égale à zéro. Mais, elle augmente de 1 à chaque exécution de la boucle (itération). La boucle sera exécutée tant que la condition i < СurrentBar est vraie.

Lorsque la boucle est exécutée pour la première fois, notre indicateur émet la commande GetCandle(0), reçoit des données sur la première bougie (à gauche) du graphique et les place dans l’objet candle. Ensuite, il compare candle.Close et candle.High, et selon la comparaison augmente q_Green ou q_Red.

Et ainsi de suite pour chaque barre. Lorsque la boucle se termine, la commande LogInfo affiche le texte et les valeurs des variables q_Green ou q_Red dans la fenêtre du journal.

Compilez notre bibliothèque d’indicateurs, collez-la avec le remplacement dans le même dossier, cliquez sur l’icône pour mettre à jour les bibliothèques dans ATAS et ajoutez l’indicateur au graphique :

Dans la fenêtre du journal, l’indicateur Example1_2 a écrit que la dernière barre est haussière. Et Example1_3 a écrit qu’il y a 11 barres haussières et 12 barres baissières. Tout est correct.

Nous allons compliquer pour la dernière fois dans cet article.

Quatrième programme

Écrivons un code qui évalue une séquence de barres haussières et baissières en fonction de la durée et de la fréquence. En d’autres termes, nous voulons savoir, par exemple, quelle est la probabilité que la première barre haussière soit suivie d’une autre barre haussière.

Mais avant d’écrire un indicateur, faisons une expérience. Prenons un code qui génère aléatoirement un tableau de 20 000 éléments remplis de zéros et de uns. Nous obtenons donc une séquence de chaînes dont la longueur minimale est de 1 maillon. Certaines chaînes seront de 2, 3, 5 maillons ou plus.

Question – quelle sera la longueur moyenne de la chaîne ?

À la suite de l’expérience, nous constatons que la valeur moyenne de la chaîne pour un tableau généré aléatoirement de 20 000 zéros et uns est d’environ 1,96 maillon.

Autrement dit, si l’on suppose que 0 est une bougie baissière et 1 est une bougie haussière, alors dans un marché complètement chaotique, la longueur moyenne d’une chaîne de barres haussières / baissières sera égale à = 1,96.

Nous avons besoin de ce chiffre comme « étalon de hasard ».

Passons à Lesson1 et écrivons le code de la nouvelle classe Example1_4. Tout d’abord, calculons les statistiques des bougies haussières.

La première boucle (1) itérera sur l’ensemble du tableau de bougies sur le graphique. Si nous trouvons le début de la ligne haussière (ligne 21), nous exécutons la deuxième boucle (2) qui compte la longueur de chaque ligne dans bullishLine (la ligne haussière). La variable bullishFirst accumule le nombre de chaînes haussières trouvées et la variable bullishSum comprend le total de leurs longueurs.

Les lignes 24 et 31 sont nécessaires pour se prémunir contre les cas où l’algorithme va au-delà du tableau de bougies. 

Lorsque les boucles sont terminées, nous affichons (3) dans la fenêtre du journal des informations sur le nombre de séquences trouvées de bougies haussières, leur longueur totale et calculons la valeur moyenne en divisant.

Nous écrivons un algorithme similaire pour calculer les statistiques sur les barres baissières. Nous n’obtiendrons sûrement pas le code le plus élégant et le plus professionnel. Mais, c’est un article d’un non professionnel pour les débutants, donc pour l’instant « le principal, c’est que ça marche ». 

Nous compilons le code, le transférons dans un dossier, le lançons sur un graphique, par exemple, des actions de Gazprom (GAZP) d’une période de jour pendant plusieurs semaines. Dans la fenêtre du journal, nous voyons ce que notre indicateur a trouvé :

• 6 séquences baissières avec un total de 10 bougies ;
• 6 séquences haussières avec un total de 11 bougies.

Ce qui est le bon résultat, étant donné que la première bougie baissière n’est pas considérée comme une séquence à part entière, car nous ne voyons pas son début.

Longueur moyenne des séquences :

• 1,66 pour les bougies baissières
• 1,83 pour les haussières

Si nous chargeons des données pour un nombre significativement plus grand de jours calendaires sur le graphique, nous constatons que :

Longueur moyenne des séquences pour la période de l’été 2017 au printemps 2021 :

• 1,86 pour les bougies baissières
• 1,93 pour les haussières

C’est très proche de « l’étalon du chaos ». En d’autres termes, si le trading des actions GAZP a clôturé avec une croissance aujourd’hui, alors la probabilité que demain soit également haussier est pour ainsi dire de 50/50. Et, si vous avez eu des pensées de la stratégie la plus simple du style « J’achèterai demain à l’ouverture, si aujourd’hui il y a de la croissance », alors avec l’aide d’ATAS et de Visual Studio, vous pouvez rapidement trouver la réponse à la façon dont cette stratégie est viable.

Et si :

• on choisit un autre marché / une autre période ?
• on change le type de graphique en Delta, Range, Range XV, Reversal ?
• on ajoute trailing stop ?
• on crée une stratégie automatique ?

Les idées apparaissent les unes après les autres. C’est de la pure créativité que vous pouvez pratiquer sur les marchés financiers avec la plateforme ATAS et l’environnement de développement de vos propres algorithmes Visual Studio. 

Vous pouvez commencer dès maintenant, voici l’archive du code source de la Leçon1.

Pour l’ouvrir dans Visual Studio, double-cliquez sur le fichier Lesson1.sln.
Et dans le dossier Lesson1binDebugnetstandard2.0 se trouve un fichier Lesson1.dll prêt à l’emploi, qui peut être immédiatement inséré dans votre dossier C:UsersUserDocumentsATASIndicators

Bonus

Voici un autre lien excellent. En l’utilisant, vous pouvez télécharger une archive avec un ensemble d’algorithmes de calcul d’indicateurs techniques populaires pouvant être ouverts dans Visual Studio.

Pour ouvrir l’ensemble dans Visual Studio, double-cliquez sur le fichier CustomIndicatorSet.sln

Conclusions

Le savoir-faire d’écrire des logiciels vous donne un avantage important. En connaissant C# même à un niveau non professionnel, vous pouvez :

• automatiser le trading ;
• optimiser les paramètres de stratégies ;
• évaluer la viabilité des idées. 

Si néanmoins la création d’algorithmes en C# pour ATAS s’avère trop coûteuse en temps et en efforts, commandez leur développement à des exécutants professionnels.

Si cet article vous a plu, faites-le savoir dans les commentaires. Écrivez également ce que vous aimeriez voir dans le prochain article sur ce sujet.