Pour l’instant ce code est inconnu des profanes mais certains compensent ce manque de visibilité par d’autres oscillateurs !
Ce lien vous en dira d’avantage. C’est ce que j’ai trouvé de plus concret.
Le problème n’est plus désormais, le code de l’indicateur mais plus sont interprétation.
Bien que je tienne à vous signaler que Belkhayate nous cache quelque chose. Un autre indicateur complémentaire existe qui maximise le taux de réussite. A suivre !
Voici pour plus d’éclaircissement :
Je sais récompenser mes lecteurs assidus. Ce nouvel article porte le nom de “Les secrets de Belkhayte” car il s’agit de lever le mystère sur la fameuse technique et outil de trading de Mustafa Belkhayate dit “Le centre de gravité”.
Si vous n’avez aucune notion boursière cela ne vous sert a rien. En revanche si vous êtes trader et un peu mathématicien et informaticien je vais vous donner une information qui vaut son pesant d’or.
Mustafa Belkhaye est un renommé trader marocain ayant fait ses études en France qui a mis au point un indicateur qu’il appel “Le centre de gravité” qui permet d’anticiper les cours boursiers avec une forte probabilité. En fait d’après mes recherche, il s’agit plus de deux indicateurs pris simultanément qui donnent de bon résultats. Mais ne bridons pas notre plaisir de révéler le code de l’un d’eux. Celui du Centre de Gravité et de ses courbes parrallèles.
Je ne pourrais pas vous donner le code en EasyLanguague mais seulement en C++ qui, je pense est le language de programmation de la plateforme Méta-Trader-4 (MT4).
Le voici :
//+——————————————————————+
//| Center of Gravity.mq4 |
//| Original Code from NG3110@latchess.com |
//| Linuxser 2007 for TSD http://www.forex-tsd.com/ |
//+——————————————————————+
#property copyright “ANG3110@latchess.com”
//———ang_PR (Din)——————–
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 RoyalBlue
#property indicator_color2 LimeGreen
#property indicator_color3 LimeGreen
#property indicator_color4 Goldenrod
#property indicator_color5 Goldenrod
//———————————–
extern int bars_back = 125;
extern int m = 2;
extern int i = 0;
extern double kstd = 2.0;
extern int sName = 1102;
//———————–
double fx[], sqh[], sql[], stdh[], stdl[];
double ai[10,10], b[10], x[10], sx[20];
double sum;
int ip, p, n, f;
double qq, mm, tt;
int ii, jj, kk, ll, nn;
double sq, std;
//*******************************************
int init()
{
IndicatorShortName(“Center of Gravity”);
SetIndexStyle(0, DRAW_LINE);
SetIndexBuffer(0, fx);
SetIndexBuffer(1, sqh);
SetIndexBuffer(2, sql);
SetIndexBuffer(3, stdh);
SetIndexBuffer(4, stdl);
p = MathRound(bars_back);
nn = m + 1;
ObjectCreate(“pr” + sName, 22, 0, Time[p], fx[p]);
ObjectSet(“pr” + sName, 14, 159);
return(0);
}
//———————————————————-
int deinit()
{
ObjectDelete(“pr” + sName);
}
//**********************************************************************************************
int start()
{
int mi;
//——————————————————————————————-
ip = iBarShift(Symbol(), Period(), ObjectGet(“pr” + sName, OBJPROP_TIME1));
p = bars_back;
sx[1] = p + 1;
SetIndexDrawBegin(0, Bars - p - 1);
SetIndexDrawBegin(1, Bars - p - 1);
SetIndexDrawBegin(2, Bars - p - 1);
SetIndexDrawBegin(3, Bars - p - 1);
SetIndexDrawBegin(4, Bars - p - 1);
//———————-sx——————————————————————-
for(mi = 1; mi <= nn * 2 - 2; mi++)
{
sum = 0;
for(n = i; n <= i + p; n++)
{
sum += MathPow(n, mi);
}
sx[mi + 1] = sum;
}
//———————-syx———–
for(mi = 1; mi <= nn; mi++)
{
sum = 0.00000;
for(n = i; n <= i + p; n++)
{
if(mi == 1)
sum += Close[n];
else
sum += Close[n] * MathPow(n, mi - 1);
}
b[mi] = sum;
}
//===============Matrix=======================================================================================================
for(jj = 1; jj <= nn; jj++)
{
for(ii = 1; ii <= nn; ii++)
{
kk = ii + jj - 1;
ai[ii, jj] = sx[kk];
}
}
//===============Gauss========================================================================================================
for(kk = 1; kk <= nn - 1; kk++)
{
ll = 0; mm = 0;
for(ii = kk; ii <= nn; ii++)
{
if(MathAbs(ai[ii, kk]) > mm)
{
mm = MathAbs(ai[ii, kk]);
ll = ii;
}
}
if(ll == 0)
return(0);
if(ll != kk)
{
for(jj = 1; jj <= nn; jj++)
{
tt = ai[kk, jj];
ai[kk, jj] = ai[ll, jj];
ai[ll, jj] = tt;
}
tt = b[kk]; b[kk] = b[ll]; b[ll] = tt;
}
for(ii = kk + 1; ii <= nn; ii++)
{
qq = ai[ii, kk] / ai[kk, kk];
for(jj = 1; jj <= nn; jj++)
{
if(jj == kk)
ai[ii, jj] = 0;
else
ai[ii, jj] = ai[ii, jj] - qq * ai[kk, jj];
}
b[ii] = b[ii] - qq * b[kk];
}
}
x[nn] = b[nn] / ai[nn, nn];
for(ii = nn - 1; ii >= 1; ii–)
{
tt = 0;
for(jj = 1; jj <= nn - ii; jj++)
{
tt = tt + ai[ii, ii + jj] * x[ii + jj];
x[ii] = (1 / ai[ii, ii]) * (b[ii] - tt);
}
}
//===========================================================================================================================
for(n = i; n <= i + p; n++)
{
sum = 0;
for(kk = 1; kk <= m; kk++)
{
sum += x[kk + 1] * MathPow(n, kk);
}
fx[n] = x[1] + sum;
}
//———————————–Std———————————————————————————–
sq = 0.0;
for(n = i; n <= i + p; n++)
{
sq += MathPow(Close[n] - fx[n], 2);
}
sq = MathSqrt(sq / (p + 1)) * kstd;
std = iStdDev(NULL, 0, p, MODE_SMA, 0, PRICE_CLOSE, i) * kstd;
for(n = i; n <= i + p; n++)
{
sqh[n] = fx[n] + sq;
sql[n] = fx[n] - sq;
stdh[n] = fx[n] + std;
stdl[n] = fx[n] - std;
}
//——————————————————————————-
ObjectMove(“pr” + sName, 0, Time[p], fx[p]);
//—————————————————————————————————————————-
return(0);
}
//==========================================================================================================================
Voici donc le code en C++ donc pour la plateforme MT4. Si vous voulez plus d’informations je peux même vous donner le programme et quelques conseils supplémentaire si vous laisser vos mails en commentaire.
Voila le résultat sur l’EuroStox en 15 minutes :
N’hésitez pas à visiter mon BLOG sur la psychologie des traders : http://neuro-economie.blogspot.com/
