Automatiser une droite de tendance

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 :

Capture.PNG (48.03 Kio) Vu 2084 fois

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.

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)

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.

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

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é.

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 )

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;
}
}

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

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

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

Salut -,
Effectivement, c'est une variante intéressante.
En fait je m'aperçois que ce qui me manquait, c'était ce premier point haut. Une fois qu'on l'a, on n'a plus qu'à itérer, cela devient plus simple.
Merci.