//MQL5 Version August 17, 2011 Final //+X================================================================X+ //| SmoothAlgorithms.mqh | //| Copyright © 2012, Nikolay Kositsin | //| Khabarovsk, farria@mail.redcom.ru | //+X================================================================X+ #property copyright "2012, Nikolay Kositsin" #property link "farria@mail.redcom.ru" #property version "3.10" //+X================================================================X+ //| Classes for averaging of prices series | //+X================================================================X+ //+X================================================================X+ //| Functional utilities for the classes of averaging algorithms | //+X================================================================X+ class CMovSeriesTools { public: void MALengthCheck(string LengthName,int ExternLength); void MALengthCheck(string LengthName,double ExternLength); protected: bool BarCheck1(int begin,int bar,bool Set); bool BarCheck2(int begin,int bar,bool Set,int Length); bool BarCheck3(int begin,int bar,bool Set,int Length); bool BarCheck4(int rates_total,int bar,bool Set); bool BarCheck5(int rates_total,int bar,bool Set); bool BarCheck6(int rates_total,int bar,bool Set); void LengthCheck(int &ExternLength); void LengthCheck(double &ExternLength); void Recount_ArrayZeroPos( int &count, int Length, uint prev_calculated, uint rates_total, double series, int bar, double &Array[], bool set ); int Recount_ArrayNumber(int count,int Length,int Number); bool SeriesArrayResize(string FunctionsName, int Length, double &Array[], int &Size_ ); bool ArrayResizeErrorPrint(string FunctionsName,int &Size_); }; //+X================================================================X+ //| The functions for the classic smoothing of price series | //+X================================================================X+ class CMoving_Average : public CMovSeriesTools { public: double MASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period ENUM_MA_METHOD MA_Method,// method of averaging (MODE_SMA, MODE_EMA, MODE_SMMA, MODE_LWMA) double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); double SMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); double EMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick double Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); double SMMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); double LWMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: double m_SeriesArray[]; int m_Size_,m_count,m_weight; double m_Moving,m_MOVING,m_Pr; double m_sum,m_SUM,m_lsum,m_LSUM; }; //+X================================================================X+ //| The algorithm for computing standard deviation | //+X================================================================X+ class CStdDeviation : public CMovSeriesTools { public: double StdDevSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double deviation,// Deviation double series,// Price series value calculated for the bar with number 'bar' double MovSeries,// Moving average value based on which the StdDeviation is calculated uint bar,// Bar index bool set // direction of indexing arrays ); protected: int m_Size_,m_count; double m_Sum,m_SUM,m_Sum2,m_SUM2; double m_SeriesArray[]; }; //+X================================================================X+ //| JMA averaging algorithm for arbitrary price series | //+X================================================================X+ class CJJMA : public CMovSeriesTools { public: double JJMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Din,// permission to change the Length and Phase parameters at every bar. // 0 locks out changes to parameters, any other value allows changes to parameters. double Phase,// parameter varying within the range -100 ... +100 and influencing the quality of the intermediate averaging process double Length,// smoothing depth double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); void JJMALengthCheck(string LengthName,int ExternLength); void JJMAPhaseCheck(string PhaseName,int ExternPhase); protected: void JJMAInit(uint begin,int Din,double Phase,double Length,double series,uint bar); //----+ Declaration of global variables bool m_start; //---- double m_array[62]; //---- double m_degree,m_Phase,m_sense; double m_Krx,m_Kfd,m_Krj,m_Kct; double m_var1,m_var2; //---- int m_pos2,m_pos1; int m_Loop1,m_Loop2; int m_midd1,m_midd2; int m_count1,m_count2,m_count3; //---- double m_ser1,m_ser2; double m_Sum1,m_Sum2,m_JMA; double m_storage1,m_storage2,m_djma; double m_hoop1[128],m_hoop2[11],m_data[128]; //----+ Variables for restoring calculations of an unclosed bar int m_pos2_,m_pos1_; int m_Loop1_,m_Loop2_; int m_midd1_,m_midd2_; int m_count1_,m_count2_,m_count3_; //---- double m_ser1_,m_ser2_; double m_Sum1_,m_Sum2_,m_JMA_; double m_storage1_,m_storage2_,m_djma_; double m_hoop1_[128],m_hoop2_[11],m_data_[128]; //---- bool m_bhoop1[128],m_bhoop2[11],m_bdata[128]; }; //+X================================================================X+ //| The Tilson's algorithm of smoothing any price series | //+X================================================================X+ class CT3 : public CMovSeriesTools { public: double T3Series(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Din,// permission to change the Length parameter at every bar. // 0 locks out changes to parameters, any other value allows changes to parameters. double Curvature,// Coefficient (for convenience, its value is centuplicated!) double Length,// smoothing depth double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: void T3Init(uint begin, int Din, double Curvature, double Length, double series, uint bar ); //----+ Declaration of global variables double m_b2,m_b3; //---- double m_e1,m_e2,m_e3,m_e4,m_e5,m_e6; double m_E1,m_E2,m_E3,m_E4,m_E5,m_E6; double m_c1,m_c2,m_c3,m_c4,m_w1,m_w2; }; //+X================================================================X+ //| The algorithm of the ultralinear price series smoothing | //+X================================================================X+ class CJurX : public CMovSeriesTools { public: double JurXSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Din,// permission to change the Length parameter at every bar. // 0 locks out changes to parameters, any other value allows changes to parameters. double Length,// smoothing depth double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: void JurXInit(uint begin, int Din, double Length, double series, uint bar ); //----+ Declaration of global variables double m_AB,m_AC; double m_f1,m_f2,m_f3,m_f4,m_f5; double m_f6,m_Kg,m_Hg,m_F1,m_F2; double m_F3,m_F4,m_F5,m_F6,m_w; }; //+X================================================================X+ //| Tushar Chande's averaging algorithms for arbitrary price series | //+X================================================================X+ class CCMO : public CMovSeriesTools { public: double VIDYASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int CMO_Length,// CMO period double EMA_Length, double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); double CMOSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int CMO_Length,// CMO period double series, uint bar,// Bar index bool set // direction of indexing arrays ); protected: double m_dSeriesArray[]; int m_Size_,m_count; double m_UpSum_,m_UpSum,m_DnSum_,m_DnSum,m_Vidya,m_Vidya_; double m_AbsCMO_,m_AbsCMO,m_series1,m_series1_,m_SmoothFactor; }; //+X================================================================X+ //| The algorithm of getting the AMA indicator calculated on the | //| basis of any price series | //+X================================================================X+ class CAMA : public CMovSeriesTools { public: double AMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// AMA period int Fast_Length, // period of fast moving average int Slow_Length, // slow moving average period double Rate,// the power to which the smoothing constant is raised double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: //----+ double m_SeriesArray[]; double m_dSeriesArray[]; double m_NOISE,m_noise; double m_Ama,m_AMA_,m_slowSC,m_fastSC,m_dSC; int m_Size_1,m_Size_2,m_count; }; //+X================================================================X+ //| The algorithm for parabolic averaging of arbitrary price series | //+X================================================================X+ class CParMA : public CMovSeriesTools { public: double ParMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: void ParMAInit(double Length); double m_SeriesArray[]; int m_Size_,m_count; int m_sum_x,m_sum_x2,m_sum_x3,m_sum_x4; }; //+X================================================================X+ //| The momentum algorithm (Murphy's version!) from any price series | //+X================================================================X+ class CMomentum : public CMovSeriesTools { public: double MomentumSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: double m_SeriesArray[]; int m_Size_,m_count; }; //+X================================================================X+ //| The algorithm of normalized momentum calculated on price series | //+X================================================================X+ class CnMomentum : public CMovSeriesTools { public: double nMomentumSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: double m_SeriesArray[]; int m_Size_,m_count; }; //+X================================================================X+ //| The Speed of changing algorithm based on arbitrary price series | //+X================================================================X+ class CROC : public CMovSeriesTools { public: double ROCSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); protected: double m_SeriesArray[]; int m_Size_,m_count; }; //+X================================================================X+ //| The functions for price series smoothing using the FATL digital | //| filter | //+X================================================================X+ class CFATL : public CMovSeriesTools { public: double FATLSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); CFATL(); protected: double m_SeriesArray[39]; int m_Size_,m_count; double m_FATL; //---- declaration and initialization of an array for the coefficient of the digital filter double m_FATLTable[39]; }; //+X================================================================X+ //| Functions for averaging price series using the SATL digital | //| filter | //+X================================================================X+ class CSATL : public CMovSeriesTools { public: double SATLSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); CSATL(); protected: double m_SeriesArray[65]; int m_Size_,m_count; double m_SATL; //---- declaration and initialization of an array for the coefficient of the digital filter double m_SATLTable[65]; }; //+X================================================================X+ //| The functions for averaging price series using the RFTL digital | //| filter | //+X================================================================X+ class CRFTL : public CMovSeriesTools { public: double RFTLSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); CRFTL(); protected: double m_SeriesArray[44]; int m_Size_,m_count; double m_RFTL; //---- declaration and initialization of an array for the coefficient of the digital filter double m_RFTLTable[44]; }; //+X================================================================X+ //| The functions for averaging price series using the RSTL digital | //| filter | //+X================================================================X+ class CRSTL : public CMovSeriesTools { public: double RSTLSeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); CRSTL(); protected: double m_SeriesArray[99]; int m_Size_,m_count; double m_RSTL; //---- declaration and initialization of an array for the coefficient of the digital filter double m_RSTLTable[99]; }; //+X================================================================X+ //| Universal averaging algorithm | //+X================================================================X+ class CXMA { public: enum Smooth_Method { MODE_SMA_, //SMA MODE_EMA_, //EMA MODE_SMMA_, //SMMA MODE_LWMA_, //LWMA MODE_JJMA, //JJMA MODE_JurX, //JurX MODE_ParMA, //ParMA MODE_T3, //T3 MODE_VIDYA, //VIDYA MODE_AMA //AMA }; double XMASeries(uint begin,// the reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick // 0 locks out changes to parameters, any other value allows changes to parameters. Smooth_Method Method, int Phase,// parameter varying within the range -100 ... +100 //and influencing the quality of the intermediate averaging process int Length,// smoothing depth double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ); int GetStartBars(Smooth_Method Method,int Length,int Phase); string GetString_MA_Method(Smooth_Method Method); void XMAPhaseCheck(string PhaseName,int ExternPhase,Smooth_Method Method); void XMALengthCheck(string LengthName,int ExternLength); void XMAInit(Smooth_Method Method); CXMA(){m_init=false;}; ~CXMA(); protected: CMoving_Average *SMA; CMoving_Average *EMA; CMoving_Average *SMMA; CMoving_Average *LWMA; CJJMA *JJMA; CJurX *JurX; CParMA *ParMA; CT3 *T3; CCMO *VIDYA; CAMA *AMA; bool m_init; Smooth_Method m_Method; }; //Version May 1, 2010 //+X================================================================X+ //| iPriceSeries.mqh | //| Copyright © 2010, Nikolay Kositsin | //| Khabarovsk, farria@mail.redcom.ru | //+X================================================================X+ /* * The iPriceSeries() function returns the input price of a bar by its index * bar and by the number of the price 'applied_price': * 1-CLOSE, 2-OPEN, 3-HIGH, 4-LOW, 5-MEDIAN, 6-TYPICAL, 7-WEIGHTED, * 8-SIMPL, 9-QUARTER, 10-TRENDFOLLOW, 11-0.5 * TRENDFOLLOW, 12-Demark Price. * * Example: * double dPrice = iPriceSeries("GBPJPY", 240, 5, bar, true) * - iPriceSeries("GBPJPY", 240, 5, bar + 1, true); */ //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ /* //---- declaring and initializing the enumeration of the types of price constants enum Applied_price_ //Type od constant { PRICE_CLOSE_ = 1, //Close PRICE_OPEN_, //Open PRICE_HIGH_, //High PRICE_LOW_, //Low PRICE_MEDIAN_, //Median Price (HL/2) PRICE_TYPICAL_, //Typical Price (HLC/3) PRICE_WEIGHTED_, //Weighted Close (HLCC/4) PRICE_SIMPL_, //Simpl Price (OC/2) PRICE_QUARTER_, //Quarted Price (HLOC/4) PRICE_TRENDFOLLOW0_, //TrendFollow_1 Price PRICE_TRENDFOLLOW1_, //TrendFollow_2 Price PRICE_DEMARK_ //Demark Price }; */ //+X================================================================X+ //| PriceSeries() function | //+X================================================================X+ double PriceSeries ( uint applied_price,// Price constant uint bar,// Shift index relative to the current bar by a specified number of periods backward or forward). const double &Open[], const double &Low[], const double &High[], const double &Close[] ) //PriceSeries(applied_price, bar, open, low, high, close) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ switch(applied_price) { //----+ Price constants from the enumeration ENUM_APPLIED_PRICE case PRICE_CLOSE: return(Close[bar]); case PRICE_OPEN: return(Open [bar]); case PRICE_HIGH: return(High [bar]); case PRICE_LOW: return(Low[bar]); case PRICE_MEDIAN: return((High[bar]+Low[bar])/2.0); case PRICE_TYPICAL: return((Close[bar]+High[bar]+Low[bar])/3.0); case PRICE_WEIGHTED: return((2*Close[bar]+High[bar]+Low[bar])/4.0); //----+ case 8: return((Open[bar] + Close[bar])/2.0); case 9: return((Open[bar] + Close[bar] + High[bar] + Low[bar])/4.0); //---- case 10: { if(Close[bar]>Open[bar])return(High[bar]); else { if(Close[bar]Open[bar])return((High[bar]+Close[bar])/2.0); else { if(Close[bar]Open[bar]) res=(res+High[bar])/2; if(Close[bar]==Open[bar]) res=(res+Close[bar])/2; return(((res-Low[bar])+(res-High[bar]))/2); break; } //---- default: return(Close[bar]); } //----+ //return(0); } //+X================================================================X+ //| iPriceSeries() function | //+X================================================================X+ double iPriceSeries ( string symbol,// Symbol name. NULL means current symbol. ENUM_TIMEFRAMES timeframe,// Period. Can be one of the chart periods. 0 means the current chart period. uint applied_price,// Price constant uint bar,// Shift index relative to the current bar by a specified number of periods backward or forward). bool set // Array indexing direction. ) //iPriceSeries(symbol, timeframe, applied_price, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ uint Bar; double diPriceSeries,price[1]; //---- if(!set) Bar=Bars(symbol,timeframe)-1-bar; else Bar=bar; //---- switch(applied_price) { case 1: CopyClose(symbol, timeframe, Bar, 1, price); diPriceSeries = price[0]; break; case 2: CopyOpen (symbol, timeframe, Bar, 1, price); diPriceSeries = price[0]; break; case 3: CopyHigh (symbol, timeframe, Bar, 1, price); diPriceSeries = price[0]; break; case 4: CopyLow (symbol, timeframe, Bar, 1, price); diPriceSeries = price[0]; break; //---- case 5: CopyHigh(symbol,timeframe,Bar,1,price); diPriceSeries=price[0]; CopyLow(symbol,timeframe,Bar,1,price); diPriceSeries+=price[0]; diPriceSeries/=2.0; break; //---- case 6: CopyClose(symbol,timeframe,Bar,1,price); diPriceSeries=price[0]; CopyHigh (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; CopyLow (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; diPriceSeries/=3.0; break; //---- case 7: CopyClose(symbol,timeframe,Bar,1,price); diPriceSeries=price[0]*2; CopyHigh (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; CopyLow (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; diPriceSeries/=4.0; break; //---- case 8: CopyClose(symbol,timeframe,Bar,1,price); diPriceSeries=price[0]; CopyOpen(symbol,timeframe,Bar,1,price); diPriceSeries+=price[0]; diPriceSeries/=2.0; break; //---- case 9: CopyClose(symbol,timeframe,Bar,1,price); diPriceSeries=price[0]; CopyOpen (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; CopyHigh (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; CopyLow (symbol, timeframe, Bar, 1, price); diPriceSeries += price[0]; diPriceSeries/=4.0; break; //---- case 10: { double Open_[1],Low_[1],High_[1],Close_[1]; //---- CopyClose(symbol,timeframe,Bar,1,Close_); CopyOpen(symbol,timeframe,Bar,1,Open_); CopyHigh(symbol,timeframe,Bar,1,High_); CopyLow(symbol,timeframe,Bar,1,Low_); //---- if(Close_[0]>Open_[0])diPriceSeries=High_[0]; else { if(Close_[0]Open_[0])diPriceSeries=(High_[0]+Close_[0])/2.0; else { if(Close_[0]Open_[0]) res=(res+High_[0])/2; if(Close_[0]==Open_[0]) res=(res+Close_[0])/2; diPriceSeries=((res-Low_[0])+(res-High_[0]))/2; break; } //---- default: CopyClose(symbol,timeframe,Bar,1,price); diPriceSeries=price[0]; break; } //----+ return(diPriceSeries); } //+X================================================================X+ //| bPriceSeries() function | //+X================================================================X+ bool bPriceSeries ( string symbol,// Symbol name. NULL means current symbol. ENUM_TIMEFRAMES timeframe,// Period. Can be one of the chart periods. 0 means the current chart period. int rates_total,// history in bars at the current tick (if the 'set' parameter is set to true, // then value of the parameter is not needed in the function calculation and can be equal to 0) uint applied_price,// Price constant uint bar, // Shift index relative to the current bar by a specified number of periods backward or forward). bool set, // Direction of indexing arrays. double &Price_ // returns the obtained value by reference ) //bPriceSeries(symbol, timeframe, int rates_total, applied_price, bar, set, Price_) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ uint Bar; double series[1]; ArraySetAsSeries(series,true); //---- if(!set) Bar=rates_total-1-bar; else Bar=bar; //---- switch(applied_price) { case 1: if(CopyClose(symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ = series[0]; break; case 2: if(CopyOpen (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ = series[0]; break; case 3: if(CopyHigh (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ = series[0]; break; case 4: if(CopyLow (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ = series[0]; break; //---- case 5: if(CopyHigh(symbol,timeframe,Bar,1,series)<0) return(false); Price_=series[0]; if(CopyLow(symbol,timeframe,Bar,1,series)<0) return(false); Price_+=series[0]; Price_/=2.0; break; //---- case 6: if(CopyClose(symbol,timeframe,Bar,1,series)<0) return(false); Price_=series[0]; if(CopyHigh (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; if(CopyLow (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; Price_/=3.0; break; //---- case 7: if(CopyClose(symbol,timeframe,Bar,1,series)<0) return(false); Price_=series[0]*2; if(CopyHigh (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; if(CopyLow (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; Price_/=4.0; break; //---- case 8: if(CopyClose(symbol,timeframe,Bar,1,series)<0) return(false); Price_=series[0]; if(CopyOpen(symbol,timeframe,Bar,1,series)<0) return(false); Price_+=series[0]; Price_/=2.0; break; //---- case 9: if(CopyClose(symbol,timeframe,Bar,1,series)<0) return(false); Price_=series[0]; if(CopyOpen (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; if(CopyHigh (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; if(CopyLow (symbol, timeframe, Bar, 1, series) < 0) return(false); Price_ += series[0]; Price_/=4.0; break; //---- case 10: { double Open_[1],Low_[1],High_[1],Close_[1]; //---- if(CopyClose(symbol, timeframe, Bar, 1, Close_) < 0) return(false); if(CopyOpen (symbol, timeframe, Bar, 1, Open_ ) < 0) return(false); if(CopyHigh (symbol, timeframe, Bar, 1, High_ ) < 0) return(false); if(CopyLow (symbol, timeframe, Bar, 1, Low_ ) < 0) return(false); //---- if(Close_[0]>Open_[0])Price_=High_[0]; else { if(Close_[0]Open_[0])Price_=(High_[0]+Close_[0])/2.0; else { if(Close_[0]Open_[0]) res=(res+High_[0])/2; if(Close_[0]==Open_[0]) res=(res+Close_[0])/2; Price_=((res-Low_[0])+(res-High_[0]))/2; break; } //---- default: if(CopyClose(symbol,timeframe,Bar,1,series)<0) return(false); Price_=series[0]; break; } //----+ return(true); } //+X================================================================X+ //| bPriceSeriesOnArray() function | //+X================================================================X+ bool bPriceSeriesOnArray ( string symbol,// Symbol name. NULL means current symbol. ENUM_TIMEFRAMES timeframe,// Period. Can be one of the chart periods. 0 means the current chart period. uint applied_price,// Price constant int start_pos,// First copied element number int count,// Number of copied elements double &series[]// the array to which the data will be copied ) //bPriceSeriesOnArray(symbol, timeframe, applied_price, start_pos, count, Array) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ ArraySetAsSeries(series,true); switch(applied_price) { case 1: if(CopyClose(symbol, timeframe, start_pos, count, series) < 0) return(false); break; case 2: if(CopyOpen (symbol, timeframe, start_pos, count, series) < 0) return(false); break; case 3: if(CopyHigh (symbol, timeframe, start_pos, count, series) < 0) return(false); break; case 4: if(CopyLow (symbol, timeframe, start_pos, count, series) < 0) return(false); break; //---- case 5: { double Low_[]; ArraySetAsSeries(Low_,true); if(CopyHigh(symbol, timeframe, start_pos, count, series) < 0) return(false); if(CopyLow (symbol, timeframe, start_pos, count, Low_ ) < 0) return(false); for(int kkk=start_pos; kkkOpen_[kkk]) series[kkk]=High_[kkk]; else { if(series[kkk]Open_[kkk]) series[kkk]=(High_[kkk]+series[kkk])/2.0; else { if(series[kkk]Open_[kkk]) res=(res+High_[kkk])/2; if(series[kkk]==Open_[kkk]) res=(res+series[kkk])/2; series[kkk]=((res-Low_[kkk])+(res-High_[kkk]))/2; } break; } //---- default: if(CopyClose(symbol,timeframe,start_pos,count,series)<0) return(false); } //----+ return(true); } //+X================================================================X+ //| iPriceSeriesAlert() function | //+X================================================================X+ /* * The function iPriceSeriesAlert() is intended for indicating an unacceptable * value of the applied_price parameter passed to the iPriceSeries() function. */ void iPriceSeriesAlert(uchar applied_price) { //----+ if(applied_price<1) Alert("Parameter applied_price must less than 1. You have specified incorrect value", applied_price," the value of 1 will be used"); //----+ if(applied_price>12) Alert("The parameter applied_price must not exceed 12. You have specified incorrect value", applied_price," the value of 1 will be used"); //----+ } //+X================================================================X+ //| Classic averaging algorithms | //+X================================================================X+ double CMoving_Average::MASeries ( uint begin,// number of beginning of bars for reliable calculation uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period ENUM_MA_METHOD MA_Method,// method of averaging (MODE_SMA, MODE_EMA, MODE_SMMA, MODE_LWMA) double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ) // MASeries(begin, prev_calculated, Length, MA_Method, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ switch(MA_Method) { case MODE_SMA: return(SMASeries (begin, prev_calculated, rates_total, Length, series, bar, set)); case MODE_EMA: return(EMASeries (begin, prev_calculated, rates_total, Length, series, bar, set)); case MODE_SMMA: return(SMMASeries(begin, prev_calculated, rates_total, Length, series, bar, set)); case MODE_LWMA: return(LWMASeries(begin, prev_calculated, rates_total, Length, series, bar, set)); default: { if(bar==begin) { string word; StringConcatenate(word,__FUNCTION__,"():", " The parameter MA_Method must be within the range from MODE_SMA to MODE_LWMA.", " The value entered is invalid ",MA_Method," the MODE_SMA value will be used!"); Print(word); } return(SMASeries(begin,prev_calculated,rates_total,Length,series,bar,set)); } } //----+ } //+X================================================================X+ //| Simple averaging | //+X================================================================X+ double CMoving_Average::SMASeries ( uint begin,// The reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // Array indexing direction ) // SMASeries(begin, prev_calculated, rates_total, Length, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ Checking the beginning of bars for reliable calculation if(BarCheck1(begin,bar,set)) return(EMPTY_VALUE); //----+ Declaration of local variables int iii,kkk; double sma; //----+ checking the external parameter Length for correctness LengthCheck(Length); //----+ Changing the size of the array of variables if(bar==begin && !SeriesArrayResize(__FUNCTION__,Length,m_SeriesArray,m_Size_)) return(EMPTY_VALUE); //----+ rearrangement and initialization of cells of the array m_SeriesArray Recount_ArrayZeroPos(m_count,Length,prev_calculated,rates_total,series,bar,m_SeriesArray,set); //----+ Initialization of zero if(BarCheck2(begin,bar,set,Length)) { m_sum=0.0; for(iii=1; iii>> if(m_Loop1>30) { if(!m_start) { m_start= true; shift1 = 1; back=29; //---- m_ser2 = m_array[1]; m_ser1 = m_ser2; } else back=0; //-S-S-S-S-+ for(int rrr=back; rrr>=0; rrr--) { if(rrr==0) ser0=series; else ser0=m_array[31-rrr]; //---- dser1 = ser0 - m_ser1; dser2 = ser0 - m_ser2; //---- if(MathAbs(dser1)>MathAbs(dser2)) m_var2=MathAbs(dser1); else m_var2=MathAbs(dser2); //---- Res=m_var2; newvel=Res+0.0000000001; if(m_count1<=1) m_count1=127; else m_count1--; //---- if(m_count2<=1) m_count2=10; else m_count2--; //---- if(m_count3<128) m_count3++; //---- m_Sum1+=newvel-m_hoop2[m_count2]; //---- m_hoop2[m_count2]=newvel; m_bhoop2[m_count2]=true; //---- if(m_count3>10) SmVel=m_Sum1/10.0; else SmVel=m_Sum1/m_count3; //---- if(m_count3>127) { hoop1=m_hoop1[m_count1]; m_hoop1[m_count1]=SmVel; m_bhoop1[m_count1]=true; numb = 64; posB = numb; //---- while(numb>1) { if(m_data[posB]127) { m_midd2--; posB=m_midd2; } else { m_midd1++; posB=m_midd1; } //---- if(m_midd1>96) m_pos2=96; else m_pos2=m_midd1; //---- if(m_midd2<32) m_pos1=32; else m_pos1=m_midd2; } //---- numb = 64; posA = numb; //---- while(numb>1) { if(m_data[posA]>=SmVel) { if(m_data[posA-1]<=SmVel) numb=1; else { numb /= 2.0; posA -= numb; } } else { numb /= 2.0; posA += numb; } //---- if(posA==127) if(SmVel>m_data[127]) posA=128; } //---- if(m_count3>127) { if(posB>=posA) { if(m_pos2+1>posA) if(m_pos1-1posA) if(m_pos1-1=posA) { if(m_pos2+1posB) m_Sum2+=m_data[m_pos2+1]; } else if(m_pos2+2>posA) m_Sum2+=SmVel; //---- else if(m_pos2+1posB) m_Sum2+=m_data[m_pos2+1]; //---- if(posB>posA) { if(m_pos1-1posB) m_Sum2-=m_data[posB]; //---- else if(m_pos2posA) m_Sum2-=m_data[m_pos2]; } else { if(m_pos2+1>posB && m_pos1-1posB) if(m_pos1-0=posA; numb--) { m_data[numb+1]=m_data[numb]; m_bdata[numb+1]=true; } //---- m_data[posA]=SmVel; m_bdata[posA]=true; } //---- if(m_count3<=127) { m_Sum2=0; for(numb=m_pos1; numb<=m_pos2; numb++) m_Sum2+=m_data[numb]; } //---- resalt=m_Sum2/(m_pos2-m_pos1+1.0); //---- if(m_Loop2>30) m_Loop2=31; else m_Loop2++; //---- if(m_Loop2<=30) { if(dser1>0.0) m_ser1=ser0; else m_ser1=ser0-dser1*m_Kct; //---- if(dser2<0.0) m_ser2=ser0; else m_ser2=ser0-dser2*m_Kct; //---- m_JMA=series; //---- if(m_Loop2!=30) continue; else { m_storage1=series; if(MathCeil(m_Krx)>=1) dSupr=MathCeil(m_Krx); else dSupr=1.0; //---- if(dSupr>0) Suprem2=MathFloor(dSupr); else { if(dSupr<0) Suprem2=MathCeil(dSupr); else Suprem2=0.0; } //---- if(MathFloor(m_Krx)>=1) m_var2=MathFloor(m_Krx); else m_var2=1.0; //---- if(m_var2>0) Suprem1=MathFloor(m_var2); else { if(m_var2<0) Suprem1=MathCeil(m_var2); else Suprem1=0.0; } //---- if(Suprem2==Suprem1) factor=1.0; else { dSupr=Suprem2-Suprem1; factor=(m_Krx-Suprem1)/dSupr; } //---- if(Suprem1<=29) shift1=(int)Suprem1; else shift1=29; //---- if(Suprem2<=29) shift2=(int)Suprem2; else shift2=29; dser3 = series - m_array[m_Loop1 - shift1]; dser4 = series - m_array[m_Loop1 - shift2]; //---- m_djma=dser3 *(1.0-factor)/Suprem1+dser4*factor/Suprem2; } } else { ResPow=MathPow(Res/resalt,m_degree); //---- if(m_Kfd>=ResPow) m_var1= ResPow; else m_var1=m_Kfd; //---- if(m_var1<1.0)m_var2=1.0; else { if(m_Kfd>=ResPow) m_sense=ResPow; else m_sense=m_Kfd; m_var2=m_sense; } //---- extent=m_var2; Pow1=MathPow(m_Kct,MathSqrt(extent)); //---- if(dser1>0.0) m_ser1=ser0; else m_ser1=ser0-dser1*Pow1; //---- if(dser2<0.0) m_ser2=ser0; else m_ser2=ser0-dser2*Pow1; } } //---- if(m_Loop2>30) { Pow2=MathPow(m_Krj,extent); //---- m_storage1 *= Pow2; m_storage1 += (1.0 - Pow2) * series; m_storage2 *= m_Krj; m_storage2 += (series - m_storage1) * (1.0 - m_Krj); //---- Extr=m_Phase*m_storage2+m_storage1; //---- Pow2x2= Pow2 * Pow2; ratio = Pow2x2-2.0 * Pow2+1.0; m_djma *= Pow2x2; m_djma += (Extr - m_JMA) * ratio; //---- m_JMA+=m_djma; } } //-x-x-x-x-x-x-x-+ if(m_Loop1<=30) return(EMPTY_VALUE); jjma=m_JMA; //----+ restoring values of variables if(BarCheck5(rates_total,bar,set)) { //---- Restoring modified cells of arrays from memory for(numb = 0; numb < 128; numb++) if(m_bhoop1[numb]) m_hoop1[numb] = m_hoop1_[numb]; for(numb = 0; numb < 11; numb++) if(m_bhoop2[numb]) m_hoop2[numb] = m_hoop2_[numb]; for(numb = 0; numb < 128; numb++) if(m_bdata [numb]) m_data [numb] = m_data_ [numb]; //---- Zeroizing numbers of modified cells of arrays ArrayInitialize(m_bhoop1,false); ArrayInitialize(m_bhoop2,false); ArrayInitialize(m_bdata,false); //---- Writing values of variables from the memory m_JMA=m_JMA_; m_djma = m_djma_; m_ser1 = m_ser1_; m_ser2 = m_ser2_; m_Sum2 = m_Sum2_; m_pos1 = m_pos1_; m_pos2 = m_pos2_; m_Sum1 = m_Sum1_; m_Loop1 = m_Loop1_; m_Loop2 = m_Loop2_; m_count1 = m_count1_; m_count2 = m_count2_; m_count3 = m_count3_; m_storage1 = m_storage1_; m_storage2 = m_storage2_; m_midd1 = m_midd1_; m_midd2 = m_midd2_; } //----+ saving values of variables if(BarCheck4(rates_total,bar,set)) { //---- writing modified cells of arrays to the memory for(numb = 0; numb < 128; numb++) if(m_bhoop1[numb]) m_hoop1_[numb] = m_hoop1[numb]; for(numb = 0; numb < 11; numb++) if(m_bhoop2[numb]) m_hoop2_[numb] = m_hoop2[numb]; for(numb = 0; numb < 128; numb++) if(m_bdata [numb]) m_data_ [numb] = m_data [numb]; //---- Zeroizing numbers of modified cells of arrays ArrayInitialize(m_bhoop1,false); ArrayInitialize(m_bhoop2,false); ArrayInitialize(m_bdata,false); //---- writing values of variables to the memory m_JMA_=m_JMA; m_djma_ = m_djma; m_Sum2_ = m_Sum2; m_ser1_ = m_ser1; m_ser2_ = m_ser2; m_pos1_ = m_pos1; m_pos2_ = m_pos2; m_Sum1_ = m_Sum1; m_Loop1_ = m_Loop1; m_Loop2_ = m_Loop2; m_count1_ = m_count1; m_count2_ = m_count2; m_count3_ = m_count3; m_storage1_ = m_storage1; m_storage2_ = m_storage2; m_midd1_ = m_midd1; m_midd2_ = m_midd2; } //----+ End of calculations of the function JMASeries() return(jjma); } //+X================================================================X+ //| Initialization of variables of the JMA algorithm | //+X================================================================X+ void CJJMA::JJMAInit ( uint begin, int Din, double Phase, double Length, double series, uint bar ) // JMAInit(begin, Din, Phase, Length, series, bar) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //----+ <<< Calculation of coefficients >>> if(bar==begin || Din!=0) { if(bar==begin) { m_midd1 = 63; m_midd2 = 64; m_start = false; //---- for(int numb = 0; numb <= m_midd1; numb++) m_data[numb] = -1000000.0; for(int numb = m_midd2; numb <= 127; numb++) m_data[numb] = +1000000.0; //----+ All array cells must be overwritten ArrayInitialize(m_bhoop1,true); ArrayInitialize(m_bhoop2,true); ArrayInitialize(m_bdata,true); //----+ Deleting trash from arrays at repeated initializations ArrayInitialize(m_hoop1_, 0.0); ArrayInitialize(m_hoop2_, 0.0); ArrayInitialize(m_hoop1, 0.0); ArrayInitialize(m_hoop2, 0.0); ArrayInitialize(m_array, 0.0); //---- m_djma = 0.0; m_Sum1 = 0.0; m_Sum2 = 0.0; m_ser1 = 0.0; m_ser2 = 0.0; m_pos1 = 0.0; m_pos2 = 0.0; m_Loop1 = 0.0; m_Loop2 = 0.0; m_count1 = 0.0; m_count2 = 0.0; m_count3 = 0.0; m_storage1 = 0.0; m_storage2 = 0.0; m_JMA=series; } if(Phase>=-100 && Phase<=100) m_Phase=Phase/100.0+1.5; //---- if(Phase > +100) m_Phase = 2.5; if(Phase < -100) m_Phase = 0.5; //---- double velA,velB,velC,velD; //---- if(Length>=1.0000000002) velA=(Length-1.0)/2.0; else velA=0.0000000001; //---- velA *= 0.9; m_Krj = velA / (velA + 2.0); velC = MathSqrt(velA); velD = MathLog(velC); m_var1= velD; m_var2= m_var1; //---- velB=MathLog(2.0); m_sense=(m_var2/velB)+2.0; if(m_sense<0.0) m_sense=0.0; m_Kfd=m_sense; //---- if(m_Kfd>=2.5) m_degree=m_Kfd-2.0; else m_degree=0.5; //---- m_Krx = velC * m_Kfd; m_Kct = m_Krx / (m_Krx + 1.0); } //----+ } //+X================================================================X+ //| Checking the depth of averaging Length for correctness | //+X================================================================X+ void CJJMA::JJMALengthCheck(string LengthName,int ExternLength) // Jm_JMALengthCheck(LengthName, ExternLength) { //----+ //---- Writing messages about unacceptable values of input parameters if(ExternLength<1) { string word; StringConcatenate (word,__FUNCTION__," (): The parameter ",LengthName, " shall not be less than 1. You have specified incorrect value", ExternLength," the value of 1 will be used"); Print(word); return; } //----+ } //+X================================================================X+ //| Checking the correctness of the Phase parameter of averaging | //+X================================================================X+ void CJJMA::JJMAPhaseCheck(string PhaseName,int ExternPhase) // Jm_JMAPhaseCheck(PhaseName, ExternPhase) { //----+ //---- Writing messages about unacceptable values of input parameters if(ExternPhase<-100) { string word; StringConcatenate (word,__FUNCTION__," (): Parameter ",PhaseName, " must be no less than -100. You have specified incorrect value", ExternPhase," the value of -100 will be used"); Print(word); return; } //---- if(ExternPhase>+100) { string word; StringConcatenate (word,__FUNCTION__," (): Parameter ",PhaseName, " must not exceed +100. You have specified incorrect value", ExternPhase," value +100 will be used"); Print(word); return; } //----+ } //+X================================================================X+ //| T3 averaging | //+X================================================================X+ double CT3::T3Series ( uint begin,// number of beginning of bars for reliable calculation uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Din,// permission to change the Length parameter at every bar. // 0 locks out changes to parameters, any other value allows changes to parameters. double Curvature,// Coefficient (for convenience, its value is centuplicated!) double Length,// smoothing depth double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ) // T3Series(begin, prev_calculated, rates_total, Din, Curvature, Length, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //---- Checking the beginning of bars for reliable calculation if(BarCheck1(begin,bar,set)) return(EMPTY_VALUE); //----+ Declaration of local variables double e0,T3_; //----+ checking the external parameter Length for correctness LengthCheck(Length); //----+ Calculation of coefficients T3Init(begin,Din,Curvature,Length,series,bar); e0=series; //----+ <<< calculation of T3 >>> m_e1 = m_w1 * e0 + m_w2 * m_e1; m_e2 = m_w1 * m_e1 + m_w2 * m_e2; m_e3 = m_w1 * m_e2 + m_w2 * m_e3; m_e4 = m_w1 * m_e3 + m_w2 * m_e4; m_e5 = m_w1 * m_e4 + m_w2 * m_e5; m_e6 = m_w1 * m_e5 + m_w2 * m_e6; //---- T3_=m_c1*m_e6+m_c2*m_e5+m_c3*m_e4+m_c4*m_e3; //----+ restoring values of variables if(BarCheck5(rates_total,bar,set)) { m_e1 = m_E1; m_e2 = m_E2; m_e3 = m_E3; m_e4 = m_E4; m_e5 = m_E5; m_e6 = m_E6; } //----+ saving values of variables if(BarCheck4(rates_total,bar,set)) { m_E1 = m_e1; m_E2 = m_e2; m_E3 = m_e3; m_E4 = m_e4; m_E5 = m_e5; m_E6 = m_e6; } //----+ end of calculations of the T3Series() function value return(T3_); } //+X================================================================X+ //| Initialization of variables of the T3 algorithm | //+X================================================================X+ void CT3::T3Init ( uint begin, int Din, double Curvature, double Length, double series, uint bar ) // T3InitInit(begin, Din, Curvature, Length, series, bar) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //----+ <<< Calculation of coefficients >>> if(bar==begin || Din!=0) { double b=Curvature/100.0; m_b2 = b * b; m_b3 = m_b2 * b; m_c1 = -m_b3; m_c2 = (3 * (m_b2 + m_b3)); m_c3 = -3 * (2 * m_b2 + b + m_b3); m_c4 = (1 + 3 * b + m_b3 + 3 * m_b2); double n=1+0.5 *(Length-1); m_w1 = 2 / (n + 1); m_w2 = 1 - m_w1; if(bar==begin) { m_e1 = series; m_e2 = series; m_e3 = series; m_e4 = series; m_e5 = series; m_e6 = series; } } //----+ } //+X================================================================X+ //| Ultralinear smoothing | //+X================================================================X+ double CJurX::JurXSeries ( uint begin,// number of beginning of bars for reliable calculation uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Din,// permission to change the Length parameter at every bar // 0 is a restriction to change the parameters, any other value means a permission. double Length,// smoothing depth double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ) // JurXSeries(begin, prev_calculated, rates_total, Din, Length, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //---- Checking the beginning of bars for reliable calculation if(BarCheck1(begin,bar,set)) return(EMPTY_VALUE); //----+ Declaration of local variables double V1,V2,JurX_; //----+ checking the external parameter Length for correctness LengthCheck(Length); //----+ Initialization of coefficients JurXInit(begin,Din,Length,series,bar); //---- <<< calculation of JurX >>> m_f1 = m_Hg * m_f1 + m_Kg * series; m_f2 = m_Kg * m_f1 + m_Hg * m_f2; V1 = m_AC * m_f1 - m_AB * m_f2; m_f3 = m_Hg * m_f3 + m_Kg * V1; m_f4 = m_Kg * m_f3 + m_Hg * m_f4; V2 = m_AC * m_f3 - m_AB * m_f4; m_f5 = m_Hg * m_f5 + m_Kg * V2; m_f6 = m_Kg * m_f5 + m_Hg * m_f6; JurX_ = m_AC * m_f5 - m_AB * m_f6; //----+ restoring values of variables if(BarCheck5(rates_total,bar,set)) { m_f1 = m_F1; m_f2 = m_F2; m_f3 = m_F3; m_f4 = m_F4; m_f5 = m_F5; m_f6 = m_F6; } //----+ saving values of variables if(BarCheck4(rates_total,bar,set)) { m_F1 = m_f1; m_F2 = m_f2; m_F3 = m_f3; m_F4 = m_f4; m_F5 = m_f5; m_F6 = m_f6; } //----+ End of calculation of value of the functions JurX.Series return(JurX_); } //+X================================================================X+ //| Initialization of variables of the algorithm JurX | //+X================================================================X+ void CJurX::JurXInit ( uint begin, int Din, double Length, double series, uint bar ) // JurXInit(begin, Din, Length, series, bar) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ if(bar==begin || Din!=0) { if(Length>=6) m_w=Length-1; else m_w=5; m_Kg = 3 / (Length + 2.0); m_Hg = 1.0 - m_Kg; //---- if(bar==begin) { m_f1 = series; m_f2 = series; m_f3 = series; m_f4 = series; m_f5 = series; m_f6 = series; m_AB = 0.5; m_AC = 1.5; } } //----+ } //+X================================================================X+ //| Parabolic smoothing | //+X================================================================X+ double CParMA::ParMASeries ( uint begin,// The reliable starting point number for bars uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// Averaging period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // Array indexing direction ) // SMASeries(Number, symbol, timeframe, begin, limit, Length, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //---- Checking the beginning of bars for reliable calculation if(BarCheck1(begin,bar,set)) return(EMPTY_VALUE); //----+ Declaration of local variables int iii,kkk; //---- double S,B0,B1,B2,parma; double A,B,C,D,E,F; double K,L,M,P,Q,R; double sum_y,sum_xy,sum_x2y,var_tmp; //----+ Changing the size of the array of variables if(bar==begin && !SeriesArrayResize(__FUNCTION__,Length,m_SeriesArray,m_Size_)) return(EMPTY_VALUE); //----+ checking the external parameter Length for correctness LengthCheck(Length); //----+ rearrangement and initialization of cells of the array m_SeriesArray Recount_ArrayZeroPos(m_count,Length,prev_calculated,rates_total,series,bar,m_SeriesArray,set); //----+ Initialization of zero if(BarCheck2(begin,bar,set,Length)) ParMAInit(Length); else if(BarCheck3(begin,bar,set,Length)) return(EMPTY_VALUE); //----+ Calculation ParMA sum_y = 0.0; sum_xy = 0.0; sum_x2y = 0.0; //---- for(iii=1; iii<=Length; iii++) { kkk=Recount_ArrayNumber(m_count,Length,Length-iii); var_tmp = m_SeriesArray[kkk]; sum_y += var_tmp; sum_xy += iii * var_tmp; sum_x2y += iii * iii * var_tmp; } // the difference between two adjacent bars for sum_x2y: Sum(i=0; i 0) m_UpSum += dseries; if(dseries < 0) m_DnSum -= dseries; } m_AbsCMO=0.000000001; } else if(BarCheck3(begin,bar,set,CMO_Length+3)) { m_series1=series; return(EMPTY_VALUE); } dseries=m_dSeriesArray[m_count]; if(dseries > 0) m_UpSum += dseries; if(dseries < 0) m_DnSum -= dseries; if(m_UpSum+m_DnSum>0) m_AbsCMO=MathAbs((m_UpSum-m_DnSum)/(m_UpSum+m_DnSum)); abcmo=m_AbsCMO; //---- rrr=Recount_ArrayNumber(m_count,size,CMO_Length-1); dseries=m_dSeriesArray[rrr]; if(dseries > 0) m_UpSum -= dseries; if(dseries < 0) m_DnSum += dseries; //----+ restoring values of variables if(BarCheck5(rates_total,bar,set)) { m_AbsCMO= m_AbsCMO_; m_UpSum = m_UpSum_; m_DnSum = m_DnSum_; m_series1=m_series1_; } else m_series1=series; //----+ saving values of variables if(BarCheck4(rates_total,bar,set)) { m_AbsCMO_=m_AbsCMO; m_UpSum_ = m_UpSum; m_DnSum_ = m_DnSum; m_series1_=m_series1; } //----+ return(abcmo); } //+X================================================================X+ //| VIDYASeries() function | //+X================================================================X+ double CCMO::VIDYASeries ( uint begin,// number of beginning of bars for reliable calculation uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int CMO_Length,// CMO period double EMA_Length,// EMA period double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ) // VIDYASeries(begin, prev_calculated, rates_total, CMO_Length, EMA_Length, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //----+ Declaration of local variables double vidya,CMO_=CMOSeries(begin,prev_calculated,rates_total,CMO_Length,series,bar,set); //----+ Initialization of zero if(BarCheck2(begin,bar,set,CMO_Length+3)) { m_Vidya=series; //---- Initialization of the EMA smoothing factor m_SmoothFactor=2.0/(EMA_Length+1.0); } else if(BarCheck3(begin,bar,set,CMO_Length+3)) return(EMPTY_VALUE); //---- CMO_*=m_SmoothFactor; m_Vidya=CMO_*series+(1-CMO_)*m_Vidya; vidya=m_Vidya; //----+ restoring values of variables if(BarCheck5(rates_total,bar,set)) { m_Vidya=m_Vidya_; } //----+ saving values of variables if(BarCheck4(rates_total,bar,set)) { m_Vidya_=m_Vidya; } //----+ return(vidya); } //+X================================================================X+ //| Kaufman's smoothing | //+X================================================================X+ double CAMA::AMASeries ( uint begin,// number of beginning of bars for reliable calculation uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick int Length,// AMA period int Fast_Length, // period of fast moving average int Slow_Length, // slow moving average period double Rate,// the power to which the smoothing constant is raised double series,// Price series value calculated for the bar with number 'bar' uint bar,// Bar index bool set // direction of indexing arrays ) // AMASeries(symbol, timeframe, begin, limit, Length, series, bar, set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //---- Checking the beginning of bars for reliable calculation if(BarCheck1(begin,bar,set)) return(EMPTY_VALUE); //----+ Declaration of local variables double signal,ER,ERSC,SSC,dprice,ama; int iii,kkk,rrr,size=Length+1; //----+ Change size of variables arrays if(bar==begin) if(!SeriesArrayResize(__FUNCTION__,size,m_SeriesArray,m_Size_1) || !SeriesArrayResize(__FUNCTION__,size,m_dSeriesArray,m_Size_2)) return(EMPTY_VALUE); //----+ checking the external parameter Length for correctness LengthCheck(Length); //----+ rearrangement and initialization of cells of the array m_SeriesArray Recount_ArrayZeroPos(m_count,size,prev_calculated,rates_total,series,bar,m_SeriesArray,set); //---- checking whether there are enough bars if(BarCheck1(begin+1,bar,set)) return(EMPTY_VALUE); kkk=Recount_ArrayNumber(m_count,size,1); dprice=series-m_SeriesArray[kkk]; m_dSeriesArray[m_count]=dprice; //----+ Initialization of zero if(BarCheck2(begin,bar,set,Length+3)) { //---- initialization of constants rrr=Recount_ArrayNumber(m_count,size,1); m_Ama=m_SeriesArray[rrr]; m_slowSC = (2.0 / (Slow_Length + 1)); m_fastSC = (2.0 / (Fast_Length + 1)); m_dSC=m_fastSC-m_slowSC; m_noise=0.000000001; for(iii=1; iii+100) { string word; StringConcatenate(word,__FUNCTION__," (): Parameter ",PhaseName, " must not exceed +100. You have specified unacceptable value ",ExternPhase," +100 will be used"); Print(word); break;; } break; case MODE_JurX: break; case MODE_ParMA: break; case MODE_T3: break; if(ExternPhase<1) { string word; StringConcatenate(word,__FUNCTION__," (): Parameter ",PhaseName, " shall not be less than 1. You have specified unacceptable value ",ExternPhase," 1 will be used"); Print(word); break; } case MODE_VIDYA: if(ExternPhase<1) { string word; StringConcatenate(word,__FUNCTION__," (): Parameter ",PhaseName, " shall not be less than 1. You have specified unacceptable value ",ExternPhase," 1 will be used"); Print(word); break; } case MODE_AMA: if(ExternPhase<1) { string word; StringConcatenate(word,__FUNCTION__," (): Parameter ",PhaseName, " shall not be less than 1. You have specified unacceptable value ",ExternPhase," 1 will be used"); Print(word); break; } } //----+ } //+X================================================================X+ //| Checking the depth of averaging Length for correctness | //+X================================================================X+ void CXMA::XMALengthCheck(string LengthName,int ExternLength) // XMALengthCheck(LengthName, ExternLength) { //----+ //---- Writing messages about unacceptable values of input parameters if(ExternLength<1) { string word; StringConcatenate (word,__FUNCTION__," (): The parameter ",LengthName, " shall not be less than 1. You have specified incorrect value", ExternLength," the value of 1 will be used"); Print(word); return; } //----+ } //+X================================================================X+ //| Checking correctness of the period of averaging | //+X================================================================X+ void CMovSeriesTools::MALengthCheck(string LengthName,int ExternLength) // MALengthCheck(LengthName, ExternLength) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ if(ExternLength<1) { string word; StringConcatenate (word,__FUNCTION__," (): The parameter ",LengthName, " shall not be less than 1. You have specified incorrect value", ExternLength," the value of 1 will be used"); Print(word); return; } //----+ } //+X================================================================X+ //| Checking correctness of the period of averaging | //+X================================================================X+ void CMovSeriesTools::MALengthCheck(string LengthName,double ExternLength) // MALengthCheck(LengthName, ExternLength) { //----+ if(ExternLength<1) { string word; StringConcatenate (word,__FUNCTION__," (): The parameter ",LengthName, " shall not be less than 1. You have specified incorrect value", ExternLength," the value of 1 will be used"); Print(word); return; } //----+ } //+X================================================================X+ //| Checking if the bar is within the calculation range | //+X================================================================X+ bool CMovSeriesTools::BarCheck1(int begin,int bar,bool Set) // BarCheck1(begin, bar, Set) { //----+ if(!Set && barbegin) return(true); //----+ return(false); } //+X================================================================X+ //| Checking bar for the start of calculation | //+X================================================================X+ bool CMovSeriesTools::BarCheck2(int begin,int bar,bool Set,int Length) // BarCheck2(begin, bar, Set, Length) { //----+ if(!Set && bar==begin+Length-1 || Set && bar==begin-Length+1) return(true); //----+ return(false); } //+X================================================================X+ //| Checking the bar for absence of bars for smoothing | //+X================================================================X+ bool CMovSeriesTools::BarCheck3(int begin,int bar,bool Set,int Length) // BarCheck3(begin, bar, Set, Length) { //----+ if(!Set && barbegin-Length+1) return(true); //----+ return(false); } //+X================================================================X+ //| Checking the bar at the moment of the data saving | //+X================================================================X+ bool CMovSeriesTools::BarCheck4(int rates_total,int bar,bool Set) // BarCheck4(rates_total, bar, Set) { //----+ //----+ saving values of variables if(!Set && bar==rates_total-2 || Set && bar==1) return(true); //----+ return(false); } //+X================================================================X+ //| Checking the bar at the moment of restoring data | //+X================================================================X+ bool CMovSeriesTools::BarCheck5(int rates_total,int bar,bool Set) // BarCheck5(rates_total, begin, bar, set) { //----+ //----+ restoring values of variables if(!Set && bar==rates_total-1 || Set && bar==0) return(true); //----+ return(false); } //+X================================================================X+ //| Changing incorrect period of averaging | //+X================================================================X+ void CMovSeriesTools::LengthCheck(int &ExternLength) // LengthCheck(LengthName, ExternLength) { //----+ if(ExternLength<1) ExternLength=1; //----+ } //+X================================================================X+ //| Changing incorrect period of averaging | //+X================================================================X+ void CMovSeriesTools::LengthCheck(double &ExternLength) // LengthCheck(ExternLength) { //----+ if(ExternLength<1) ExternLength=1; //----+ } //+X================================================================X+ //| recalculation of position of a newest element in the array | //+X================================================================X+ void CMovSeriesTools::Recount_ArrayZeroPos ( int &count,// Returns the number of the current value of the price series by reference int Length, uint prev_calculated,// amount of history in bars at the previous tick uint rates_total,// amount of history in bars at the current tick double series,// Price series value calculated for the bar with number 'bar' int bar, double &Array[], bool set // Array indexing direction ) // Recount_ArrayZeroPos(count, Length, prev_calculated, rates_total, series, bar, Array[], set) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ if(set) { if(bar!=rates_total-prev_calculated) { count--; if(count<0) count=Length-1; } } else { if(bar!=prev_calculated-1) { count--; if(count<0) count=Length-1; } } Array[count]=series; //----+ } //+X================================================================X+ //| Transformation of a timeseries number into an array position | //+X================================================================X+ int CMovSeriesTools::Recount_ArrayNumber ( int count,// Number of the current value of the price series int Length, int Number // Position of the requested value relatively to the current bar 'bar' ) // Recount_ArrayNumber(count, Length, Number) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ int ArrNumber=Number+count; if(ArrNumber>Length-1) ArrNumber-=Length; //----+ return(ArrNumber); } //+X================================================================X+ //| Changing size of the array Array[] | //+X================================================================X+ bool CMovSeriesTools::SeriesArrayResize ( string FunctionsName,// Name of the function in which the size is changed int Length,// new size of the array double &Array[],// Array that is being changed int &Size_ // Resulting size of the array ) // SeriesArrayResize(FunctionsName, Length, Array, Size_) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ //----+ Changing the size of the array of variables if(Length>Size_) { int Size=Length+1; if(ArrayResize(Array,Size)==-1) { ArrayResizeErrorPrint(FunctionsName,Size_); return(false); } Size_=Size; } //----+ return(true); } //+X================================================================X+ //| Writing the error of changing size of the array into log file | //+X================================================================X+ bool CMovSeriesTools::ArrayResizeErrorPrint ( string FunctionsName, int &Size_ ) // ArrayResizeErrorPrint(FunctionsName, Size_) //+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -+ { //----+ string lable,word; StringConcatenate(lable,FunctionsName,"():"); StringConcatenate(word,lable," Error!!! Failed to change", " the size of the array of variables of the function ",FunctionsName,"()!"); Print(word); //---- int error=GetLastError(); ResetLastError(); //---- if(error>4000) { StringConcatenate(word,lable,"(): Error code ",error); Print(word); } Size_=-2; return(false); //----+ return(true); } //+X----------------------+ <<< The End >>> +-----------------------X+