ProRealTime · ProBuilder
Tableaux en ProBuilder : $tableau, LastSet, ArraySort et ArrayMax
Créer et parcourir des tableaux $ en ProBuilder, utiliser ArrayMax, ArrayMin, ArraySort, IsSet, LastSet et UnSet, et comprendre pourquoi les tableaux ne sont pas historisés.
En ProBuilder, un tableau est une variable dont le nom commence par le symbole $, par exemple $niveaux. On y écrit avec $niveaux[indice] = valeur et on y lit avec $niveaux[indice], les indices allant de 0 à 999 999. Un code peut utiliser autant de tableaux que nécessaire, dans la limite d’un million de valeurs au total. Leur particularité majeure : les tableaux ne sont pas historisés. Leur contenu persiste d’une barre à l’autre, ce qui permet de mémoriser une liste de niveaux, de signaux ou de prix, mais $niveaux[2][1] n’a pas de sens. Des fonctions dédiées complètent l’ensemble : ArrayMax, ArrayMin, ArraySort, IsSet, LastSet et UnSet.
Cette page fait partie de la rubrique Le langage ProBuilder. Elle suppose connues les boucles FOR et WHILE, indispensables pour parcourir un tableau.
Variable classique ou tableau : la différence fondamentale
Une variable ordinaire contient une valeur par barre, et ProBuilder garde automatiquement l’historique de ces valeurs : x[1] est la valeur de x sur la barre précédente. Un tableau fonctionne autrement : il contient une liste de valeurs indépendante des barres. Ce que vous écrivez dans $liste[5] reste en mémoire jusqu’à ce que vous le remplaciez ou que vous vidiez le tableau, quel que soit le nombre de barres écoulées.
Cette différence a deux conséquences :
- Les tableaux sont l’outil naturel pour mémoriser des événements (les dix derniers sommets, les prix d’entrée de plusieurs signaux, des niveaux de support) sans connaître à l’avance combien de barres les séparent.
- On ne peut pas lire l’état passé d’un tableau. La documentation officielle précise que l’opération
$MonTableau[MonIndice][3]est invalide. Si vous avez besoin d’une valeur historisée, stockez-la dans une variable classique.
Écrire et lire dans un tableau
$prix[0] = Close // écrit la clôture à l'indice 0
$prix[1] = Open // écrit l'ouverture à l'indice 1
ecart = $prix[0] - $prix[1]
condition = Close > $prix[0]
Il n’y a pas de déclaration ni de taille à fixer : le tableau s’agrandit à mesure qu’on écrit dedans. Une règle importante : lorsque vous écrivez à l’indice n, tous les indices non définis entre 0 et n - 1 sont initialisés à zéro. Si vous écrivez directement $t[10] = 5, les indices 0 à 9 existent alors avec la valeur 0. Les fonctions dédiées savent distinguer ces zéros de remplissage des valeurs réellement écrites, comme on le verra plus bas.
L’indice peut être une variable ou une expression, ce qui permet de remplir et de parcourir un tableau avec une boucle FOR.
Les fonctions de tableau
| Fonction | Rôle |
|---|---|
ArrayMax($t) | plus grande valeur du tableau ; les zéros de remplissage sont ignorés |
ArrayMin($t) | plus petite valeur définie ; les zéros de remplissage sont ignorés |
ArraySort($t, ASCEND) ou ArraySort($t, DESCEND) | trie le tableau en ordre croissant ou décroissant ; les zéros de remplissage sont supprimés |
IsSet($t[i]) | 1 si l’indice i a été défini, 0 sinon (un zéro de remplissage compte comme non défini) |
LastSet($t) | plus grand indice défini, ou -1 si le tableau est vide |
UnSet($t) | vide entièrement le tableau |
LastSet est la fonction la plus utilisée : elle donne à la fois la taille utile du tableau (LastSet($t) + 1 éléments si les indices sont contigus) et l’indice où ajouter l’élément suivant. Le retour -1 pour un tableau vide est pratique : LastSet($t) + 1 vaut alors 0, le premier indice.
Attention, ArraySort trie le tableau en place : l’ordre d’origine est perdu. Si deux tableaux sont liés indice par indice (un prix et la barre correspondante, par exemple), trier l’un désynchronise l’autre.
Ajouter un élément à la fin d’un tableau
Le schéma suivant revient dans presque tous les codes qui utilisent des tableaux :
IF Close CROSSES OVER Average[50](Close) THEN
k = LastSet($entrees) + 1 // premier indice libre (0 si le tableau est vide)
$entrees[k] = Close // mémorise le prix du signal
$barres[k] = BarIndex // et la barre correspondante
ENDIF
Les deux tableaux $entrees et $barres partagent le même indice : c’est une manière simple de stocker des enregistrements à plusieurs champs, puisque ProBuilder n’a pas de structures.
Exemple complet : tracer les derniers sommets
Cet indicateur détecte les sommets locaux (une barre dont le plus haut dépasse celui des deux barres de chaque côté), les mémorise dans deux tableaux, puis trace sur la dernière barre un segment horizontal pour chacun des cinq sommets les plus récents. Il affiche aussi le plus haut de tous les sommets mémorisés grâce à ArrayMax.
// Mémorise les sommets locaux et trace les 5 plus récents
DEFPARAM DRAWONLASTBARONLY = true // les objets ne sont dessinés que sur la dernière barre
// Un sommet est confirmé deux barres plus tard : on teste donc la barre [2]
IF BarIndex > 4 THEN
IF High[2] > High[3] AND High[2] > High[4] AND High[2] > High[1] AND High[2] > High[0] THEN
k = LastSet($sommets) + 1 // indice libre
$sommets[k] = High[2] // prix du sommet
$barres[k] = BarIndex - 2 // barre du sommet
ENDIF
ENDIF
dernier = LastSet($sommets) // -1 tant qu'aucun sommet n'est trouvé
IF IsLastBarUpdate AND dernier >= 0 THEN
premier = MAX(0, dernier - 4) // les 5 derniers sommets au plus
FOR i = premier TO dernier DO
DRAWSEGMENT($barres[i], $sommets[i], BarIndex, $sommets[i]) COLOURED(200, 0, 0)
NEXT
plusHautSommet = ArrayMax($sommets) // le plus haut de tous les sommets mémorisés
DRAWHLINE(plusHautSommet) COLOURED(120, 120, 120)
ENDIF
RETURN
Plusieurs points méritent attention. Le sommet est testé sur la barre [2], car il faut deux barres supplémentaires pour le confirmer ; utiliser la barre courante reviendrait à exploiter une information future. Le test IsLastBarUpdate, documenté pour repérer la dernière barre mise à jour, évite d’exécuter la boucle de dessin sur tout l’historique. Enfin, le RETURN sans valeur indique que l’indicateur ne renvoie pas de courbe : il ne fait que dessiner. Les instructions de dessin sont détaillées dans le guide DRAWTEXT, DRAWARROW et objets graphiques.
Limites et pièges des tableaux
- Pas d’historique : un tableau reflète toujours son état actuel. Toute logique du type « valeur du tableau il y a trois barres » doit passer par une variable classique.
- Croissance sans fin : sur un long historique, un tableau alimenté à chaque signal peut grossir beaucoup. Si seuls les derniers éléments vous intéressent, réutilisez les indices ou videz le tableau avec
UnSetau moment opportun (par exemple au début de chaque journée). - Zéros de remplissage : écrire à un indice éloigné crée des zéros intermédiaires.
ArrayMax,ArrayMinetIsSetles ignorent, mais une boucle de lecture classique les verra comme des valeurs 0. - Indices hors limites : ne lisez pas au-delà de
LastSet($t), comme le rappelle la documentation deArraySort. - Tri destructif :
ArraySortmodifie l’ordre du tableau et supprime les zéros de remplissage.
Cas d’usage en trading
Les tableaux servent typiquement à : mémoriser des niveaux de support et de résistance détectés automatiquement ; conserver les prix d’ouverture de chaque séance pour tracer des niveaux remarquables ; enregistrer plusieurs points d’entrée et calculer leur prix moyen ; construire un histogramme de volumes par niveau de prix. Dans un système de trading, ils permettent aussi de garder la trace de signaux successifs que les variables classiques écraseraient à chaque barre. Les mêmes règles s’appliquent dans les screeners et les backtests. À l’inverse, pour un simple plus haut ou plus bas sur N barres, un tableau est inutile : une instruction native comme le canal de Donchian fait le travail plus simplement.
Pour la logique de détection de niveaux sur plusieurs unités de temps, voyez aussi TIMEFRAME : multi-unités de temps.
Dernier conseil : commencez toujours par afficher la taille du tableau, par exemple avec PRINT ou en renvoyant LastSet($t) dans le RETURN, pour vérifier que les éléments s’ajoutent bien au rythme attendu avant de construire une logique plus complexe dessus.
FAQ
Comment déclarer un tableau en ProBuilder ?
Il n’y a pas de déclaration : un tableau est créé à la première écriture, avec un nom précédé de $, par exemple $niveaux[0] = Close. Les indices vont de 0 à 999 999, avec un maximum d’un million de valeurs pour l’ensemble des tableaux du code.
Comment connaître la taille d’un tableau ?
Utilisez LastSet($tableau), qui renvoie le plus grand indice défini, ou -1 si le tableau est vide. Si vos indices sont contigus à partir de 0, le nombre d’éléments vaut LastSet($tableau) + 1.
Peut-on lire la valeur d’un tableau sur une barre précédente ?
Non. Les tableaux ne sont pas historisés : $tableau[i][1] est invalide. Si vous avez besoin de l’historique d’une valeur issue d’un tableau, copiez-la dans une variable classique, qui, elle, est historisée.
Comment vider un tableau ?
Avec UnSet($tableau), qui supprime tout son contenu. Après cette instruction, LastSet($tableau) renvoie de nouveau -1.
