Viop altýn/usdtry sistemli trade

[cengizz]

Bu paylaþtýðým resim önünüzü görme açýsýndan çok çok önemli. "Þu an neredeyiz?" diye tespit için.
-Herhangi bir enstrümanda poz. açmadan önce muhakkak bu indikatörlerin incelenmesinde fayda görüyorum.
-Tek kelimeyle burda anlatýlmak istenen þey "yeþil close line, open olan kýrmýzýdan büyükse veya küçükse"
-Resimde dairelere dikkat çektim. Anlaþýlýr olmasý için de sinyal üremiþ olan barlara manuel ok koydum.
-Yeþil macd çizgisine koyduðum lacivert çizgi, 0 referansýný gösterir ve kullanýmý isteðe baðlýdýr. Yani sadece 0 referansýný da kullanabilirsiniz ya da sinyale dahil edebilirsiniz.
-Resimde görüleceði gibi ben macd deðerini düþük kullandým, biraz kurcalamayla siz kendinize uygun bir parametre de bulabilirsiniz.
-Grafik aylýk zaman diliminde kullanýlmalý zira varolan/halihazýrda devam eden trendi gösterir.


Bu indikatör çok amaçlý kullanýlabilir. Hem trend hem de ideal fiyatý yakalama takibi ile 1-2 günlük scalping þeklinde. Daha da ötesi UZUN VADELÝ (15-20 yýl) hisse senedi biriktirenler için sadece 0 referansýna doðru yaklaþan alým sinyali geldiðinde paçal yatýrým için kullanmak mümkün. Bol þans.

[cengizz]

Parabolic Sar,

Günlük scalping için uygun bi çalýþma,
Eðer günlükte ideal ya da size göre uygun fiyatý yakalarsanýz bu indikatörün yönü itibari ile para kazanýlýr. Bu indikatörün yüzünün ne tarafa doðru dönük olduðuna bakýlýp ideal fiyat yakalanmaya çalýþýlýr ve eðer viop kontratlarýnda iþlem yapýlacaksa x30yvade'de günde 300-500 puan yakalanýnca ekran kapatýlýr ta ki yarýna kadar. Bol þans.

[fiestaciboo]

Tþkrlr sn. fiestaciboo,
Hiç bir faydasý olmayan derinlik ve hacim ile alýcý satýcý dengesini izlemek için. Halbuki onlarý seyrettiðinde de zarar ediyor ama yeni baþlayan ya da borsa hayatý 3-5 yýl olan bilmiþ tiplere bunlarý anlatamazsýn.

Cengiz hocam ben hisseciyim ve hisseden baþka bir yatýrýmým da yoktur VOB 24/ cafe ve daha birçok topigi de düzenli olarak okurum oralarda herkes sadece fikrini yazýyor sanki bu ülkede fikri olmayan tek bir kiþi varmýþ gibi adam hiç düþünmeden fikir saçýyor temel yok grafik yok gerekçe yok öðretici hicbirsey yok...þu sizin 12 sayfalýk topicte dahi birçok þey öðrendim ne zamandýr böyle bir yer ariyordum 4 yýldýr borsa ile ilgileniyorum 3/5 kitap okumuslugum vardýr...tekniðe merakliyim....

MI 4W cihazýmdan hisse.net mobile app kullanarak gönderildi.

[ykazan]

THYAO vadeli görünüm ve fibolar.

sn cengiz kýrmýzý kalýn çizgi 11.50 ýse tepe 16 00 tl düsünülürse ao su 13.00 kusure gelýr dýye duzeltmemý beklenýr yoksa ust yený bantmý acýlýr yatay dýnlenýrde yolu varmý daha dýyemý yorumlamamýz gerekýr acýklayabýlýrmýsýnýz yorumunuz tsk ederým.

[cengizz]

corrected average 2.2 mq5


mt5 platformunu kullananlar için 5-10-15 dk.lýk zaman dilimlerinde iyi sonuç alýnabilecek bir trend indikatörü.










************************************************** *************************




//+------------------------------------------------------------------+
//| Corrected Average.mq5 |
//| Copyright 2012, Prof. A.Uhl, FinGeR alias Alexander Piechotta |
//| http://www.metatrader-wiki.com |
//+------------------------------------------------------------------+

//Update Version 2.2 August 2012
//Corrected Average(CA) by A.Uhl

