Je ne comprends pas l’intérêt des tableaux dans prorealtime… Alors peut-être n’ai je pas tout compris ou mon niveau de programmation en prorealtime est trop basique pour comprendre ?!
Si j’ai bien compris :
- les tableaux dans prorealtime n’ont qu’une seule dimension. C’est bien un tableau avec une seule ligne ?
- Les données enregistrées dans le tableau sont indépendante de la bar/du chandelier en cours. C’est la seule chose qui différencie un tableau d’une variable classique ?
- Une fois que l’on a enregistré une donnée dans une case (pourquoi parler de colonne quand il n’y a qu’une seule ligne?!), on ne peut plus l’effacer ou la changer. Si c’est possible, quel est l’instruction pour le faire ?
- Si c’est possible d’effacer une case… Est ce que les données des cases suivantes reculent d’une case pour ne pas laisser une case vide (à la manière des piles qui existaient en langage machine) ?
Que peut-on faire avec un tableau que l’on ne peut faire sans ?
Merci d’avance pour votre éclairage, je ne saisi pas trop l’intérêt des tableaux ou comment en tirer complètement profit.
Bonjour, point par point :
« Une dimension »… pour le moment… on ne sait pas encore si la suggestion d’augmenter le nombre de dimensions sera accordée. On peut toutefois faire du 2 dimensions limité, la limite étant qu’il faut que le nombre N d’éléments dans la 2e dimension soit connu d’avance, et pas trop grand (praticité d’écriture…), puisque si on a fait des math matricielles N vecteurs à même 1 dimension feront 1 matrice 2d à N éléments sur sa 2e dimension
« données indépendantes des chandeliers » c’est la chose la plus importante pour garder le plus de liberté possible
« enregistré dans une case/ne peut plus la changer » (colonne ou ligne, peu importe, s’il y a une dimension c’est le long de « la » dimension dans un cas comme dans l’autre). Si, on peut la changer, ou la remettre à zéro : avec un tableau qui s’appelle $tableau, en son rang i, en écrivant simplement $tableau[i]=0 (ou = sa nouvelle valeur) pour lui réattribuer au rang i une nouvelle valeur s’il en avait déjà une
« cases reculent » non, chaque élément reste à son rang
« Que peut-on faire avec un tableau que l’on ne peut faire sans ? » En ce qui me concerne, transformation de mon volume profile PRTv10.3(sans tableaux) à nombre fixe de 80 barres d’épaisseur variable en un volume profile PRTv11(avec tableaux) à nombre variable de barres d’épaisseur fixe, tpo profiles, et footprint uptick/downtick (à défaut de pouvoir être bid/ask tant qu’on ne peut pas lire le carnet)… mais aussi dans les requêtes du forum tu as peut-être vu passer des besoins de mise en mémoire d’événements quel que soit le moment et le niveau, tels que : plusieurs plus hauts/plus bas dans un ordre voulu, mémoriser des divergences, mémoriser des gaps, etc… de façon générale tout ce qui va avoir besoin d’être mémorisé sans savoir à l’avance combien il y en aura sur 1 dimension, car avec l’indexation par rang pour un seul nom (de tableau), tu peux travailler en quantité indéfinie à l’avance au lieu de devoir nommer sans tableau par variables un nombre fixe connu d’avance d’éléments.
On parle de tableaux, avec des colonnes, car on a l’habitude de représenter une variable en tableau comme dans l’image attachée.
L’intérêt des arrays (variables en tableaux), c’est qu’on peut en créer à la volée autant qu’on veut (et y revenir par la suite pour utiliser leurs informations rapidement).
Avec des variables ordinaires, on doit savoir à l’avance combien de variables seront nécessaires.
Si par exemple, je veux enregistrer tous les fractals de période 10 de mon historique, sans un tableau je ne pourrais pas, hors ici je peux faire:
if fractalHigh then // je détecte un nouveau fractal
$top[i] = fractalValue // je stocke sa valeur dans la colonne i
i=i+1 // j'incrémente la colonne pour le prochain stockage
endif
Peu importe la quantité de fractals qu’on a à stocker, une seule variable le permet !
Imagine que tu veuilles calculer un niveau de support sur un niveau de prix donné. Sans ce tableau qu’on vient de créer, tu devrais refaire une boucle complète dans l’historique, avec les problèmes de temps de calcul que l’on connaît et une précision moindre..
Beaucoup d’exemples dans le sujet anglophone: https://www.prorealcode.com/topic/array-variables-availability-in-prorealtime/
Exemple récent dans la library: Supply & Demand – Order Blocks
Dans le marketplace:
https://market.prorealcode.com/product/graphic-patterns-indicator/
https://market.prorealcode.com/product/tpo-profiles-for-prorealtime/
https://market.prorealcode.com/product/horus-footprint-pack/
Bonjour, point par point :
« Si, on peut la changer, ou la remettre à zéro : avec un tableau qui s’appelle $tableau, en son rang i, en écrivant simplement $tableau[i]=0 (ou = sa nouvelle valeur) pour lui réattribuer au rang i une nouvelle valeur s’il en avait déjà une
Si l’on peut réattribuer une valeur à n’importe quelle colonne du tableau, que retourne lastset ? i ? ou la colonne la plus à droite du tableau ?
D’ailleurs, à quoi servent les instructions ArrayMin et ArrayMax ? Rien à voir avec les colonnes ? Ces instructions comparent le contenu du tableau ?
Bonjour, point par point :
« cases reculent » non, chaque élément reste à son rang.
Est-il alors au moins possible de diminuer la longueur du tableau, si l’on “efface” ou si l’on met à zéro une case… Y a-il une instruction pour le nombre max d’élément dans le tableau ?
de façon générale tout ce qui va avoir besoin d’être mémorisé sans savoir à l’avance combien il y en aura sur 1 dimension, car avec l’indexation par rang pour un seul nom (de tableau), tu peux travailler en quantité indéfinie à l’avance au lieu de devoir nommer sans tableau par variables un nombre fixe connu d’avance d’éléments.
L’intérêt des arrays (variables en tableaux), c’est qu’on peut en créer à la volée autant qu’on veut (et y revenir par la suite pour utiliser leurs informations rapidement).
Avec des variables ordinaires, on doit savoir à l’avance combien de variables seront nécessaires.
C’est là que je ne saisi pas la nuance… Je m’explique.
Avant (sans les tableaux) et même maintenant (car je n’ai pas pris le temps de me pencher sur les tableaux), j’utilise tout simplement une variable classique pour mémoriser en quantité indéfinie à l’avance tout événement que je souhaite mémoriser…
if fractalHigh then // je détecte un nouveau fractal
top = 0 // je notifie qu'il y a un fractal dans ce dernier chandelier
else
top = top + 1 // j'incrémente ma variable lorsqu'il n'y a pas de nouveau fractal détecté
endif
Ensuite, pour retrouver le dernier fractal détecté : il est stocké dans fractal[top]
Si l’on veut le précédant top, il suffit de faire : PreviousTop = Top + top[top+1]
Et ainsi de suite jusqu’au premier, si l’on a pris le soins d’incrémenté un compteur de fractal détecté…
C’est pourquoi je ne comprends pas pourquoi les tableaux (tels qu’ils sont implémentés actuellement) seraient indispensables…
Surtout que les tableaux (tels qu’ils sont implémentés actuellement) ne semblent pas dynamiques (taille du tableau que l’on pourrait réduire ou augmenter, et pas seulement augmenter…)
Mais encore une fois, j’ai peut-être mal saisi toute la porté des tableaux et comment les utiliser pour en tirer le meilleur.
Autre question que je me pose concernant les tableaux.
A priori, on peut y stocker le barindex du dernier chandelier lorsqu’un événement que l’on veut pouvoir retrouver se produit.
Seulement comment retrouver toutes les données relatives à un barindex donné ? Par exemple, si j’ai besoin du close, ou du high, ou du Rsi[14](close) d’un barindex stocké dans mon tableau… Comment puis-je faire pour le retrouver ? Close[$tableau[i]] (sachant que $tableau[i] contient un barindex et non le numéro d’un chandelier qui est censé être incrémenté à chaque bar…
Est-ce à dire qu’il faut dès le départ prévoir d’autres tableaux avec toutes les données dont on aurait besoin ? (un tableau avec le close, un avec le high, un autre avec le RSI…
J’ai l’habitude par exemple de mettre en mémoire les plus haut du RSI, en utilisant une variable, de la manière suivant :
IF RSI[14](close[1])>RSI[14](close[2]) AND RSI[14](close)<=RSI[14](close[1]) THEN
PicRSI = 1
ELSE
PicRSI = PicRSI[1] + 1
ENDIF
Par la suite, si j’ai besoin de retrouver le précédant pic, il est directement accessible dans la variable PicRSI, mais je peux aussi accéder à toutes les autres données de la bar : Close, high, RSI, etc…
Si je veux le pic antérieur au précédant, je le retrouve facilement :
PreviousPic = PicRSI + PicRSI[PicRSI]
Et là encore, j’ai accès à toutes les données du chandelier [PreviousPic], son close, son high, son RSI…
Est-il possible de faire la même chose avec les tableaux, en plus simple ou en plus rapide ?
Merci d’avance pour votre aide, je suis perdu avec les tableaux…
Bjr, post par post,
#202981 : Lastset retourne le plus grand rang où on a activement entré une valeur, même si une valeur de rang plus bas a été modifiée. Arraymin et arraymax donnent respectivement la plus petite et la plus grande valeurs entrées dans le tableau quel que soit leur rang.
#202982 : si tu as un tableau avec des cases vides ou à zéro que tu veux éliminer pour diminuer la taille du tableau (je n’ai jamais eu à ce jour besoin de diminuer une taille de tableau les rangs non utilisés ou à zéro au milieu ne me gênant pas alors que changer mes numéros de rangs en cours de route m’obligerait à en tenir compte via programmation supplémentaire), alors tu peux faire un petit bout de code qui transfère rang par rang les valeurs depuis le tableau avec zéro ou vide que si elles sont différentes de zéro vers un nouveau tableau avec ses propres rangs . Le nombre max d’élément est 1000000 par tableau, sans instruction particulière.
#202984 : en prenant ton exemple de top, tu illustres avec un cas où le parcours du rang est lié à l’historique, or ce n’est pas le cas général pour celui qui veut un tableau avec indexation du rang non liée à l’historique. D’autre part avec ton exemple de top, tu sais bien que tu ne peux pas réécrire sur ancienne valeur il y a n bougies de cela, top[n], mais avec un tableau, si, et selon le problème à résoudre on peut vouloir mettre à jour une valeur passée du tableau. Tu utilises le mot « indispensable », on ne va pas dire qu’ils sont indispensables de façon générale pour tout le monde et pour tout problème à résoudre. Même si je les utilise beaucoup dans certains codes en parallèle de mon code principal pour des problèmes complexes en général à but de représentation graphique, mon algo de trading principal fonctionne très bien sans tableau par exemple. Personne n’oblige à s’en servir si on arrive à résoudre un problème sans eux. Mais inversement si on part d’un problème qu’on peut aisément résoudre sans, on ne peut pas en déduire pour autant qu’ils sont inutiles de façon générale.
#202998 : oui, si tu as ton barindex mémorisé, appelons-le « mabarre », qu’il vienne d’un tableau (mabarre=$tableau[i]) ou qu’il ait pu être mis en mémoire dans une variable pour un problème simple ne nécessitant pas de tableau, toutes les données du chandelier associé sont accessibles, non pas en mettant mabarre entre crochets (cf ton Close[$tableau[i]]) mais puisque pendant une barre lue les close, high etc sont accessibles via nombre de barres précédentes, en y faisant référence avec la différence « barindex-mabarre », donc close[barindex-mabarre] etc…
Merci beaucoup JC_Bywan pour les explications claires et précises. J’y vois plus claire maintenant… Et surtout je n’avais pas pensé à la soustraction toute simple barindex-mabarre :-)))
Le gros avantage du tableau (si j’ai bien compris cette fois-ci) est d’occuper moins de mémoire qu’avec mon système de variable donnant la position précédente, la possibilité de réaffecté des colonnes passées car n’étant pas liées historiquement aux chandeliers et peut-être aussi une exécution un peu plus rapide…
Encore merci!
Avec ton principe, si tu veux connaître les 10 derniers fractals, il faudra que tu recherches en arrière les 10 dernières fois ou ta variable TOP a changé (par ailleurs “top” est un mot réservé désormais, mais c’est un autre sujet). Avec un tableau, on récupère juste les 10 dernières colonnes.
ou si je veux savoir la valeur du Nième dernier fractal, je pourrais faire:
n = 5
f = $top[lastset(top)-n] //soit la dernière colonne moins N
Je pense qu’il faut que tu interprètes bien tous les exemples disponibles pour en saisir tout l’intérêt.
Par ailleurs les tableaux sont présents dans tous les langages de programmation, il était indispensable de les ajouter à ProBuilder.
https://fr.wikipedia.org/wiki/Tableau_(structure_de_donn%C3%A9es)
Merci Nicolas pour ton temps et les explications…
Je commence à entrevoir les possibilités…
(C’est dommage d’ailleurs, qu’il n’y ait pour l’instant qu’une dimension)
Bonjour à tous,
Je bute depuis un moment sur une difficulté concernant les tableaux :
Pour mes backtests, je souhaite mettre en variable le prix d’entrée de ma position. Simple : PrixEntrée = tradeprice. Là où je me perds c’est que je souhaite prendre un profit partiel si gain de 100 €, en vendant 50% de ma position, mais à ce moment là le tradeprice initial est modifié. Or je souhaite conserver la mémoire du prix d’entrée initial pour mettre en place une nouvelle stratégie de cloture de position.
J’ai essayé d’entrer ce tradeprice dans un tableau, pensant que cela serait la solution… J’entre la commande $PrixEntree[0] = tradeprice dès ma prise de position :
If MesConditions then
Buy 10 shares at market
$PrixEntree[0] = tradeprice
Endif
Cela ne fonctionne pas … le tradeprice n’en fait qu’à sa tête…
Figer un prix d’entrée dans une variable, que l’on puisse rappeler, est-il possible ?
Merci de votre aide !
au dessus de ta condition tu ecrit :
if longonmarket[1]=0 and longonmarket=1 then
$PrixEntree[0] = prix de transaction
endif
et si tu as plusieurs positions ce sera toujours ta premiere position
Génial ! Ca fonctionne parfaitement !!! Merci beaucoup, je butais sur ce problème depuis des jours.
