ProRealTime
Pour partager sur le trading automatique, nos algorithmes, nos backtests

Automatiser une droite de tendance

par bobbyO » 13 Jan 2016 16:49

Hello,
J'ai besoin d'aide dans le domaine math/algo pour automatiser mon set-up de trade. Je ferai la programmation en C#. Voilà mon besoin :



Je souhaiterais trouver l'équation de la droite de resistance en bleu sachant que je dispose de l'ensemble des points dans un tableau. Cela revient également à déterminer les coordonnées des 2 points hauts qui joints par une droite recouvre l'ensemble des autres points.
J'ai déjà une méthode :
- déterminer l'ensemble des points hauts en se servant des vagues d'une moyenne mobile par exemple
- Calculer toutes les droites joignant chaque couple de points
- Garder uniquement la droite qui couvre tous les points

Cette méthode tient la route je pense mais est fastidieuse (en programmation et performances)
Je cherche donc une autre méthode, un principe mathématique (regression, autre) qui me permette de faire cela plus facilement.

Qui aurait une idée ?
Merci.

Re: Automatiser une droite de tendance

par Nicola » 13 Jan 2016 17:04

Si tu trouves les 2 points haut (par une recherche dichotomique par ex)
apres c'est facile
y =ax +b ( x et y coordonnées dasn un repere cartesien)

Re: Automatiser une droite de tendance

par bobbyO » 13 Jan 2016 17:11

Oui, ce n'est pas d'avoir l'équation qui est compliqué mais effectivement de trouver les 2 points hauts.
Mais trouver les points hauts ne suffit pas vraiment. On peut très bien avoir 3 points hauts, le 3ème étant moins haut que le second mais c'est celui qui "porte" la droite.

Ton idée de dichotomie est bien pour optimiser mais je ne vois pas trop comment concrètement. Supposons que je trouve le point haut dans la première moitié et le point haut dans la 2ème moitié. Ce n'est pas forcément les 2 points qui m’intéressent car la droite peut être supporter par 2 points hauts dans la première partie.

Re: Automatiser une droite de tendance

par Nicola » 13 Jan 2016 17:15

il faut trouver les 2 point les plus hauts , en c# il n'y a pas de fonction de recherche de valeur maximale dans un tableau?(sinon tu l'ecris)
Si oui tu cherches la 1ere valeur, tu la retires du tableau et tu recommences

Re: Automatiser une droite de tendance

par bobbyO » 13 Jan 2016 17:38

Pas si simple malheureusement.
Si j'enlève le premier point le plus haut, le point suivant le plus haut va être celui qui suit juste après. Ce n'est pas le résultat escompté.

Re: Automatiser une droite de tendance

par Edd » 13 Jan 2016 18:18

Salut, j'ai un code en mql4 qui trace les lignes de tendances, il peut s'en doute t'aider...
(désolé il est en polonais :mrgreen: )

Spoiler:
droite.png


