Calcul de l'angle de pente de la ligne de tendance. - page 15
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
Ah, bien, alors je vois)) Alors je renvoie le code, peut-être que quelqu'un d'autre queRenat Akhtyamov en aura besoin, d'ailleurs je ne m'assieds pas beaucoup sur les forums)))
//-----------------------------------------------------------------------------------
// angle x ///////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------------
double xAngle(double x1,double y1,double x2,double y2) // x1,x2 temps[] - y1,y2 prix
{
if(x1==0 || x2==0 || y1==y2){return(0);}
if(y1==y2) {return(0);}
//---
double PriceMAX=ChartGetDouble(0,CHART_PRICE_MAX,0) ;
double PriceMIN=ChartGetDouble(0,CHART_PRICE_MIN,0) ;
double Bar1proc=(double)(ChartGetInteger(0,CHART_WIDTH_IN_BARS,0)*_Period*60)/100 ;
double Price1proc=((PriceMAX-PriceMIN)/_Point)/100 ;
x1=iBarShift(NULL,0,(datetime)x1) ;
x2=iBarShift(NULL,0,(datetime)x2) ;
double x1x2=MathAbs(x1-x2)*_Period*60;
double y1y2=MathAbs(y1-y2)/_Point ;
double x1x2_proc=x1x2/Bar1proc ;
double y1y2_proc=y1y2/Price1proc ;
//---
double theta=MathArctan(y1y2_proc/x1x2_proc)*(180/3.1415926535);
if(y2<y1){theta=NormalizeDouble(theta*(-1),2);}
retour(thêta) ;
}
//+------------------------------------------------------------------+
Fonction pure, pour le calcul de l'angle, en mode automatique, avec correction par l'échelle du graphique, je l'utilise moi-même, cela fonctionne parfaitement) Quant à la stratégie de tendance, par l'angle vous pouvez estimer la force, et la durée approximative de la tendance.
Ici :
double Bar1proc=(double)(ChartGetInteger(0,CHART_WIDTH_IN_BARS,0)*_Period*60)/100 ;
double Price1proc=((PriceMAX-PriceMIN)/_Point)/100 ;
La division par 100 est redondante. Dans la formule finale, ils (100) sont placés au numérateur et au dénominateur lors du calcul du thêta. Et ils sont abrégés.
Ici :
double Price1proc=((PriceMAX-PriceMIN)/_Point)/100 ;
double y1y2=MathAbs(y1-y2)/_Point ;
la division par _Point est redondante. Il en va de même pour la division par 100.
Dans la formule finale, le double y1y2_proc=y1y2/Price1proc ;
Les points du numérateur et du dénominateur sont réduits.
Ces simplifications permettent, d'une part, de réduire les calculs (charge du processeur) et, d'autre part, d'augmenter éventuellement la précision du résultat final.
===============================
Ou peut-être devriez-vous essayer d'utiliser la fonction ChartTimePriceToXY pour déterminer les valeurs des pixels aux points d'ancrage de l'outil graphique.
Il est plus facile de calculer des fonctions trigonométriques en utilisant le nombre de pixels horizontalement et verticalement. Sans la conversion des barres et des points.
Cela devrait être beaucoup plus simple.
//-----------------------------------------------------------------------------------
// angle x ///////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------------
double xAngle(datetime x1,double y1,datetime x2,double y2) // x1,x2 Time[] - y1,y2 Price
{
if(x1==0 || x2==0 || y1==y2){return(0);}
int _x1, _y1, _x2, _y2 ;
ChartTimePriceToXY(0,0,x1,y1,_x1, _y1) ;
ChartTimePriceToXY(0,0,x2,y2,_x2, _y2) ;
double theta=MathArctan((double)MathAbs(_y1-_y2)/(double)MathAbs(_x1-_x2))*(180/3,1415926535) ;
if(y2<y1){theta=NormalizeDouble(theta*(-1),2);}
retour(thêta) ;
}
Ici si(y2<y1){theta=NormalizeDouble(theta*(-1),2);} ajuster le signe par le résultatIci :
.........
Cela devrait être beaucoup plus simple.
Oui, tout cela est complètement inutile car cela dépend de l'échelle définie par l'utilisateur, qui peut être différente sur différents graphiques.
La seule solution correcte est de mesurer l'évolution du prix par unité de temps.
Une tendance de "0,0001 eurodollar par heure" sera dessinée exactement de la même manière par n'importe qui, indépendamment de toute échelle, ou même de toute plateforme.
Tout ceci est totalement inutile car cela dépend de l'échelle définie par l'utilisateur, qui peut être différente sur différents graphiques.
La seule solution correcte est de mesurer l'évolution du prix par unité de temps.
Une tendance de "0,0001 eurodollar par heure" sera dessinée exactement de la même manière par n'importe qui, indépendamment de toute échelle, ou même de toute plateforme.
Je ne faisais pas attention au sujet du fil de discussion. Il était intéressant de calculer l'angle pour faire des inscriptions inclinées parallèles à la tendance. J'ai écrit une fonction simplifiée pour calculer l'angle ci-dessus. Cela ne dépend pas du tout de l'échelle. Pour éviter la déformation de l'inscription lors du changement d'échelle et d'autres propriétés du graphique, vous pouvez utiliser CHARTEVENT_CHART_CHANGE
=========
Je voulais afficher une légende près des lignes, comme sur l'image. Avec la fonction modifiée ci-dessus, voici comment cela s'est passé :
Je voulais afficher les étiquettes près des lignes, comme dans l'image. Voici comment cela s'est passé avec la fonction ci-dessus :
Je suis d'accord avec vous, je n'aime pas ça, mais quand j'ai initialement créé cette fonction, j'ai vérifié plusieurs façons différentes, et ensuite je ne l'ai pas changé) et à propos des pixels, je suis complètement d'accord avec vous, le calcul le plus idéal de l'angle pour moi personnellement est de cette façon, voici ma fonction :
//-----------------------------------------------------------------------------------
// xAnglePixels /////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------------
double xAnglePixels(datetime x1,double y1,datetime x2,double y2) // x1,x2 Temps[] - y1,y2
{
if(x1==0 || x2==0 || y1==y2){return(0);}
//---
int x[2],y[2] ;
ChartTimePriceToXY(0,0,x1,y1,x[0],y[0]) ;
ChartTimePriceToXY(0,0,x2,y2,x[1],y[1]) ;
//---
if(x[1]<x[0]){return(-1000);}
//---
double x1x2=MathAbs(x[0]-x[1]);
double y1y2=MathAbs(y[0]-y[1]);
//---
double thêta ;
if(x1x2!=0){theta=MathArctan(y1y2/x1x2)*(180/3.1415926535);}
else{theta=90;}
if(y2<y1){theta=NormalizeDouble(theta*(-1),2);}else{theta=NormalizeDouble(theta,2);}
retour(thêta) ;
}
//---------------------------------------------------------------------------------
p.s. dans la fonctionif(x[1]<x[0]){return(-1000);} peut être supprimée, car je l'ai utilisée pour moi-même), et plus particulièrement elle est nécessaire si l'utilisateur a interverti deux points de l'objet à certains endroits.
//-----------------
A propos, pour les inscriptions sur le graphique, je l'utilise. Plus tôt dans la branche j'ai posté des exemples de travail de cet indicateur, là vous pouvez le voir.
//-----------------
Un grand merci à vous et au respect)
Il était intéressant de calculer l'angle pour faire des inscriptions obliques parallèles à la tendance. Ci-dessus, j'ai écrit une fonction simplifiée pour calculer l'angle. Cela ne dépend pas du tout de l'échelle.
Oui, c'est une question différente. Ici, il ne s'agit pas de déterminer la tendance, mais de déterminer la pente de la ligne affichée sur le moniteur. Et dans ce cas, c'est la bonne voie. Et tout est beau sur la photo.
Si nous nous basons sur vos propos, l'idée est que nous pouvons tracer des lignes de tendance et qu'elles montreront la direction de la tendance, et l'angle droit sera montré par rapport à la ligne tracée sans aucune altération. J'ai joint un exemple dans l'image, mon robot est construit selon les règles, mais l'essentiel est clair.
L'image est une visualisation de vos calculs. Vous pouvez déformer les proportions de la visualisation (changer l'échelle du graphique) et l'image changera de manière significative - les lignes changeront leurs angles de pente en degrés. Mais les résultats de vos calculs ne changeront pas lorsque vous changerez d'échelle. À moins, bien sûr, que vous ne calculiez les tendances en pixels.
Je suis d'accord avec vous, mais vous comprenez que sur chaque TF, les tendances sont différentes, ce qui semblait grand sur un petit, est devenu petit sur un plus grand, et les pentes changeront, juste la représentation de la tendance change, pas le système de mesure de l'angle, si le système de mesure change, rien de bon n'en sortira.