Problèmes de fermeture, aidez-nous - page 8
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Bonjour Cameofx,
Merci pour votre réponse.
Ce système de codage est très simple et facile.
Tout est fait manuellement dans MetaEditor.
En fait, le système est conçu pour développer de grands programmes facilement et à grande vitesse.
Le système devrait également être flexible et fiable.
Meilleures salutations !
Ais, merci pour votre réponse. J'ai beaucoup appris de vos messages :)
Cameo
Salut les amis !
Une chose du passé plane sur moi jour après jour.
Ceci est une documentation sur AIS5 Trade Machine.
Je reviendrai dès que Dieu le décidera.
Au revoir pour le moment !
Bonjour Ais
Votre absence nous manquera cruellement. Prends soin de toi.
Nous nous réjouissons de ton retour.
Ton ami, Cheers
Bonjour Ais
Je n'arrive pas à trouver de réponse ferme dans le livre ou le forum. Dans un schéma de logique de relais, une porte ET fonctionnerait de la même manière que l'exemple ci-dessus. Ce n'est que lorsqu'il y a deux entrées "vraies" qu'il y a une sortie "vraie". Ce n'est qu'à ce moment-là que le contrôle se poursuit.A votre retour, je suis désolé de vous accabler immédiatement de nouvelles questions. Ce n'est pas votre système en particulier, j'ai ce problème avec presque tous les programmes. Il s'agit des fonctions définies par l'utilisateur. Comment la fonction définie par l'utilisateur obtient-elle sa définition.
Par exemple :
Dans l'attente de votre réponse. Merci d'avance.
Salutations
Hello Huckleberry
Clarifions cette partie du code.
1. Probablement des difficultés majeures :
1.1. Tous les humains pensent et agissent différemment ;
1.2. J'aime utiliser un nombre strictement limité de types de données ;
1.3. Je n'aime utiliser que des types de données "standard" :
1.3.1. "int",
1.3.2. "double",
1.3.3. "string" ;
1.4. Je n'utilise d'autres types de données que dans des cas particuliers ;
1.5. Je désigne le type des éléments de mon programme par une petite lettre en première position du nom :
1.5.1. "i" pour le type de données "int",
1.5.2. "d" pour le type de données "double",
1.5.3. "s" pour le type de données "string",
1.5.4. "r" pour le type de données "undefined" ;
1.6. cette technique de programmation m'aide à contrôler le casting de type ;
1.7. les fonctions et constantes prédéfinies peuvent également avoir les types de données suivants :
1.7.1. "bool",
1.7.2. "color",
1.7.3. "datetime" ;
1.8. J'essaie toujours de convertir ces types en type "int" ;
1.9. aujourd'hui, la conversion des données est généralement implicite ;
1.10. quelques éléments essentiels de mes techniques de programmation :
1.10.1. J'ai aimé utiliser la paire de constantes "TRUE" et "EMPTY" au lieu de la paire de constantes "TRUE" et "FALSE" ;
1. 10.2.10.2. Dans les instructions "if", j'ai parfois utilisé "1" et "0" au lieu de "VRAI" et "FAUX" ;
1.10.3. J'ai utilisé la constante "EMPTY" avec la valeur négative "-1" pour indiquer les résultats invalides pour les éléments de données non signés ;
1.10.4. à l'avenir, j'utiliserai le type "bool" avec le préfixe "b" dans les noms.
2. Nous devons connaître les types de données MQL4 suivants :
2.1. "int" est un nombre entier <!>signé</!> de 4 octets avec des valeurs de -2147483648 à 2147483647 ;
2.2. "datetime" est un <!> non signé</!>.>unsigned</!> long nombre entier de 4 octets avec des valeurs de 0 à 4294967295 ;
2.3. En assignant les valeurs de "datetime" aux variables "int", nous obtenons des résultats corrects jusqu'à environ 2038.01.01.
3. Nous devons connaître la fonction "iTime ( symbol, timeframe, shift )" comme suit :
3.1. cette fonction retourne toujours une valeur de type "datetime" ;
3.2. il y a 2 cas différents de retour :
3.2.1. "0" si l'historique local est vide ;
3.2.2. le temps d'ouverture de la barre indiqué par "shift" dans tous les autres cas ;
3.3. "iTime ( 0, 0, 0 )" renvoie le temps d'ouverture de la barre zéro du graphique actuel ;
3.4. si la barre zéro est la même, "iTime ( 0, 0, 0 )" renvoie la même valeur ;
3.5. lorsque la barre zéro actuelle est terminée, cette barre est devenue la barre numéro 1 et la formation d'une nouvelle barre zéro commence ;
3.6. "iTime ( 0, 0, 0 )" renvoie la nouvelle valeur ;
3.7. ainsi, la valeur de "iTime ( 0, 0, 0 )" change lorsque la barre zéro change.
4. Nous avons empêché le travail avec un historique vide dans le bloc de programme "2.2.3.1. Inspection des données de l'historique".
5. Lorsque l'ordre est fermé avec succès, dans la fonction "iTryClose", nous assignons "iTradeBarTime = iTime ( 0, 0, 0 ) ;".
6. Dans la fonction "iSignalOpen", nous vérifions si "iTradeBarTime == iTime ( 0, 0, 0 ) )".
7. Si c'est vrai et que le trade répété est interdit par "iTradeBarOnce = 1 ;" alors nous interdisons l'ouverture du signal par la valeur "EMPTY".
Salutations
Bonjour Ais
Je vous remercie pour votre réponse. Je vais étudier la question et je reviendrai bientôt.
Cheers
Bonjour Ais,
Désolé pour ma réponse tardive. J'ai repris le travail à mon poste habituel lundi. Le temps est un peu plus court ces jours-ci. Le temps d'étude est plus court.
Comme je l'ai mentionné plus tôt dans ce fil, j'aime décomposer les choses en écrous et boulons. Comment un pignon fournit de la puissance à un autre et ainsi de suite. J'ai donc trouvé que le contrôle au sein du programme est fascinant. Comprenez que je vous donne tout le respect dû à la patience et aux connaissances que vous avez fournies, mais j'ai des questions sur la raison pour laquelle le bloc 2.2.3.1 est nécessaire.
Comment le iBaseLag + iBaseBar peut-il être une expression ?
J'ai compris que iBaseLag et iBaseBar sont dans le paramètre pour iHighest et iLowest. À moins qu'il ne s'agisse de nombres explicites,
comment peut-on déterminer quel sera le nombre exact. iBaseLag est 20, ce qui représente 20 barres utilisées pour le calcul de la moyenne.
iBaseBar représente la barre à laquelle la moyenne doit commencer. Les barres 1 à 20, dans ce cas, la barre zéro n'est pas prise en compte.
J'ai pris la liberté de raccourcir le programme par /* 2.2.3.1*/. J'ai testé le programme et j'ai trouvé les mêmes résultats. En exécutant le programme dans des conditions réelles de trading, ce n'est peut-être pas une bonne idée.
Quel est votre avis ?
De plus, votre explication du bloc 2.1.2 a clarifié ma confusion. L'iTime renvoie l'heure d'ouverture de la barre zéro.
iTradeBarTime est également une date de type cast. Le programme sait à quelle barre la transaction a eu lieu, donc une seule transaction par barre . . iTradeBarOnce == 1
Merci.
Je vais étudier davantage dans les jours à venir. Mais le bloc réservé 2.1.1 peut-il être utilisé pour une fonction qui fournirait des positions supplémentaires à des positions existantes. Exemple : une position longue existante, puis l'ajout de trois positions longues ou plus ?
Avec les fonctions qui sont déjà dans le programme, y aurait-il des conflits avec des positions additionnelles ?
Merci encore pour tout. Bonne continuation
Salutations
Bonjour Huckleberry,
Regardons attentivement la partie principale du programme, notamment le bloc 2.2.3.1 :
////////////////////////////////////////////////////////////////////< 14> // < 2.2.3. Code : Special : Start > //< > int start () // - i 9 l - o //< > { //< > // < 2.2.3.1. History data inspection 4 >`````````````````````````//< > static int iTrigger = 0 ; if ( iTrigger == 0 ) { //< > if ( ( iTime ( 0 , 0 , 0 ) == 0 ) //< > || ( iBars ( 0 , 0 ) < iBaseLag + iBaseBar ) ) //< > return ; else iTrigger = 1 ; } //< > // </2.2.3.1. History data inspection 4 >`````````````````````````//< > // //< > // < 2.2.3.2. Main routine 3 >````````````````````````````````````//< > int iTicket = iGetTicket () ; //< > // //< > if ( iTicket < 0 ) iTryOpen () ; //< > else iTryClose () ; //< > // </2.2.3.2. Main routine 3 >````````````````````````````````````//< > // //< > // < 2.2.3.3. Exception handler 2 >```````````````````````````````//< > int iTrap = GetLastError () ; //< > if ( iTrap > 0 ) Alert ( "Exception " , iTrap ) ; //< > // </2.2.3.3. Exception handler 2 >```````````````````````````````//< > } //< > // </2.2.3. Code : Special : Start > //< > ////////////////////////////////////////////////////////////////////< 0>1. le bloc 2.2.3.1., le tout premier bloc du programme, est un simple trigger :
1.1. "static int iTrigger" stocke sa propre valeur pendant toute la durée de vie du programme, c'est "static" ;
1.2. initialement "iTrigger == 0" ;
1.3. l'instruction "if ( iTrigger == 0 )" est exécutée à chaque tick ;
1.4. la toute première fois, lorsque "iTrigger == 0", l'inspection des données historiques est exécutée à l'intérieur du bloc {..} ;
1.5. si les données historiques sont incorrectes, l'instruction "return ;" est exécutée ;
1.6. cela signifie que l'exécution de la fonction principale "start ()" est terminée ;
1.7. au prochain tick, l'instruction "if ( iTrigger == 0 )" est exécutée à nouveau ;
1.8. si les données historiques sont correctes, l'instruction "iTrigger = 1 ;" est exécutée ;
1.9. alors l'exécution de la fonction principale "start ()" continue ;
1.10. au tick suivant, l'instruction "if ( iTrigger == 0 )" est exécutée à nouveau ;
1.11. la valeur de "iTrigger" maintenant et dans le futur sera toujours "== 1" parce qu'elle est statique ;
1.12. ainsi, dans le futur, l'inspection des données historiques sera toujours sautée ;
1.13. tel est le trigger simple ;
2. l'inspection des données d'historique se compose de deux parties :
2.1. vérifier si l'historique local est vide "iTime ( 0, 0, 0 ) == 0" ;
2.2. vérifier si la taille de l'historique local est suffisante pour le calcul de "iATR ( 0, 0, iBaseLag, iBaseBar )", où :
2.2.1. "iBaseBar" est la barre de départ pour "iATR" ;
2.2.2. "iBaseLag" est le nombre de barres de moyenne pour "iATR" ;
2.2.3. "iBaseLag + iBaseBar" est une expression usuelle, le résultat est toujours une somme de "iBaseLag" et "iBaseBar" ;
2.2.4. en d'autres termes, l'expression "iBaseLag + iBaseBar" est équivalente à la somme de "iBaseLag" et "iBaseBar" ;
2.2.5. nous pouvons attribuer n'importe quelle valeur à "iBaseLag" et "iBaseBar" dans l'entrée de programme du bloc 1.1.1. ;
2.2.6. nous pouvons attribuer "iBaseLag = 100 ;" et "iBaseBar = 7 ;" ;
2.2.7. alors le calcul correct de "iATR ( 0, 0, iBaseLag, iBaseBar )" sera possible, si la taille de l'historique local est égale ou supérieure à 107, parce que le dernier numéro de barre pour le calcul est #106 et le numéro de barre zéro est toujours considéré.
Il est possible d'ajouter un nombre quelconque de fonctions dans n'importe quel programme, le bloc 2.1.1 ne fait que montrer un exemple de mise en œuvre possible.
La fourniture de positions supplémentaires nécessitera un code d'analyse et de gestion des positions beaucoup plus complexe que la fonction 2.1.4.
Mais tout est possible.
Salutations
Bonjour Ais
Merci pour votre réponse rapide. Je peux suivre une grande partie de ce que vous dites. Surtout en ce qui concerne la fonction iATR. Vous dites que l'utilisation de l'expression iBaseLag + iBasebar, en soi, est une partie acceptable de la formule. J'avais l'impression qu'ils devaient être avec dans les paramètres d'une fonction définie ou ils n'étaient pas autorisés. C'est pour vérifier la taille de l'historique local, s'il y a effectivement assez de barres pour continuer. Est-ce là ce que vous voulez dire ? Tant d'étapes supplémentaires, mais des étapes nécessaires pour atteindre le but. Des étapes qui seraient négligées, ou considérées comme allant de soi.
Je vais ruminer un peu plus sur le reste. Je vous remercie pour votre temps.
Au revoir
Bonjour Huckleberry
MQL4 est un environnement très convivial, surtout en comparaison avec, par exemple, le C ou les assembleurs.
Les besoins en vérifications diverses et autres astuces sont considérablement réduits.
Mais l'implémentation du maximum de vérifications possibles dans l'environnement de développement réduit toujours les performances.
De toute façon, le programmeur est toujours responsable du mauvais comportement du programme.
Ainsi, pour moi, une revérification redondante est préférable, par exemple, à une corruption élémentaire des limites.
Au revoir