Category Trend  at 09/03/2015

zig zag buy sell

Subscribe
Description

//+------------------------------------------------------------------+
//|                                             ZigAndZagScalpel.mq4 |
//|                           Bookkeeper, 2006, yuzefovich@gmail.com |
//+------------------------------------------------------------------+
#property copyright ""
#property link      ""
//----
#property indicator_chart_window
#property indicator_buffers 7     // Èëè 8 - äëÿ testBuffer
#property indicator_color1 Aqua
#property indicator_color2 Black
#property indicator_color3 Black
#property indicator_color4 Black
#property indicator_color5 White
#property indicator_color6 Red
#property indicator_color7 Red
//#property indicator_color8 White // Äëÿ ïîäáîðà ÷åãî-íèáóäü
extern int KeelOver=55; // Äëÿ M15
extern int Slalom=17;  // Äëÿ M15
double KeelOverZigAndZagSECTION[];
double KeelOverZagBuffer[];
double SlalomZigBuffer[];
double SlalomZagBuffer[];
double LimitOrdersBuffer[];
double BuyOrdersBuffer[];
double SellOrdersBuffer[];
//double testBuffer[];
int    shift,back,CountBar,Backstep=3;
int    LastSlalomZagPos,LastSlalomZigPos,LastKeelOverZagPos,LastKeelOverZigPos;
double Something,LimitPoints,Navel;
double CurKeelOverZig,CurKeelOverZag,CurSlalomZig,CurSlalomZag;
double LastSlalomZag,LastSlalomZig,LastKeelOverZag,LastKeelOverZig;
bool   TrendUp,SetBuyOrder,SetLimitOrder,SetSellOrder,Second=false;
string LastZigOrZag="None";
//----
int init()
  {
   SetIndexBuffer(0,KeelOverZigAndZagSECTION);
   SetIndexStyle(0,DRAW_SECTION,STYLE_DOT);//DRAW_SECTION èëè DRAW_NONE
   SetIndexEmptyValue(0,0.0);
   SetIndexBuffer(1,KeelOverZagBuffer);
   SetIndexStyle(1,DRAW_NONE);
   SetIndexEmptyValue(1,0.0);
   SetIndexBuffer(2,SlalomZigBuffer);
   SetIndexStyle(2,DRAW_NONE);
   SetIndexEmptyValue(2,0.0);
   SetIndexBuffer(3,SlalomZagBuffer);
   SetIndexStyle(3,DRAW_NONE);
   SetIndexEmptyValue(3,0.0);
   SetIndexBuffer(4,LimitOrdersBuffer);
   SetIndexStyle(4,DRAW_ARROW);
   SetIndexArrow(4,108);
   SetIndexEmptyValue(4,0.0);
   SetIndexBuffer(5,BuyOrdersBuffer);
   SetIndexStyle(5,DRAW_ARROW);
   SetIndexArrow(5,233);
   SetIndexEmptyValue(5,0.0);
   SetIndexBuffer(6,SellOrdersBuffer);
   SetIndexStyle(6,DRAW_ARROW);
   SetIndexArrow(6,234);
   SetIndexEmptyValue(6,0.0);
   //   SetIndexStyle(7,DRAW_SECTION);
   //   SetIndexBuffer(7,testBuffer);
   //   SetIndexEmptyValue(7,0.0);
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   CountBar=Bars-KeelOver;
   LimitPoints=Ask-Bid;
   if(CountBar<=3*KeelOver) return(-1); // Ìàëîâàòî áóäåò
   if(KeelOver<=2*Slalom) return(-1);  // Òùàòåëüíåå íàäî
   // Çà÷èñòêà íåïðàâèëüíîé èñòîðèè
   for(shift=Bars-1; shift>Bars-KeelOver; shift--)
     {
      SlalomZagBuffer[shift]=0.0;
      SlalomZigBuffer[shift]=0.0;
      KeelOverZagBuffer[shift]=0.0;
      KeelOverZigAndZagSECTION[shift]=0.0;
      LimitOrdersBuffer[shift]=0.0;
      BuyOrdersBuffer[shift]=0.0;
      SellOrdersBuffer[shift]=0.0;
      //      testBuffer[shift]=0.0;
     }
   //+---Ïåðâûé ïîõîä ïî èñòîðèè----------------------------------------+
   The_First_Crusade();
   //+---Âòîðîé ïðîõîä ïî èñòîðè÷åñêèì ìåñòàì---------------------------+
   //+---ñ öåëüþ ïîä÷èñòêè íåâåðíî ïîíÿòûõ ñîáûòèé----------------------+
   LastSlalomZag=-1; LastSlalomZagPos=-1;
   LastSlalomZig=-1;  LastSlalomZigPos=-1;
   LastKeelOverZag=-1; LastKeelOverZagPos=-1;
   LastKeelOverZig=-1;  LastKeelOverZigPos=-1;
   The_Second_Crusade();
   //+---Òðåòèé èñòîðè÷åñêèé ýêñêóðñ - ïîñòðîåíèå "òðåíäà"--------------+
   //+---è ðàññòàíîâêà "òîðãîâûõ ñèãíàëîâ"------------------------------+
   LastSlalomZag=-1; LastSlalomZagPos=-1;
   LastSlalomZig=-1;  LastSlalomZigPos=-1;
   LastZigOrZag="None";
   The_Third_Crusade();
   //+---À ÷åãî ìû òåïåðü áóäåì èìåòü çäåñü è ñåé÷àñ?-------------------+
   Shift_Zerro();
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void The_First_Crusade()
  {
   for(shift=CountBar; shift>0; shift--)
     {
      // Ïîèñê òî÷åê "âñòàë â ïîçó" - "óøåë ñ ðûíêà"
      CurSlalomZig=Low[Lowest(NULL,0,MODE_LOW,Slalom,shift)];
      CurSlalomZag=High[Highest(NULL,0,MODE_HIGH,Slalom,shift)];
      // Ïðîâåðÿåì shift íà íàëè÷èå î÷åðåäíîãî ÑëàëîìÇèãà äëÿ âõîäà
      // â ïîêóïêó èëè äëÿ âûõîäà èç ïðîäàæè
      if(CurSlalomZig==LastSlalomZig) CurSlalomZig=0.0;
      else
        {
         LastSlalomZig=CurSlalomZig;
         if((Low[shift]-CurSlalomZig)>LimitPoints) CurSlalomZig=0.0;
         else
           {
            // Íà èíòåðâàëå Backstep ìîæåò áûòü òîëüêî îäèí Çèã,
            // îñòàâëÿåì òîëüêî ïîñëåäíèé, áîëåå ðàííèå óáèðàåì
            for(back=1; back<=Backstep; back++)
              {
               Something=SlalomZigBuffer[shift+back];
               if((Something!=0)&&(Something>CurSlalomZig))
                  SlalomZigBuffer[shift+back]=0.0;
              }
           }
        }
      // Ïðîâåðÿåì shift íà íàëè÷èå î÷åðåäíîãî ÑëàëîìÇàãà äëÿ âõîäà âíèç
      // èëè äëÿ âûõîäà èç ïîêóïêè
      if(CurSlalomZag==LastSlalomZag) CurSlalomZag=0.0;
      else
        {
         LastSlalomZag=CurSlalomZag;
         if((CurSlalomZag-High[shift])>LimitPoints) CurSlalomZag=0.0;
         else
           {
            // Íà èíòåðâàëå Backstep ìîæåò áûòü òîëüêî îäèí Çàã,
            // îñòàâëÿåì òîëüêî ïîñëåäíèé, áîëåå ðàííèå óáèðàåì
            for(back=1; back<=Backstep; back++)
              {
               Something=SlalomZagBuffer[shift+back];
               if((Something!=0)&&(Something                   SlalomZagBuffer[shift+back]=0.0;
              }
           }
        }
      // Âñå, ÷òî íàøëè íîâåíüêîãî è ïóñòûøêè - êëàäåì â áóôåðà ñëàëîìà
      SlalomZigBuffer[shift]=CurSlalomZig;
      SlalomZagBuffer[shift]=CurSlalomZag;
      // Èùåì òî÷êè ðàçâîðîòà äëÿ ïîñòðîåíèÿ "ëèíåéíîãî òðåíäà", ïðè ýòîì
      // â áóôåð ðàçâîðîòîâ ZigAndZag ïîêà ÷òî áóäåì êëàñòü òîëüêî ÎâåðêèëüÇèãè
      CurKeelOverZig=Low[Lowest(NULL,0,MODE_LOW,KeelOver,shift)];
      CurKeelOverZag=High[Highest(NULL,0,MODE_HIGH,KeelOver,shift)];
      // Ïðîâåðÿåì shift íà íàëè÷èå î÷åðåäíîãî ÎâåðêèëüÇèãà
      if(CurKeelOverZig==LastKeelOverZig) CurKeelOverZig=0.0;
      else
        {
         LastKeelOverZig=CurKeelOverZig;
         if((Low[shift]-CurKeelOverZig)>LimitPoints) CurKeelOverZig=0.0;
         else
           {
            // Íà èíòåðâàëå Backstep ìîæåò áûòü òîëüêî îäèí Çèã,
            // îñòàâëÿåì òîëüêî ïîñëåäíèé, áîëåå ðàííèå óáèðàåì
            for(back=1; back<=Backstep; back++)
              {
               Something=KeelOverZigAndZagSECTION[shift+back];
               if((Something!=0)&&(Something>CurKeelOverZig))
                  KeelOverZigAndZagSECTION[shift+back]=0.0;
              }
           }
        }
      // Ïðîâåðÿåì shift íà íàëè÷èå î÷åðåäíîãî ÎâåðêèëüÇàãà
      if(CurKeelOverZag==LastKeelOverZag) CurKeelOverZag=0.0;
      else
        {
         LastKeelOverZag=CurKeelOverZag;
         if((CurKeelOverZag-High[shift])>LimitPoints) CurKeelOverZag=0.0;
         else
           {
            // Íà èíòåðâàëå Backstep ìîæåò áûòü òîëüêî îäèí Çàã,
            // áîëåå ðàííèå óáèðàåì
            for(back=1; back<=Backstep; back++)
              {
               Something=KeelOverZagBuffer[shift+back];
               if((Something!=0)&&(Something                   KeelOverZagBuffer[shift+back]=0.0;
              }
           }
        }
      // Âñå, ÷òî íàøëè èëè íå íàøëè - êëàäåì â áóôåðà ðàçâîðîòîâ
      KeelOverZigAndZagSECTION[shift]=CurKeelOverZig;
      KeelOverZagBuffer[shift]=CurKeelOverZag;
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void The_Second_Crusade()
  {
   // Ïðîñòî ïîä÷èñòêà ëèøíåãî
   for(shift=CountBar; shift>0; shift--)
     {
      CurSlalomZig=SlalomZigBuffer[shift];
      CurSlalomZag=SlalomZagBuffer[shift];
      if((CurSlalomZig==0)&&(CurSlalomZag==0)) continue;
      if(CurSlalomZag!=0)
        {
         if(LastSlalomZag>0)
           {
            if(LastSlalomZag             else SlalomZagBuffer[shift]=0;
           }
         if(LastSlalomZag            {
            LastSlalomZag=CurSlalomZag;
            LastSlalomZagPos=shift;
           }
         LastSlalomZig=-1;
        }
      if(CurSlalomZig!=0)
        {
         if(LastSlalomZig>0)
           {
            if(LastSlalomZig>CurSlalomZig) SlalomZigBuffer[LastSlalomZigPos]=0;
            else SlalomZigBuffer[shift]=0;
           }
         if((CurSlalomZig            {
            LastSlalomZig=CurSlalomZig;
            LastSlalomZigPos=shift;
           }
         LastSlalomZag=-1;
        }
      CurKeelOverZig=KeelOverZigAndZagSECTION[shift];
      CurKeelOverZag=KeelOverZagBuffer[shift];
      if((CurKeelOverZig==0)&&(CurKeelOverZag==0)) continue;
      if(CurKeelOverZag !=0)
        {
         if(LastKeelOverZag>0)
           {
            if(LastKeelOverZag                KeelOverZagBuffer[LastKeelOverZagPos]=0;
            else KeelOverZagBuffer[shift]=0.0;
           }
         if(LastKeelOverZag            {
            LastKeelOverZag=CurKeelOverZag;
            LastKeelOverZagPos=shift;
           }
         LastKeelOverZig=-1;
        }
      if(CurKeelOverZig!=0)
        {
         if(LastKeelOverZig>0)
           {
            if(LastKeelOverZig>CurSlalomZig)
               KeelOverZigAndZagSECTION[LastKeelOverZigPos]=0;
            else KeelOverZigAndZagSECTION[shift]=0;
           }
         if((CurKeelOverZig            {
            LastKeelOverZig=CurKeelOverZig;
            LastKeelOverZigPos=shift;
           }
         LastKeelOverZag=-1;
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void The_Third_Crusade()
  {
   bool first=true;
   for(shift=CountBar; shift>0; shift--)
     {
      // Íèçâåãàåì ïðåæíèõ ïðîðîêîâ
      LimitOrdersBuffer[shift]=0.0;
      BuyOrdersBuffer[shift]=0.0;
      SellOrdersBuffer[shift]=0.0;
      // Çàäàåì öåíòð ìèðîçäàíüÿ èíòåðâàëà shift (ïî ëþáîìó -
      // ñïîñîá áîëüøîãî ïîëèòè÷åñêîãî âåñà íå èìååò)
      Navel=(5*Close[shift]+2*Open[shift]+High[shift]+Low[shift])/9;
      // Åñëè îâåðêèëü - ñìîòðèì,
      // êóäà (ìîæåò áûòü) äàëüøå ñåéìîìåíòíî ïîéäåì: ââåðõ èëè âíèç
      if(KeelOverZigAndZagSECTION[shift]!=0.0)
        {
         TrendUp=true;
         first=false;
        }
      if(KeelOverZagBuffer[shift]!=0.0)
        {
         TrendUp=false;
         first=false;
        }
      // Ñîáèðàåì â KeelOverZigAndZagSECTION è ÎâåðêèëüÇèãè, è ÎâåðêèëüÇàãè,
      // è ïóñòûøêè - âñå â îäíó êó÷êó, òàêèì îáðàçîì ïîëó÷àåì äîëãîèãðàþùèé
      // ZigAndZag, íàòÿãèâàÿ íèòü "òðåíäà" íà ïóïêè ðàçâîðîòíûõ ñâå÷åê
      if(KeelOverZagBuffer[shift]!=0.0 || KeelOverZigAndZagSECTION[shift]!=0.0)
        {
         KeelOverZigAndZagSECTION[shift]=Navel;
        }
      else KeelOverZigAndZagSECTION[shift]=0.0;
      // Ïðîâåðÿåì shift íà íàëè÷èå ÑëàëîìÇèãà èëè ÑëàëîìÇàãà
      if(SlalomZigBuffer[shift]!=0.0)
        {
         LastZigOrZag="Zig";
         LastSlalomZig=Navel;
         SetBuyOrder=false;
         SetLimitOrder=false;
         SetSellOrder=false;
        }
      if(SlalomZagBuffer[shift]!=0.0)
        {
         LastZigOrZag="Zag";
         LastSlalomZag=Navel;
         SetBuyOrder=false;
         SetLimitOrder=false;
         SetSellOrder=false;
        }
      // è, åñëè íè ÑëàëîìÇèãà, íè ÑëàëîìÇàãà óæå íåò,
      // à îâåðêèëü óæå áûë - ñìîòðèì, à ÷òî åñòü ïî âõîäó-âûõîäó
      if(SlalomZigBuffer[shift]==0.0 &&
         SlalomZagBuffer[shift]==0.0 &&
         first==false)                  Slalom_With_A_Scalpel();
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Shift_Zerro()
  {
   shift=0;
   Navel=(5*Close[0]+2*Open[0]+High[0]+Low[0])/9;
   Slalom_With_A_Scalpel();
   KeelOverZigAndZagSECTION[0]=Navel;
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Slalom_With_A_Scalpel()
  {
   // Ïðîâåðÿåì ñóùåñòâóþùèé ñèãíàë íà èìååò ïðàâî áûòü
   // èëè íà åñëè íå ñòîèò, à õîòåëîñü áû:  
   // åñëè õîä ÷èñòî êîíêðåòíî ïî æèçíè - çàáèâàåì Ñòðåëêó íà äåíüãè,
   // åñëè ïðîòèâ - ñòàâèì íà øóõåð Øàðèêà Äåëàé-Íîãè
   if(LastZigOrZag=="Zig")
     {
      if(TrendUp==true)
        {
         if((Navel-LastSlalomZig)>=LimitPoints && SetBuyOrder==false)
           {
            SetBuyOrder=true;
            BuyOrdersBuffer[shift]=Low[shift+1];
            LastSlalomZigPos=shift;
           }
         if(Navel<=LastSlalomZig && SetBuyOrder==true)
           {
            SetBuyOrder=false;
            BuyOrdersBuffer[LastSlalomZigPos]=0.0;
            LastSlalomZigPos=-1;
           }
        }
      if(TrendUp==false)
        {
         if(Navel>LastSlalomZig && SetLimitOrder==false)
           {
            SetLimitOrder=true;
            LimitOrdersBuffer[shift]=Navel;
            //            LimitOrdersBuffer[shift]=Close[shift];
            LastSlalomZigPos=shift;
           }
         if(Navel<=LastSlalomZig && SetLimitOrder==true)
           {
            SetLimitOrder=false;
            LimitOrdersBuffer[LastSlalomZigPos]=0.0;
            LastSlalomZigPos=-1;
           }
        }
     }
   if(LastZigOrZag=="Zag")
     {
      if(TrendUp==false)
        {
         if((LastSlalomZag-Navel)>=LimitPoints && SetSellOrder==false)
           {
            SetSellOrder=true;
            SellOrdersBuffer[shift]=High[shift+1];
            LastSlalomZagPos=shift;
           }
         if(Navel>=LastSlalomZag && SetSellOrder==true)
           {
            SetSellOrder=false;
            SellOrdersBuffer[LastSlalomZagPos]=0.0;
            LastSlalomZagPos=-1;
           }
        }
      if(TrendUp==true)
        {
         if(LastSlalomZag>Navel && SetLimitOrder==false)
           {
            SetLimitOrder=true;
            LimitOrdersBuffer[shift]=Navel;
            //            LimitOrdersBuffer[shift]=Close[shift];
            LastSlalomZagPos=shift;
           }
         if(Navel>=LastSlalomZag && SetLimitOrder==true)
           {
            SetLimitOrder=false;
            LimitOrdersBuffer[LastSlalomZagPos]=0.0;
            LastSlalomZagPos=-1;
           }
        }
     }
   return;
  }
//+--Ñîáñòâåííî, ÿ âñå ñêàçàë. Çàáàâíî, åñëè âñå ýòî ðàáîòàòü áóäåò--+
//+------------------------------------------------------------------+

 


// ------------------------------------------------------------                   
// Paste this code into your cAlgo editor. 
// -----------------------------------------------------------
using System;
using System.Collections.Generic;

using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.MQ4;

using System.Linq;

// ---------------------------------------------------------------------------                   
// Converted from MQ4 to cAlgo with http://2calgo.com
// ---------------------------------------------------------------------------

// ZigZag Kwan MBFX Timing ou Beta
// http://fxfree.co/threads/kwan-zigzag-beta-mbfx-timing-indicators-chi-bao-xu-huong-thi-thuong.1230/

namespace cAlgo.Indicators
{

	[Indicator(ScalePrecision = 2, AutoRescale = false, IsOverlay = false)]
	[Levels(70, 30, 50)]
	public class ZigzagKwanMBFXTiming : Indicator
	{

		#region cBot Parameters
		[Parameter("Len", DefaultValue = 4)]
		public int len { get; set; }

		[Parameter("Filter", DefaultValue = -1.0)]
		public double filter { get; set; }

		[Output("Stand", Color = Colors.Yellow, PlotType = PlotType.DiscontinuousLine)]
		public IndicatorDataSeries standIndicatorDataSeries { get; set; }

		[Output("Buy", Color = Colors.Green, PlotType = PlotType.DiscontinuousLine)]
		public IndicatorDataSeries buyIndicatorDataSeries { get; set; }

		[Output("Sell", Color = Colors.Red, PlotType = PlotType.DiscontinuousLine)]
		public IndicatorDataSeries sellIndicatorDataSeries { get; set; }

		[Output("Trade", Color = Colors.SteelBlue, PlotType = PlotType.DiscontinuousLine)]
		public IndicatorDataSeries tradeActionIndicatorDataSeries { get; set; }
		#endregion

		#region globals

		public const int ceilTradeAction = 10;
		public const int tradeActionNeutral = -20;

		public Mq4OutputDataSeries tradeActionMq4Output;
		Mq4OutputDataSeries standMq4Output;
		Mq4OutputDataSeries buyMq4Output;
		Mq4OutputDataSeries sellMq4Output;

		int _indicatorCounted;
		int _currentIndex;

		CachedStandardIndicators _cachedStandardIndicators;
		Mq4ChartObjects _mq4ChartObjects;
		Mq4ArrayToDataSeriesConverterFactory _mq4ArrayToDataSeriesConverterFactory;
		Mq4MarketDataSeries Open;
		Mq4MarketDataSeries High;
		Mq4MarketDataSeries Low;
		Mq4MarketDataSeries Close;
		Mq4MarketDataSeries Median;
		Mq4MarketDataSeries Volume;

		new Mq4TimeSeries  Time;

		static Dictionary<int, string> ArrowByIndex = new Dictionary<int, string>
			{ { 0, MQ4Const.xArrow }, { 1, MQ4Const.xArrow }, { 2, MQ4Const.xArrow }, { 3, MQ4Const.xArrow }, { 4, MQ4Const.xArrow }, { 5, MQ4Const.xArrow }, { 6, MQ4Const.xArrow }, { 7, MQ4Const.xArrow } };

		static List<Mq4OutputDataSeries> AllBuffers = new List<Mq4OutputDataSeries>();

		List<DataSeries> AllOutputDataSeries = new List<DataSeries>();

		#endregion

		protected override void Initialize()
		{
			if (tradeActionIndicatorDataSeries == null)
				tradeActionIndicatorDataSeries = CreateDataSeries();
			tradeActionMq4Output = new Mq4OutputDataSeries(this, tradeActionIndicatorDataSeries, ChartObjects, 0, 0, () => CreateDataSeries(), 2, Colors.Blue);
			AllBuffers.Add(tradeActionMq4Output);

			if (standIndicatorDataSeries == null)
				standIndicatorDataSeries = CreateDataSeries();
			standMq4Output = new Mq4OutputDataSeries(this, standIndicatorDataSeries, ChartObjects, 0, 0, () => CreateDataSeries(), 2, Colors.Yellow);
			AllBuffers.Add(standMq4Output);

			if (buyIndicatorDataSeries == null)
				buyIndicatorDataSeries = CreateDataSeries();
			buyMq4Output = new Mq4OutputDataSeries(this, buyIndicatorDataSeries, ChartObjects, 0, 1, () => CreateDataSeries(), 2, Colors.Green);
			AllBuffers.Add(buyMq4Output);

			if (sellIndicatorDataSeries == null)
				sellIndicatorDataSeries = CreateDataSeries();
			sellMq4Output = new Mq4OutputDataSeries(this, sellIndicatorDataSeries, ChartObjects, 0, 2, () => CreateDataSeries(), 2, Colors.Orange);
			AllBuffers.Add(sellMq4Output);

			AllOutputDataSeries.Add(standIndicatorDataSeries);
			AllOutputDataSeries.Add(buyIndicatorDataSeries);
			AllOutputDataSeries.Add(sellIndicatorDataSeries);

			Open = new Mq4MarketDataSeries(MarketSeries.Open);
			High = new Mq4MarketDataSeries(MarketSeries.High);
			Low = new Mq4MarketDataSeries(MarketSeries.Low);
			Close = new Mq4MarketDataSeries(MarketSeries.Close);
			Volume = new Mq4MarketDataSeries(MarketSeries.TickVolume);
			Median = new Mq4MarketDataSeries(MarketSeries.Median);
			Time = new Mq4TimeSeries(MarketSeries.OpenTime);

			_cachedStandardIndicators = new CachedStandardIndicators(Indicators);
			_mq4ChartObjects = new Mq4ChartObjects(ChartObjects, MarketSeries.OpenTime);
			_mq4ArrayToDataSeriesConverterFactory = new Mq4ArrayToDataSeriesConverterFactory(() => CreateDataSeries());

		}

		Mq4Double calculateZigzagKwanMBFXTiming()
		{
			Mq4Double index = 0;
			Mq4Double debut = 0;
			Mq4Double ld_208 = 0;
			Mq4Double ld_200 = 0;
			Mq4Double ld_192 = 0;
			Mq4Double ld_184 = 0;
			Mq4Double ld_176 = 0;
			Mq4Double ld_168 = 0;
			Mq4Double ld_160 = 0;
			Mq4Double ld_152 = 0;
			Mq4Double ld_144 = 0;
			Mq4Double ld_136 = 0;
			Mq4Double ld_128 = 0;
			Mq4Double ld_120 = 0;
			Mq4Double ld_112 = 0;
			Mq4Double coFactor = 0;
			Mq4Double factor = 0;
			Mq4Double oldAverage = 0;
			Mq4Double average = 0;
			Mq4Double ld_72 = 0;
			Mq4Double ld_64 = 0;
			Mq4Double ld_56 = 0;
			Mq4Double ld_48 = 0;
			Mq4Double ld_40 = 0;
			Mq4Double priceProgression = 0;
			Mq4Double result = 0;
			Mq4Double secondCycle = 0;
			Mq4Double firstCycle = 0;
			Mq4Double lenBase = 0;

			debut = MarketSeries.Close.Count - len - 1;
			for (index = debut; index >= 0; index--)
			{
				if (firstCycle == 0.0)
				{
					firstCycle = 1.0;
					secondCycle = 0.0;

					lenBase = Math.Max(len - 1.0,5);

					average = 100.0 * ((High[index] + Low[index] + Close[index]) / 3.0);
					factor = 3.0 / (len + 2.0);
					coFactor = 1.0 - factor;
				}
				else
				{
					firstCycle = (firstCycle < lenBase) ? firstCycle+1 : lenBase + 1.0 ;

					oldAverage = average;
					average = 100.0 * ((High[index] + Low[index] + Close[index]) / 3.0);
					priceProgression = average - oldAverage;

					ld_112 = coFactor * ld_112 + factor * priceProgression;
					ld_120 = factor * ld_112 + coFactor * ld_120;
					ld_40 = 1.5 * ld_112 - ld_120 / 2.0;

					ld_128 = coFactor * ld_128 + factor * ld_40;
					ld_208 = factor * ld_128 + coFactor * ld_208;
					ld_48 = 1.5 * ld_128 - ld_208 / 2.0;

					ld_136 = coFactor * ld_136 + factor * ld_48;
					ld_152 = factor * ld_136 + coFactor * ld_152;
					ld_56 = 1.5 * ld_136 - ld_152 / 2.0;

					ld_160 = coFactor * ld_160 + factor * Math.Abs((double)priceProgression);
					ld_168 = factor * ld_160 + coFactor * ld_168;
					ld_64 = 1.5 * ld_160 - ld_168 / 2.0;

					ld_176 = coFactor * ld_176 + factor * ld_64;
					ld_184 = factor * ld_176 + coFactor * ld_184;
					ld_144 = 1.5 * ld_176 - ld_184 / 2.0;

					ld_192 = coFactor * ld_192 + factor * ld_144;
					ld_200 = factor * ld_192 + coFactor * ld_200;
					ld_72 = 1.5 * ld_192 - ld_200 / 2.0;

					if (firstCycle <= lenBase && average != oldAverage)
						secondCycle = 1.0;

					if (firstCycle == lenBase  && secondCycle == 0.0)
						firstCycle = 0.0;
				}

				if (firstCycle > lenBase && ld_72 > 1E-10)
				{
					result = 50.0 * (ld_56 / ld_72 + 1.0);

					if (result > 100.0)
						result = 100.0;

					if (result < 0.0)
						result = 0.0;
				}
				else
					result = 50.0;

				standMq4Output[index] = result;
				buyMq4Output[index] = result;
				sellMq4Output[index] = result;
				tradeActionMq4Output[index] = tradeActionNeutral;

				if (standMq4Output[index] > standMq4Output[index + 1] - filter)
				{
					sellMq4Output[index] = MQ4Const.EMPTY_VALUE;
					tradeActionMq4Output[index] = tradeActionNeutral+ ceilTradeAction;
				}
				else if (standMq4Output[index] < standMq4Output[index + 1] + filter)
				{
					buyMq4Output[index] = MQ4Const.EMPTY_VALUE;
					tradeActionMq4Output[index] += tradeActionNeutral - ceilTradeAction;

				}
				else if (standMq4Output[index] == standMq4Output[index + 1] + filter)
				{
					buyMq4Output[index] = MQ4Const.EMPTY_VALUE;
					sellMq4Output[index] = MQ4Const.EMPTY_VALUE;
					tradeActionMq4Output[index] = tradeActionNeutral;
				}
			}
			return 0;
		}

		public override void Calculate(int index)
		{
			try
			{
				_currentIndex = index;
				tradeActionMq4Output.CurrentIndex = index;
				standMq4Output.CurrentIndex= index;
				buyMq4Output.CurrentIndex=index;
				sellMq4Output.CurrentIndex=index;

				if (IsLastBar)
				{
					calculateZigzagKwanMBFXTiming();
					_indicatorCounted = index;
				}
			}
			catch (Exception e)
			{
				if (e.Source != null)
					Console.WriteLine("IOException source: {0}", e.Source);
				throw;
			}
		}


		public class Mq4OutputDataSeries : IMq4Array<Mq4Double>
		{
			public IndicatorDataSeries OutputDataSeries { get; private set; }
			private readonly IndicatorDataSeries _originalValues;

			private readonly ChartObjects _chartObjects;
			private readonly int _style;
			private readonly int _bufferIndex;
			private readonly Indicator _indicator;

			public Mq4OutputDataSeries(ZigzagKwanMBFXTiming zigzagKwanMBFXTiming, IndicatorDataSeries outputDataSeries, ChartObjects chartObjects, int style, int bufferIndex, Func<IndicatorDataSeries> dataSeriesFactory, int lineWidth, Colors? color = null)
			{
				OutputDataSeries = outputDataSeries;
				_chartObjects = chartObjects;
				_style = style;
				_bufferIndex = bufferIndex;
				_indicator = zigzagKwanMBFXTiming;
				Color = color;
				_originalValues = dataSeriesFactory();
				LineWidth = lineWidth;
			}

			public int LineWidth { get; private set; }
			public Colors? Color { get; private set; }

			public int Length
			{
				get { return OutputDataSeries.Count; }
			}

			public int CurrentIndex
			{
				get;
				set;
			}

			public int Shift
			{
				get;
				set;
			}

			public Mq4Double this[int index]
			{
				get
				{
					var indexToGetFrom = CurrentIndex - index + Shift;
					if (indexToGetFrom < 0 || indexToGetFrom > CurrentIndex)
						return 0;
					if (indexToGetFrom >= _originalValues.Count)
						return MQ4Const.EMPTY_VALUE;

					return _originalValues[indexToGetFrom];
				}
				set
				{
					var indexToSet = CurrentIndex - index + Shift;
					if (indexToSet < 0)
						return;

					_originalValues[indexToSet] = value;

					var valueToSet = value;
					if (valueToSet == MQ4Const.EMPTY_VALUE)
						valueToSet = double.NaN;

					if (indexToSet < 0)
						return;

					OutputDataSeries[indexToSet] = valueToSet;

					switch (_style)
					{
						case MQ4Const.DRAW_ARROW:
							var arrowName = GetArrowName(indexToSet);
							if (double.IsNaN(valueToSet))
								_chartObjects.RemoveObject(arrowName);
							else
							{
								var color = Color.HasValue ? Color.Value : Colors.Red;
								_chartObjects.DrawText(arrowName, ArrowByIndex[_bufferIndex], indexToSet, valueToSet, VerticalAlignment.Center, HorizontalAlignment.Center, color);
							}
							break;
						case MQ4Const.DRAW_HISTOGRAM:
							//if (false)
							{
								var anotherLine = AllBuffers.FirstOrDefault(b => b.LineWidth == LineWidth && b != this);
								if (anotherLine != null)
								{
									var name = GetNameOfHistogramLineOnChartWindow(indexToSet);
									Colors color;
									if (this[index] > anotherLine[index])
										color = Color ?? Colors.Green;
									else
										color = anotherLine.Color ?? Colors.Green;
									var lineWidth = LineWidth;
									if (lineWidth != 1 && lineWidth < 5)
										lineWidth = 5;

									_chartObjects.DrawLine(name, indexToSet, this[index], indexToSet, anotherLine[index], color, lineWidth);
								}
							}
							break;
					}
				}
			}

			private string GetNameOfHistogramLineOnChartWindow(int index)
			{
				return string.Format("Histogram on chart window {0} {1}", LineWidth, index);
			}

			private string GetArrowName(int index)
			{
				return string.Format("Arrow {0} {1}", GetHashCode(), index);
			}


		}

	}

}
AL
aleandroiacovelli

Joined 08.01.2015

  • Type: Free
  • Language: C#
  • Trading Platform: cTrader Automate
  • Filename: ZigzagKwanMBFXTiming.algo
  • Rating: 0
  • Downloads: 3407

Download
Comments
Only logged in users can post a comment
Comments not found
 
Copyright © 2023 Spotware Systems Ltd. All rights reserved.
The services provided by Spotware Systems Ltd. are not available to citizens or residents of the USA. Neither is the information on our websites directed toward soliciting citizens or residents of the USA.