//+------------------------------------------------------------------+
//| The strengths of the corrected Average(CA) is that the current |
//| value of the time series one of the current Volatility-dependent |
//| threshold must exceed that. so that the filter rises and falls, |
//| allowing false signals be avoided in trend is weak phase. |
//+------------------------------------------------------------------+

#property copyright "FinGeR alias Alexander Piechotta"
#property link "http://www.metatrader-wiki.com"
#property version "2.2"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots 1

//--- plot Corrected Average(CA)
#property indicator_label1 "Corrected Average (CA)"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrRed
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1

//--- input parameters
input int Periode =200; //Averaging Period
input ENUM_MA_METHOD Methode =MODE_SMA; //Smoothing Type
input ENUM_APPLIED_PRICE appliedPrice=PRICE_CLOSE; //Type of Price
input int Shift =0; //Shift of indicator

//--- indicator buffers
double CABuffer[];
double MABuffer[];
double StdDevBuffer[];

//--- handles
int MA_handle,StdDev_handle;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- indicator buffers mapping
SetIndexBuffer(0,CABuffer,INDICATOR_DATA);
IndicatorSetString(INDICATOR_SHORTNAME,"Corrected Average (CA) ("+DoubleToString(Periode,1)+")");

SetIndexBuffer(1,MABuffer,INDICATOR_CALCULATIONS);
SetIndexBuffer(2,StdDevBuffer,INDICATOR_CALCULATIO NS);

//--- sets first bar from what index will be drawn
PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,Periode);
PlotIndexSetInteger(0,PLOT_SHIFT,Shift);

//--- get MA handle
MA_handle=iMA(Symbol(),Period(),Periode,Shift,Meth ode,appliedPrice);
StdDev_handle=iStdDev(Symbol(),Period(),Periode,Sh ift,Methode,appliedPrice);

ArraySetAsSeries(MABuffer,true);
ArraySetAsSeries(CABuffer,true);
ArraySetAsSeries(StdDevBuffer,true);
//---
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const int begin,
const double &price[])
{

//--- check for data
if(rates_total<Periode)
return(0);

//--- not all data may be calculated
int calculated=BarsCalculated(MA_handle);
if(calculated<rates_total)
{
Print("Not all data of MA_handle is calculated (",calculated," bars ). Error",GetLastError());
return(0);
}

//--- not all data may be calculated
calculated=BarsCalculated(StdDev_handle);
if(calculated<rates_total)
{
Print("Not all data of StdDev_handle is calculated (",calculated," bars ). Error",GetLastError());
return(0);
}

//--- we can copy not all data
int to_copy;
if(prev_calculated>rates_total || prev_calculated<0) to_copy=rates_total;
else
{
to_copy=rates_total-prev_calculated;
if(prev_calculated>0) to_copy++;
}

//--- get MA buffer
if(IsStopped()) return(0); //Checking for stop flag
if(CopyBuffer(MA_handle,0,0,to_copy,MABuffer)<=0)
{
Print("Getting fast MA failed! Error",GetLastError());
return(0);
}

//--- get StdDev buffer
if(IsStopped()) return(0); //Checking for stop flag
if(CopyBuffer(StdDev_handle,0,0,to_copy,StdDevBuff er)<=0)
{
Print("Getting StdDev failed! Error",GetLastError());
return(0);
}

double v1,v2,k;

int counted=prev_calculated;
if(counted<0) return(-1);
if(counted>0) counted--;
int limit=Bars(Symbol(),Period())-counted;

//--- calculate
for(int i=limit-1; i>=0 && !IsStopped(); i--)
{
if(i==Bars(Symbol(),Period())-1)
{
CABuffer[i]=MABuffer[i];
continue;
}

v1=MathPow(StdDevBuffer[i],2);
v2=MathPow(CABuffer[i+1] - MABuffer[i],2);

//----
k=0;
if(v2<v1 || v2==0) k=0; else k=1-v1/v2;

CABuffer[i]=CABuffer[i+1]+k*(MABuffer[i]-CABuffer[i+1]);

}

//--- return value of prev_calculated for next call
return(rates_total);
}
//+------------------------------------------------------------------+

[cengizz]

Ons altýn grafiðinin saatlik zaman diliminde bu indikatör 100 period olarak güzel çalýþýr. Bilginize...

[cengizz]

