Sur MT4 je cherche a simplifier une condition...

Hello,
Je sais que la plupart de vous code sur prt mais bon j'essaie quand meme.
Je bricole quelques algo sur MT4 et je cherche a simplifier ce genre d'ecriture:

double MM5_1 = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,1);
double MM5_2 = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,2);
double MM5_3 = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,3);
double MM5_4 = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,4);
double MM20_1 = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,1);
double MM20_2 = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,2);
double MM20_3 = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,3);
double MM20_4 = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,4);

if(
MM5_1 < MM20_1
&& MM5_2 < MM20_2
&& MM5_3 < MM20_3
&& MM5_4 < MM20_4
)

bool MMenBaisse = true;

Pour schematiser la condition est (en periode de baisse):
la MM5 est en dessous de la MM20 pendant une certaine periode (ici periode de 4 bougies)

La question: il y a t il un moyen de definir une condition qui se realise pendant "n"periodes sans avoir a ecrire les "n" periodes une par une?
Je sais meme pas si ma question est claire...lol

Salut lool,

Tu compares 4 variations de 2 indicateurs deux à deux. Si tu mets la valeur de tes variations d'indicateurs dans deux tableaux de double, tu peux mettre tes comparaisons dans une boucle et faire quelque chose comme cela :

Code : #

#define NB_MM 4

   double MM5[NB_MM];
    MM5[0] = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,1);
    MM5[1] = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,2);
    MM5[2] = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,3);
    MM5[3] = iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,4);

    double MM20[NB_MM];
    MM20[0] = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,1);
    MM20[1] = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,2);
    MM20[2] = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,3);
    MM20[3] = iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,4);

    bool MMenBaisse = true;
    for (int i = 0; i < NB_MM; i++)
        if (MM5[i] > MM20[i])
            MMenBaisse = false;

Cela fonctionne en reversant le test. Si je comprends bien ton code, il faut que toutes les MM5 soient inférieures aux MM20 correspondantes pour que la condition MMenBaisse soit vraie. Donc, cela signifie que si au moins l'une d'elles est supérieure, le test échoue.

J'ai mis la boucle for et son contenu sur 3 lignes car je trouve cela plus clair.

Si tu veux gagner de l'espace verticalement, tu peux aussi écrire ces 3 lignes

Code : #

    for (int i = 0; i < NB_MM; i++)
        if (MM5[i] > MM20[i])
            MMenBaisse = false;

comme cela :

Code : #

   for (int i = 0; i < NB_MM; i++) if (MM5[i] > MM20[i]) MMenBaisse = false;

Mon Dieu comme c'est brillant!!

C'est pour ca que je dit toujours que je "bricole" avec Mql4... meme apres 2 ans a bricoler des algos... J'ai toujours eu du mal avec la boucle for...

Merci Trds!!! "You made my day" comme on dit par chez moi...

Sinon, moi je ferais une petite fonction optimisée:

Code : #

#define NB_MM 4
bool MMenBaisse = TestMM();

// procédure qui compare les MM5 et MM20 sur 4 périodes
bool TestMM()
{
    for (int i=0; i<NB_MM; i++) {
        // on compare MM5 et MM20 pour chaque i
        if (iMA(NULL,0,5,0,MODE_SMA,PRICE_CLOSE,i) >= iMA(NULL,0,20,0,MODE_SMA,PRICE_CLOSE,i)) return(false);
    }

    // si on est encore dans la fonction, la condition est vraie
    return(true)
}

De cette manière, tu ne testes pas toujours tous les i, tu sors de la boucle dès que le test est faux.

@kero: l'idée de faire une fonction est intéressante, mais est-ce ta boucle n'effectue pas 4 fois le même test ?

@lool: No Problem

MQL4 ressemble beaucoup à du C (avec des extensions et des fonctions particulières facilitant l’interaction avec les flux de données, les indicateurs, le compte de trading, etc.), aussi, si tu veux mieux appréhender les bases du langage, tu pourrais suivre un tutoriel de langage C. Cela t'aidera à mieux maîtriser les types, structures de données, boucles, etc. Tu n'as pas besoin de le faire en entier (les entrées/sorties clavier, écran, fichiers seront hors sujet, l'allocation dynamique de mémoire aussi, etc.), mais juste pour acquérir les bonnes bases.

Oui, merci Trds. Petite erreur de codage. Remplacer le "1" par "i".

C'est corrigé.

Sinon, il suffit aussi d'ajouter un "break;" dans ta boucle.

@kero: non, je pense qu'il faudrait que cela soit "i + 1" vu la façon dont lool initialise ses indicateurs

Correct aussi.

J'avoue que j'initialise mes indicateurs comme un enfant de 4 ans... par default...Pardon...

Ce que j'aime avec la petite fonction de kero c'est que je peux effectivement sortir de la boucle quand le resultat est "false"
et que je peux attribuer une valeur a "NB_MM" au démarrage de l'algo dans la boite de dialogue... (input double NB_MM = 50)
sans avoir a initialiser pendant 2 heures mes indicateurs
Bon bah je sais quoi faire ce week end!!!

Par contre si j'ai bien compris je n'ai meme pas besoin d'initialiser les indicateurs puisqu'il sont ecrit dans la boucle.... avec la fonction de kero?
Me trompe-je?

Oui, tes arrays MM5[NB_MM] / MM20[NB_MM] sont parfaitement inutiles. Dans ma fonction tu compares directement les MM au lieu de stocker d'abord leur valeur dans les arrays.

Dans MQL5, l'appel aux indicateurs (iMA comme les autres) retourne un handle et n'est destiné à être fait qu'une fois. A chaque itération les données produites par les indicateurs sont calculées par le terminal MT5 (une fois), et l'accès aux données produites se fait en accédant à la mémoire tampon gérée par l'indicateur et permet même d'accéder à une plage de valeurs précédentes, sans recalculs.

Je ne connais pas très bien MQL4 (je pratique plutôt MQL5 qui fonctionne différemment), mais je comprends que iMA opère le calcul à chaque fois qu'elle est appelée, et je comprends que c'est ainsi que fonctionnent de façon générale les appels aux indicateur sous MQL4.

https://docs.mql4.com/indicators/ima

Si on fait une fonction, elle va effectuer ce calcul à chaque appel, multiplié par le nombre d'itérations de la boucle dans tes tests. C'est donc consommateur de ressources de calcul.

Si, ensuite, tu as besoin de consulter la valeur retournée par un ou plusieurs de ces indicateurs pour comparer l'éloignement des prix, ou quoi que ce soit d'autre, tu vas de nouveau appeler iMA et refaire ce calcul, etc.

Dans un tel cas, il peut être judicieux de précalculer ces valeurs et les stocker, pour les réutiliser à ta guise autant que fois que tu le souhaite, sans recalculer quelque chose qui l'a déjà été.

@Trds : oui je comprends tres bien ce que tu veux dire... suivant la complexité de ton programme et/ou du nombre de conditions, faire les calculs a chaque fois peut effectivement etre consommateur de ressources et millisecondes.

Merci a tout les 2 pour votre aide!

Je vais developper ca ce week end...

le code est pas optimisé : il va calculer 8 Moving Average à chaque tick. Alors qu'il ne faut les calculer qu'au début de chaque candle