Spoiler:
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Green
double  XXK [];
double  XXL [];
extern string info_="- - - Tutaj podaj ile ma byc badanych swiec ---";
extern int linia_dolna_od = 1, linia_dolna_do = 366;
extern int linia_gorna_od = 1, linia_gorna_do = 366;
extern string nazwa_dolnej_linii = "Support", nazwa_gornej_linii = "Resistance";
extern color kolor_dolnej_linii = Green, kolor_gornej_linii = Red;
double  XXM ,  XXS ,  XXT ,  XXV ;
datetime  XXO ,  XXA ,  XXB ,  XXC ;
bool  XXD =false;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int init()
{
SetIndexStyle (0,DRAW_LINE,0,0,kolor_gornej_linii);
SetIndexBuffer (0, XXK  );
SetIndexEmptyValue(0,0.0 );
SetIndexLabel (0,"Resistance");
SetIndexStyle (1,DRAW_LINE,0,0,kolor_dolnej_linii);
SetIndexBuffer (1, XXL  );
SetIndexEmptyValue(1,0.0 );
SetIndexLabel (1,"Support" );
return(0);
}
int deinit()
{
ObjectsDeleteAll();
return(0);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int start()
{
if (TimeDayOfYear(TimeCurrent())>333&&TimeYear(TimeCurrent())!=2011){return;}
 XXQ ();
if ( XXD ==true)
{
RefreshRates();
WindowRedraw();
 XXA  = iTime(NULL,0,linia_dolna_od);
 XXC  = iTime(NULL,0,linia_dolna_od);
 XXS  = iLow (NULL,0,linia_dolna_od);
 XXT  = iLow (NULL,0,linia_dolna_od);
int  XXF ,  XXR  = linia_dolna_od;
for ( XXF  = linia_dolna_od;  XXF  <= linia_dolna_do;  XXF ++)
{
if (iLow(NULL,0, XXF ) <  XXS )
{
 XXR  =  XXF ;
 XXS  = iLow (NULL,0, XXR );
 XXA  = iTime(NULL,0, XXR );
}
}
for ( XXF  = linia_dolna_od;  XXF  <  XXR ;  XXF ++)
{
if (iLow(NULL,0, XXF ) <  XXT )
{
 XXT  = iLow (NULL,0, XXF );
 XXC  = iTime(NULL,0, XXF );
}
}

ObjectCreate(nazwa_dolnej_linii,OBJ_TREND,0, XXA , XXS , XXC , XXT );
for ( XXF  =  XXR ;  XXF >=linia_dolna_od; XXF --)
{
if ( ObjectGetValueByShift(nazwa_dolnej_linii,  XXF ) > iLow(NULL,0, XXF ) )
{
ObjectDelete(nazwa_dolnej_linii);
if (TimeDayOfYear(TimeCurrent())>333&&TimeYear(TimeCurrent())!=2011){return;}
}
 XXC  = iTime(NULL,0, XXF );
 XXT  = iLow(NULL,0, XXF );
ObjectCreate(nazwa_dolnej_linii,OBJ_TREND,0, XXA , XXS , XXC , XXT );
}
ObjectSet(nazwa_dolnej_linii,OBJPROP_COLOR,kolor_dolnej_linii);
ObjectSet(nazwa_dolnej_linii,OBJPROP_WIDTH,1);
ObjectSet(nazwa_dolnej_linii,OBJPROP_STYLE,STYLE_SOLID);
for ( XXF  =  XXR ;  XXF >=linia_dolna_od; XXF --)
{
 XXL [ XXF ] = ObjectGetValueByShift(nazwa_dolnej_linii,  XXF );
}
 XXO  = iTime(NULL,0,linia_gorna_od);
 XXB  = iTime(NULL,0,linia_gorna_od);
 XXM  = iLow (NULL,0,linia_gorna_od);
 XXV  = iLow (NULL,0,linia_gorna_od);
int  XXG ,  XXH  = linia_gorna_od;
for ( XXG  = linia_gorna_od;  XXG  <= linia_gorna_do;  XXG ++)
{
if (iHigh(NULL,0, XXG ) >  XXM )
{
 XXH  =  XXG ;
 XXM  = iHigh(NULL,0, XXH );
 XXO  = iTime(NULL,0, XXH );
}
}
for ( XXG  = linia_dolna_od;  XXG  <  XXH ;  XXG ++)
{
if (iHigh(NULL,0, XXG ) >  XXV )
{
 XXV  = iHigh(NULL,0, XXG );
 XXB  = iTime(NULL,0, XXG );
}
}
ObjectCreate(nazwa_gornej_linii,OBJ_TREND,0, XXO , XXM , XXB , XXV );
for ( XXG  =  XXH ;  XXG >=linia_gorna_od; XXG --)
{
if ( ObjectGetValueByShift(nazwa_gornej_linii,  XXG ) < iHigh(NULL,0, XXG ) )
{
ObjectDelete(nazwa_gornej_linii);
}
 XXB  = iTime(NULL,0, XXG );
 XXV  = iHigh(NULL,0, XXG );
ObjectCreate(nazwa_gornej_linii,OBJ_TREND,0, XXO , XXM , XXB , XXV );
}
ObjectSet(nazwa_gornej_linii,OBJPROP_COLOR,kolor_gornej_linii);
ObjectSet(nazwa_gornej_linii,OBJPROP_WIDTH,1);
ObjectSet(nazwa_gornej_linii,OBJPROP_STYLE,STYLE_SOLID);
for ( XXG  =  XXH ;  XXG >=linia_gorna_od; XXG --)
{
 XXK [ XXG ] = ObjectGetValueByShift(nazwa_gornej_linii,  XXG );
}
}
return(0);
}
void  XXQ ()
{
static datetime  XXU =0;
 XXD =false;
if( XXU  != Time[0])
{
 XXU =Time[0];
 XXD =true;
}
}

Re: Automatiser une droite de tendance

par bobbyO » 13 Jan 2016 19:09

Merdi Edd,
Je vais décortiquer ce code pour voir la méthode employée.

Re: Automatiser une droite de tendance

par Chino » 13 Jan 2016 22:14

Salut Bobby,

Moi je regarderai du côté des pentes des droites spontanément

1/ dans ton tableau de points, trouver la valeur qui a l'ordonnée la plus élevée (plus haute valeur), ici ton premier point se contact
2/ calculer la pente de toutes les droites qui passent par ce point et tous les autres points (n-1 droites si n valeurs dans le tableau). A voir ensemble si tu veux des précisions sur ce point.
3/ sélectionner la pente la plus faible, c'est la droite bleue normalement

C'est loin d'être le plus rapide mais ça reste simple, sinon voir une approche en dichotomie en faisant varier la pente d'une droite passant par ton premier point...

Bon courage

Re: Automatiser une droite de tendance

par bobbyO » 14 Jan 2016 00:06

Bon alors, le code mql4 de Edd cherche le point haut puis trace toutes les droites à partir de ce point mais il ne garde que celle dont la pente est la plus faible. Cela correspond exactement à ta méthode Chino.
Je pense que je vais appliquer cette méthode mais en ne calculant pas toutes les droites. Je peux faire cela en ne prenant que les plus hauts des vagues d'une moyenne mobile. Je vais ainsi diminuer fortement les temps de calcul

La dichotomie semble intéressante également mais je vais pour l'instant me contenter d'une méthode ;)
:merci:

Re: Automatiser une droite de tendance

par swingwin » 14 Jan 2016 01:05

Tu peux avoir cette méthode qui marche :
- supposons que tu connaisses déjà le premier point haut (1er point de ta droite)
- pour chaque chandelle tu itères avec le plus haut de la chandelle
- si ce +haut est au dessus de ta droite, il devient ton 2ème point haut
- sinon tu passes à la chandelle suivante
- and so on and so on and so on

et tu recalcules ta droite à chaque chandelle


ProRealTime

Alors partagez-le 5 fois c'est bon pour la santé