Aþaðýda uluslararasý forex ve teknik analiz forumlarýnda kimsenin yüzüne bakmadýðý bir basit "super trend" indikatörü formülünü paylaþýyorum. Üzerinde iyileþtirmeler yapýp 2 ay izledim, sonuç fena deðil, para kazandýrýr.
mt5 de 12 saatlik zaman periyodunda iyi sonuç alabilirsiniz.

Bazý üstad geçinen insanlarn havasý international forumlarda sökmez, adamý pas-pas gibi çiðner ezer geçer, alay konusu yaparlar.
Senin üstadlýðýn burda bilmeyenlere söker.
Benim tecrübelerime göre sadece teknoloji kullanmayý ve ayarlarý bilen sýradan kiþiler bunlar.




************************************************** **************









super_trend_averages
18 ayrý ma eklenmiþ bir super trend indikatörü



************************************************** ************




//------------------------------------------------------------------
#property copyright "www.forex-tsd.com"
#property link "www.forex-tsd.com"
//------------------------------------------------------------------
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 1
#property indicator_label1 "Super trend hull"
#property indicator_type1 DRAW_COLOR_LINE
#property indicator_color1 clrYellow,clrMagenta
#property indicator_style1 STYLE_SOLID
#property indicator_width1 3

//
//
//
//
//

enum enPrices
{
pr_close, // Close
pr_open, // Open
pr_high, // High
pr_low, // Low
pr_median, // Median
pr_typical, // Typical
pr_weighted, // Weighted
pr_average // Average (high+low+oprn+close)/4
};
enum enumAveragesType
{
avgSma, // Simple moving average
avgEma, // Exponential moving average
avgDsema, // Double smoothed EMA
avgDema, // Double EMA
avgTema, // Tripple EMA
avgSmma, // Smoothed MA
avgLwma, // Linear weighted MA
avgPwma, // Parabolic weighted MA
avgAlex, // Alexander MA
avgVwma, // Volume weighted MA
avgHull, // Hull MA
avgTma, // Triangular MA
avgSine, // Sine weighted MA
avgLsma, // Linear regression value
avgIe2, // IE/2
avgNlma, // Non lag MA
avgZlma, // Zeo lag EMA
avgLead // Leader EMA
};

input int AvgPeriod = 2; // Averages period for 4 h
input enumAveragesType AvgMethod = avgNlma; // Averages method
input enPrices Price = pr_open; // Price
input int atrPeriod = 100; // ATR period
input double atrMultiplier = 1; // ATR multiplier

double st[];
double colorBuffer[];
int totalBars;

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

int OnInit()
{
SetIndexBuffer(0,st,INDICATOR_DATA);
SetIndexBuffer(1,colorBuffer,INDICATOR_COLOR_INDEX );
return(0);
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

double Up[];
double Dn[];
double Direction[];
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime& time[],
const double& open[],
const double& high[],
const double& low[],
const double& close[],
const long& tick_volume[],
const long& volume[],
const int& spread[])
{
totalBars=rates_total;
if (ArraySize(Direction)!=rates_total)
{
ArrayResize(Up,rates_total);
ArrayResize(Dn,rates_total);
ArrayResize(Direction,rates_total);
}

//
//
//
//
//

for (int i=(int)MathMax(prev_calculated-1,1); i<rates_total; i++)
{
double atr = 0;
for (int k=0;k<atrPeriod && (i-k-1)>=0; k++)
atr += MathMax(high[i-k],close[i-k-1])-MathMin(low[i-k],close[i-k-1]);
atr /= atrPeriod;

//
//
//
//
//

double cprice = close[i];
double mprice = iCustomMa(AvgMethod,getPrice(Price,open,close,high ,low,i,rates_total),AvgPeriod,tick_volume,i);
Up[i] = mprice+atrMultiplier*atr;
Dn[i] = mprice-atrMultiplier*atr;

//
//
//
//
//

colorBuffer[i] = colorBuffer[i-1];
Direction[i] = Direction[i-1];
if (cprice > Up[i-1]) Direction[i] = 1;
if (cprice < Dn[i-1]) Direction[i] = -1;
if (Direction[i] > 0)
{ Dn[i] = MathMax(Dn[i],Dn[i-1]); st[i] = Dn[i]; }
else { Up[i] = MathMin(Up[i],Up[i-1]); st[i] = Up[i]; }
if (Direction[i]== 1) colorBuffer[i] = 0;
if (Direction[i]==-1) colorBuffer[i] = 1;
}
return(rates_total);
}


