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.