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);
}
}
}
}
aleandroiacovelli
Joined on 08.01.2015
- Distribution: Free
- Language: C#
- Trading platform: cTrader Automate
- File name: ZigzagKwanMBFXTiming.algo
- Rating: 0
- Installs: 3717