//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

string methodNames[] = {"SMA","EMA","Double smoothed EMA","Double EMA","Tripple EMA","Smoothed MA","Linear weighted MA","Parabolic weighted MA","Alexander MA","Volume weghted MA","Hull MA","Triangular MA","Sine weighted MA","Linear regression","IE/2","NonLag MA","Zero lag EMA","Leader EMA"};
string getAverageName(int method)
{
int max = ArraySize(methodNames)-1;
method = (int)MathMax(MathMin(method,max),0); return(methodNames[method]);
}

//
//
//
//
//

#define _maWorkBufferx1 1
#define _maWorkBufferx2 2
#define _maWorkBufferx3 3

double iCustomMa(int mode, double price, double length, const long& Volume[], int r, int instanceNo=0)
{
switch (mode)
{
case avgSma : return(iSma(price,(int)length,r,instanceNo));
case avgEma : return(iEma(price,length,r,instanceNo));
case avgDsema : return(iDsema(price,length,r,instanceNo));
case avgDema : return(iDema(price,length,r,instanceNo));
case avgTema : return(iTema(price,length,r,instanceNo));
case avgSmma : return(iSmma(price,length,r,instanceNo));
case avgLwma : return(iLwma(price,length,r,instanceNo));
case avgPwma : return(iLwmp(price,length,r,instanceNo));
case avgAlex : return(iAlex(price,length,r,instanceNo));
case avgVwma : return(iWwma(price,length,Volume,r,instanceNo));
case avgHull : return(iHull(price,length,r,instanceNo));
case avgTma : return(iTma(price,length,r,instanceNo));
case avgSine : return(iSineWMA(price,(int)length,r,instanceNo));
case avgLsma : return(iLinr(price,length,r,instanceNo));
case avgIe2 : return(iIe2(price,length,r,instanceNo));
case avgNlma : return(iNonLagMa(price,length,r,instanceNo));
case avgZlma : return(iZeroLag(price,length,r,instanceNo));
case avgLead : return(iLeader(price,length,r,instanceNo));
default : return(price);
}
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

double workSma[][_maWorkBufferx2];
double iSma(double price, int period, int r, int instanceNo=0)
{
if (ArrayRange(workSma,0)!= totalBars) ArrayResize(workSma,totalBars); instanceNo *= 2;

//
//
//
//
//

int k;
workSma[r][instanceNo] = price;
if (r>=period)
workSma[r][instanceNo+1] = workSma[r-1][instanceNo+1]+(workSma[r][instanceNo]-workSma[r-period][instanceNo])/period;
else { workSma[r][instanceNo+1] = 0; for(k=0; k<period && (r-k)>=0; k++) workSma[r][instanceNo+1] += workSma[r-k][instanceNo];
workSma[r][instanceNo+1] /= k; }
return(workSma[r][instanceNo+1]);
}

//
//
//
//
//

double workEma[][_maWorkBufferx1];
double iEma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workEma,0)!= totalBars) ArrayResize(workEma,totalBars);

//
//
//
//
//

double alpha = 2.0 / (1.0+period);
workEma[r][instanceNo] = workEma[r-1][instanceNo]+alpha*(price-workEma[r-1][instanceNo]);
return(workEma[r][instanceNo]);
}

//
//
//
//
//

double workDsema[][_maWorkBufferx2];
#define _ema1 0
#define _ema2 1
double iDsema(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workDsema,0)!= totalBars) ArrayResize(workDsema,totalBars); instanceNo*=2;

//
//
//
//
//

double alpha = 2.0 /(1.0+MathSqrt(period));
workDsema[r][_ema1+instanceNo] = workDsema[r-1][_ema1+instanceNo]+alpha*(price -workDsema[r-1][_ema1+instanceNo]);
workDsema[r][_ema2+instanceNo] = workDsema[r-1][_ema2+instanceNo]+alpha*(workDsema[r][_ema1+instanceNo]-workDsema[r-1][_ema2+instanceNo]);
return(workDsema[r][_ema2+instanceNo]);
}

//
//
//
//
//

double workDema[][_maWorkBufferx2];
double iDema(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workDema,0)!= totalBars) ArrayResize(workDema,totalBars); instanceNo*=2;

//
//
//
//
//

double alpha = 2.0 / (1.0+period);
workDema[r][_ema1+instanceNo] = workDema[r-1][_ema1+instanceNo]+alpha*(price -workDema[r-1][_ema1+instanceNo]);
workDema[r][_ema2+instanceNo] = workDema[r-1][_ema2+instanceNo]+alpha*(workDema[r][_ema1+instanceNo]-workDema[r-1][_ema2+instanceNo]);
return(workDema[r][_ema1+instanceNo]*2.0-workDema[r][_ema2+instanceNo]);
}

//
//
//
//
//

double workTema[][_maWorkBufferx3];
#define _ema3 2
double iTema(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workTema,0)!= totalBars) ArrayResize(workTema,totalBars); instanceNo*=3;

//
//
//
//
//

double alpha = 2.0 / (1.0+period);
workTema[r][_ema1+instanceNo] = workTema[r-1][_ema1+instanceNo]+alpha*(price -workTema[r-1][_ema1+instanceNo]);
workTema[r][_ema2+instanceNo] = workTema[r-1][_ema2+instanceNo]+alpha*(workTema[r][_ema1+instanceNo]-workTema[r-1][_ema2+instanceNo]);
workTema[r][_ema3+instanceNo] = workTema[r-1][_ema3+instanceNo]+alpha*(workTema[r][_ema2+instanceNo]-workTema[r-1][_ema3+instanceNo]);
return(workTema[r][_ema3+instanceNo]+3.0*(workTema[r][_ema1+instanceNo]-workTema[r][_ema2+instanceNo]));
}

//
//
//
//
//

double workSmma[][_maWorkBufferx1];
double iSmma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workSmma,0)!= totalBars) ArrayResize(workSmma,totalBars);

//
//
//
//
//

if (r<period)
workSmma[r][instanceNo] = price;
else workSmma[r][instanceNo] = workSmma[r-1][instanceNo]+(price-workSmma[r-1][instanceNo])/period;
return(workSmma[r][instanceNo]);
}

//
//
//
//
//

double workLwma[][_maWorkBufferx1];
double iLwma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workLwma,0)!= totalBars) ArrayResize(workLwma,totalBars);

//
//
//
//
//

workLwma[r][instanceNo] = price;
double sumw = period;
double sum = period*price;

for(int k=1; k<period && (r-k)>=0; k++)
{
double weight = period-k;
sumw += weight;
sum += weight*workLwma[r-k][instanceNo];
}
return(sum/sumw);
}

//
//
//
//
//

double workLwmp[][_maWorkBufferx1];
double iLwmp(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workLwmp,0)!= totalBars) ArrayResize(workLwmp,totalBars);

//
//
//
//
//

workLwmp[r][instanceNo] = price;
double sumw = period*period;
double sum = sumw*price;

for(int k=1; k<period && (r-k)>=0; k++)
{
double weight = (period-k)*(period-k);
sumw += weight;
sum += weight*workLwmp[r-k][instanceNo];
}
return(sum/sumw);
}

//
//
//
//
//

double workAlex[][_maWorkBufferx1];
double iAlex(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workAlex,0)!= totalBars) ArrayResize(workAlex,totalBars);
if (period<4) return(price);

//
//
//
//
//

workAlex[r][instanceNo] = price;
double sumw = period-2;
double sum = sumw*price;

for(int k=1; k<period && (r-k)>=0; k++)
{
double weight = period-k-2;
sumw += weight;
sum += weight*workAlex[r-k][instanceNo];
}
return(sum/sumw);
}

//
//
//
//
//

double workTma[][_maWorkBufferx1];
double iTma(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workTma,0)!= totalBars) ArrayResize(workTma,totalBars);

//
//
//
//
//

workTma[r][instanceNo] = price;

double half = (period+1.0)/2.0;
double sum = price;
double sumw = 1;

for(int k=1; k<period && (r-k)>=0; k++)
{
double weight = k+1; if (weight > half) weight = period-k;
sumw += weight;
sum += weight*workTma[r-k][instanceNo];
}
return(sum/sumw);
}

//
//
//
//
//

double workSineWMA[][_maWorkBufferx1];
#define Pi 3.14159265358979323846264338327950288
double iSineWMA(double price, int period, int r, int instanceNo=0)
{
if (period<1) return(price);
if (ArrayRange(workSineWMA,0)!= totalBars) ArrayResize(workSineWMA,totalBars);

//
//
//
//
//

workSineWMA[r][instanceNo] = price;
double sum = 0;
double sumw = 0;

for(int k=0; k<period && (r-k)>=0; k++)
{
double weight = MathSin(Pi*(k+1.0)/(period+1.0));
sumw += weight;
sum += weight*workSineWMA[r-k][instanceNo];
}
return(sum/sumw);
}

//
//
//
//
//

double workWwma[][_maWorkBufferx1];
double iWwma(double price, double period,const long& Volume[], int r, int instanceNo=0)
{
if (ArrayRange(workWwma,0)!= totalBars) ArrayResize(workWwma,totalBars);

//
//
//
//
//

workWwma[r][instanceNo] = price;
double sumw = (double)Volume[r];
double sum = sumw*price;

for(int k=1; k<period && (r-k)>=0; k++)
{
double weight = (double)Volume[r-k];
sumw += weight;
sum += weight*workWwma[r-k][instanceNo];
}
return(sum/sumw);
}

//
//
//
//
//

double workHull[][_maWorkBufferx2];
double iHull(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workHull,0)!= totalBars) ArrayResize(workHull,totalBars);

//
//
//
//
//

int k;
int HmaPeriod = (int)MathMax(period,2);
int HalfPeriod = (int)MathFloor(HmaPeriod/2);
int HullPeriod = (int)MathFloor(MathSqrt(HmaPeriod));
double hma,hmw,weight; instanceNo *= 2;

workHull[r][instanceNo] = price;

//
//
//
//
//

hmw = HalfPeriod; hma = hmw*price;
for(k=1; k<HalfPeriod && (r-k)>=0; k++)
{
weight = HalfPeriod-k;
hmw += weight;
hma += weight*workHull[r-k][instanceNo];
}
workHull[r][instanceNo+1] = 2.0*hma/hmw;

hmw = HmaPeriod; hma = hmw*price;
for(k=1; k<period && (r-k)>=0; k++)
{
weight = HmaPeriod-k;
hmw += weight;
hma += weight*workHull[r-k][instanceNo];
}
workHull[r][instanceNo+1] -= hma/hmw;

//
//
//
//
//

hmw = HullPeriod; hma = hmw*workHull[r][instanceNo+1];
for(k=1; k<HullPeriod && (r-k)>=0; k++)
{
weight = HullPeriod-k;
hmw += weight;
hma += weight*workHull[r-k][1+instanceNo];
}
return(hma/hmw);
}

//
//
//
//
//

double workLinr[][_maWorkBufferx1];
double iLinr(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workLinr,0)!= totalBars) ArrayResize(workLinr,totalBars);

//
//
//
//
//

period = MathMax(period,1);
workLinr[r][instanceNo] = price;
double lwmw = period; double lwma = lwmw*price;
double sma = price;
for(int k=1; k<period && (r-k)>=0; k++)
{
double weight = period-k;
lwmw += weight;
lwma += weight*workLinr[r-k][instanceNo];
sma += workLinr[r-k][instanceNo];
}

return(3.0*lwma/lwmw-2.0*sma/period);
}

//
//
//
//
//

double workIe2[][_maWorkBufferx1];
double iIe2(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workIe2,0)!= totalBars) ArrayResize(workIe2,totalBars);

//
//
//
//
//

period = MathMax(period,1);
workIe2[r][instanceNo] = price;
double sumx=0, sumxx=0, sumxy=0, sumy=0;
for (int k=0; k<period && (r-k)>=0; k++)
{
price = workIe2[r-k][instanceNo];
sumx += k;
sumxx += k*k;
sumxy += k*price;
sumy += price;
}
double slope = (period*sumxy - sumx*sumy)/(sumx*sumx-period*sumxx);
double average = sumy/period;
return(((average+slope)+(sumy+slope*sumx)/period)/2.0);
}

//
//
//
//
//

double workLeader[][_maWorkBufferx2];
double iLeader(double price, double period, int r, int instanceNo=0)
{
if (ArrayRange(workLeader,0)!= totalBars) ArrayResize(workLeader,totalBars); instanceNo*=2;

//
//
//
//
//

period = MathMax(period,1);
double alpha = 2.0/(period+1.0);
workLeader[r][instanceNo ] = workLeader[r-1][instanceNo ]+alpha*(price -workLeader[r-1][instanceNo ]);
workLeader[r][instanceNo+1] = workLeader[r-1][instanceNo+1]+alpha*(price-workLeader[r][instanceNo]-workLeader[r-1][instanceNo+1]);

return(workLeader[r][instanceNo]+workLeader[r][instanceNo+1]);
}

//
//
//
//
//

double workZl[][_maWorkBufferx2];
#define _price 0
#define _zlema 1

double iZeroLag(double price, double length, int r, int instanceNo=0)
{
if (ArrayRange(workZl,0)!=totalBars) ArrayResize(workZl,totalBars); instanceNo *= 2;

//
//
//
//
//

double alpha = 2.0/(1.0+length);
int per = (int)((length-1.0)/2.0);

workZl[r][_price+instanceNo] = price;
if (r<per)
workZl[r][_zlema+instanceNo] = price;
else workZl[r][_zlema+instanceNo] = workZl[r-1][_zlema+instanceNo]+alpha*(2.0*price-workZl[r-per][_price+instanceNo]-workZl[r-1][_zlema+instanceNo]);
return(workZl[r][_zlema+instanceNo]);
}

//
//
//
//
//

#define _length 0
#define _len 1
#define _weight 2

double nlm_values[3][_maWorkBufferx1];
double nlm_prices[ ][_maWorkBufferx1];
double nlm_alphas[ ][_maWorkBufferx1];

//
//
//
//
//

double iNonLagMa(double price, double length, int r, int instanceNo=0)
{
if (ArrayRange(nlm_prices,0) != totalBars) ArrayResize(nlm_prices,totalBars);
nlm_prices[r][instanceNo]=price;
if (length<3 || r<3) return(nlm_prices[r][instanceNo]);

//
//
//
//
//

int k;
if (nlm_values[_length][instanceNo] != length)
{
double Cycle = 4.0;
double Coeff = 3.0*Pi;
int Phase = (int)(length-1);

nlm_values[_length][instanceNo] = length;
nlm_values[_len ][instanceNo] = length*4 + Phase;
nlm_values[_weight][instanceNo] = 0;

if (ArrayRange(nlm_alphas,0) < nlm_values[_len][instanceNo]) ArrayResize(nlm_alphas,(int)nlm_values[_len][instanceNo]);
for (k=0; k<nlm_values[_len][instanceNo]; k++)
{
double t;
if (k<=Phase-1)
t = 1.0 * k/(Phase-1);
else t = 1.0 + (k-Phase+1)*(2.0*Cycle-1.0)/(Cycle*length-1.0);
double beta = MathCos(Pi*t);
double g = 1.0/(Coeff*t+1); if (t <= 0.5 ) g = 1;

nlm_alphas[k][instanceNo] = g * beta;
nlm_values[_weight][instanceNo] += nlm_alphas[k][instanceNo];
}
}

//
//
//
//
//

if (nlm_values[_weight][instanceNo]>0)
{
double sum = 0;
for (k=0; k < nlm_values[_len][instanceNo] && (r-k)>=0; k++) sum += nlm_alphas[k][instanceNo]*nlm_prices[r-k][instanceNo];
return( sum / nlm_values[_weight][instanceNo]);
}
else return(0);
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

double getPrice(enPrices price, const double& open[], const double& close[], const double& high[], const double& low[], int i, int bars)
{
switch (price)
{
case pr_close: return(close[i]);
case pr_open: return(open[i]);
case pr_high: return(high[i]);
case pr_low: return(low[i]);
case pr_median: return((high[i]+low[i])/2.0);
case pr_typical: return((high[i]+low[i]+close[i])/3.0);
case pr_weighted: return((high[i]+low[i]+close[i]+close[i])/4.0);
case pr_average: return((high[i]+low[i]+close[i]+open[i])/4.0);
}
return(0);
}

[cengizz]

55-60 yaþýna gelmiþ ve hala 2 tane mav'ý doðru dürüst kesiþtirip ÝSTÝKRARLI VE HATASIZLIK PAYI YÜKSEK sinyal üretemeyen sözde üstad geçinen o densizlerin veya her kim olursa olsun hala günümüze kadar kayda deðer bir indikatör bile yapamamýþ kiþinin benim teknik analistliðimi sorgulamaya hakký yoktur. Sen otur önce istikrarlý bir gösterge yarat, daha doðrusu önce önündeki ..ku ye!!!

Bu densizler bu sayfada tek kelime "slm" bile yazsa çok aðýr hakarete maruz kalabilir, þimdiden uyarayým. Sonra mýzýkçýlýk istemem.