 |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
The Zig Zag indicator is extremely useful for determining price trends, support and resistance areas, and classic chart patterns like head and shoulders, double bottoms and double tops. Zig Zag demonstrates past performance trends and only the most important changes. It filters out all changes less than a specified amount. First, the Zig Zag indicator is used to help you watch changes by highlighting the most essential reversals.
Zig Zag indicator calculation:
Highs - When a price (usually close) is both higher than the price previous to it and after it.
Lows - When a price is both lower than the price prior to it and lower than the price following it.
Meta Trader 4 - Zig Zag indicator /MQL 4 Code Base (Copy Code)/
//+------------------------------------------------------------------+ //| Zig Zag.mq4 | //| Copyright © 2005-2007, MetaQuotes Software Corp. | //| http://plusforex.blogspot.com | //+------------------------------------------------------------------+ Definition of Zig Zag Indicator - read more at: http://plusforex.blogspot.sk/2012/07/zig-zag-indicator.html #property copyright "Copyright © 2007, MetaQuotes Software Corp." #property link "http://plusforex.blogspot.com/" #property indicator_chart_window #property indicator_buffers 1 #property indicator_color1 Red //---- indicator parameters extern int ExtDepth=12; extern int ExtDeviation=5; extern int ExtBackstep=3; //---- indicator buffers double ZigzagBuffer[]; double HighMapBuffer[]; double LowMapBuffer[]; int level=3; // recounting's depth bool downloadhistory=false; //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { IndicatorBuffers(3); //---- drawing settings SetIndexStyle(0,DRAW_SECTION); //---- indicator buffers mapping SetIndexBuffer(0,ZigzagBuffer); SetIndexBuffer(1,HighMapBuffer); SetIndexBuffer(2,LowMapBuffer); SetIndexEmptyValue(0,0.0); //---- indicator short name IndicatorShortName("ZigZag plusforex.blogspot.com("+ExtDepth+","+ExtDeviation+","+ExtBac kstep+")"); //---- initialization done return(0); } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ int start() { int i, counted_bars = IndicatorCounted(); int limit,counterZ,whatlookfor; int shift,back,lasthighpos,lastlowpos; double val,res; double curlow,curhigh,lasthigh,lastlow; if (counted_bars==0 && downloadhistory) // history was downloaded { ArrayInitialize(ZigzagBuffer,0.0); ArrayInitialize(HighMapBuffer,0.0); ArrayInitialize(LowMapBuffer,0.0); } if (counted_bars==0) { limit=Bars-ExtDepth; downloadhistory=true; } if (counted_bars>0) { while (counterZ<level && i<100) { res=ZigzagBuffer[i]; if (res!=0) counterZ++; i++; } i--; limit=i; if (LowMapBuffer[i]!=0) { curlow=LowMapBuffer[i]; whatlookfor=1; } else { curhigh=HighMapBuffer[i]; whatlookfor=-1; } for (i=limit-1;i>=0;i--) { ZigzagBuffer[i]=0.0; LowMapBuffer[i]=0.0; HighMapBuffer[i]=0.0; } } for(shift=limit; shift>=0; shift--) { val=Low[iLowest(NULL,0,MODE_LOW,ExtDepth,shift)]; if(val==lastlow) val=0.0; else { lastlow=val; if((Low[shift]-val)>(ExtDeviation*Point)) val=0.0; else { for(back=1; back<=ExtBackstep; back++) { res=LowMapBuffer[shift+back]; if((res!=0)&&(res>val)) LowMapBuffer[shift+back]=0.0; } } } if (Low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0; //--- high val=High[iHighest(NULL,0,MODE_HIGH,ExtDepth,shift)]; if(val==lasthigh) val=0.0; else { lasthigh=val; if((val-High[shift])>(ExtDeviation*Point)) val=0.0; else { for(back=1; back<=ExtBackstep; back++) { res=HighMapBuffer[shift+back]; if((res!=0)&&(res<val)) HighMapBuffer[shift+back]=0.0; } } } if (High[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0; } // final cutting if (whatlookfor==0) { lastlow=0; lasthigh=0; } else { lastlow=curlow; lasthigh=curhigh; } for (shift=limit;shift>=0;shift--) { res=0.0; switch(whatlookfor) { case 0: // look for peak or lawn if (lastlow==0 && lasthigh==0) { if (HighMapBuffer[shift]!=0) { lasthigh=High[shift]; lasthighpos=shift; whatlookfor=-1; ZigzagBuffer[shift]=lasthigh; res=1; } if (LowMapBuffer[shift]!=0) { lastlow=Low[shift]; lastlowpos=shift; whatlookfor=1; ZigzagBuffer[shift]=lastlow; res=1; } } break; case 1: // look for peak if (LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0) { ZigzagBuffer[lastlowpos]=0.0; lastlowpos=shift; lastlow=LowMapBuffer[shift]; ZigzagBuffer[shift]=lastlow; res=1; } if (HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0) { lasthigh=HighMapBuffer[shift]; lasthighpos=shift; ZigzagBuffer[shift]=lasthigh; whatlookfor=-1; res=1; } break; case -1: // look for lawn if (HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0) { ZigzagBuffer[lasthighpos]=0.0; lasthighpos=shift; lasthigh=HighMapBuffer[shift]; ZigzagBuffer[shift]=lasthigh; } if (LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0) { lastlow=LowMapBuffer[shift]; lastlowpos=shift; ZigzagBuffer[shift]=lastlow; whatlookfor=1; } break; default: return; } } return(0); } //+------------------------------------------------------------------+
MetaTrader 5 - Zig Zag indicator /MQL5 Code Base (Copy Code)/
//+------------------------------------------------------------------+
//| ZigZag.mq5 |
//| Copyright 2009, MetaQuotes Software Corp. |
//| http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2009, MetaQuotes Software Corp."
#property link "http://www.mql5.com"
#property version "1.00"
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_plots 1
//---- plot Zigzag
#property indicator_label1 "Zigzag"
#property indicator_type1 DRAW_SECTION
#property indicator_color1 Red
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//--- input parameters
input int ExtDepth=12;
input int ExtDeviation=5;
input int ExtBackstep=3;
//--- indicator buffers
double ZigzagBuffer[]; // main buffer
double HighMapBuffer[]; // highs
double LowMapBuffer[]; // lows
int level=3; // recounting depth
double deviation; // deviation in points
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- indicator buffers mapping
SetIndexBuffer(0,ZigzagBuffer,INDICATOR_DATA);
SetIndexBuffer(1,HighMapBuffer,INDICATOR_CALCULATIONS);
SetIndexBuffer(2,LowMapBuffer,INDICATOR_CALCULATIONS);
//--- set short name and digits
PlotIndexSetString(0,PLOT_LABEL,"ZigZag("+(string)ExtDepth+","+(string)ExtDeviation+","+(string)ExtBackstep+")");
IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
//--- set empty value
PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
//--- to use in cycle
deviation=ExtDeviation*_Point;
//---
return(0);
}
//+------------------------------------------------------------------+
//| searching index of the highest bar |
//+------------------------------------------------------------------+
int iHighest(const double &array[],
int depth,
int startPos)
{
int index=startPos;
//--- start index validation
if(startPos<0)
{
Print("Invalid parameter in the function iHighest, startPos =",startPos);
return 0;
}
int size=ArraySize(array);
//--- depth correction if need
if(startPos-depth<0) depth=startPos;
double max=array[startPos];
//--- start searching
for(int i=startPos;i>startPos-depth;i--)
{
if(array[i]>max)
{
index=i;
max=array[i];
}
}
//--- return index of the highest bar
return(index);
}
//+------------------------------------------------------------------+
//| searching index of the lowest bar |
//+------------------------------------------------------------------+
int iLowest(const double &array[],
int depth,
int startPos)
{
int index=startPos;
//--- start index validation
if(startPos<0)
{
Print("Invalid parameter in the function iLowest, startPos =",startPos);
return 0;
}
int size=ArraySize(array);
//--- depth correction if need
if(startPos-depth<0) depth=startPos;
double min=array[startPos];
//--- start searching
for(int i=startPos;i>startPos-depth;i--)
{
if(array[i]<min)
{
index=i;
min=array[i];
}
}
//--- return index of the lowest bar
return(index);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
int i=0;
int limit=0,counterZ=0,whatlookfor=0;
int shift=0,back=0,lasthighpos=0,lastlowpos=0;
double val=0,res=0;
double curlow=0,curhigh=0,lasthigh=0,lastlow=0;
//--- auxiliary enumeration
enum looling_for
{
Pike=1, // searching for next high
Sill=-1 // searching for next low
};
//--- initializing
if(prev_calculated==0)
{
ArrayInitialize(ZigzagBuffer,0.0);
ArrayInitialize(HighMapBuffer,0.0);
ArrayInitialize(LowMapBuffer,0.0);
}
//---
if(rates_total<100) return(0);
//--- set start position for calculations
if(prev_calculated==0) limit=ExtDepth;
//--- ZigZag was already counted before
if(prev_calculated>0)
{
i=rates_total-1;
//--- searching third extremum from the last uncompleted bar
while(counterZ<level && i>rates_total-100)
{
res=ZigzagBuffer[i];
if(res!=0) counterZ++;
i--;
}
i++;
limit=i;
//--- what type of exremum we are going to find
if(LowMapBuffer[i]!=0)
{
curlow=LowMapBuffer[i];
whatlookfor=Pike;
}
else
{
curhigh=HighMapBuffer[i];
whatlookfor=Sill;
}
//--- chipping
for(i=limit+1;i<rates_total && !IsStopped();i++)
{
ZigzagBuffer[i]=0.0;
LowMapBuffer[i]=0.0;
HighMapBuffer[i]=0.0;
}
}
//--- searching High and Low
for(shift=limit;shift<rates_total && !IsStopped();shift++)
{
val=low[iLowest(low,ExtDepth,shift)];
if(val==lastlow) val=0.0;
else
{
lastlow=val;
if((low[shift]-val)>deviation) val=0.0;
else
{
for(back=1;back<=ExtBackstep;back++)
{
res=LowMapBuffer[shift-back];
if((res!=0) && (res>val)) LowMapBuffer[shift-back]=0.0;
}
}
}
if(low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;
//--- high
val=high[iHighest(high,ExtDepth,shift)];
if(val==lasthigh) val=0.0;
else
{
lasthigh=val;
if((val-high[shift])>deviation) val=0.0;
else
{
for(back=1;back<=ExtBackstep;back++)
{
res=HighMapBuffer[shift-back];
if((res!=0) && (res<val)) HighMapBuffer[shift-back]=0.0;
}
}
}
if(high[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;
}
//--- last preparation
if(whatlookfor==0)// uncertain quantity
{
lastlow=0;
lasthigh=0;
}
else
{
lastlow=curlow;
lasthigh=curhigh;
}
//--- final rejection
for(shift=limit;shift<rates_total && !IsStopped();shift++)
{
res=0.0;
switch(whatlookfor)
{
case 0: // search for peak or lawn
if(lastlow==0 && lasthigh==0)
{
if(HighMapBuffer[shift]!=0)
{
lasthigh=high[shift];
lasthighpos=shift;
whatlookfor=Sill;
ZigzagBuffer[shift]=lasthigh;
res=1;
}
if(LowMapBuffer[shift]!=0)
{
lastlow=low[shift];
lastlowpos=shift;
whatlookfor=Pike;
ZigzagBuffer[shift]=lastlow;
res=1;
}
}
break;
case Pike: // search for peak
if(LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)
{
ZigzagBuffer[lastlowpos]=0.0;
lastlowpos=shift;
lastlow=LowMapBuffer[shift];
ZigzagBuffer[shift]=lastlow;
res=1;
}
if(HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)
{
lasthigh=HighMapBuffer[shift];
lasthighpos=shift;
ZigzagBuffer[shift]=lasthigh;
whatlookfor=Sill;
res=1;
}
break;
case Sill: // search for lawn
if(HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
{
ZigzagBuffer[lasthighpos]=0.0;
lasthighpos=shift;
lasthigh=HighMapBuffer[shift];
ZigzagBuffer[shift]=lasthigh;
}
if(LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)
{
lastlow=LowMapBuffer[shift];
lastlowpos=shift;
ZigzagBuffer[shift]=lastlow;
whatlookfor=Pike;
}
break;
default: return(rates_total);
}
}
//--- return value of prev_calculated for next call
return(rates_total);
}
//+------------------------------------------------------------------+
Some content tab 3
FXCM Trading Station - Zig Zag indicator /LUA Code Base (Copy Code)/
-- Indicator profile initialization routine
function Init()
indicator:name("ZigZag - plusforex.blogspot.com");
indicator:description("");
indicator:requiredSource(core.Tick);
indicator:type(core.Indicator);
indicator.parameters:addInteger("Depth", "Depth", "the minimal amount of bars where there will not be the second maximum", 12);
indicator.parameters:addInteger("Deviation", "Deviation", "Distance in pips to eliminate the second maximum in the last Depth periods", 5);
indicator.parameters:addInteger("Backstep", "Backstep", "The minimal amount of bars between maximums/minimums", 3);
indicator.parameters:addColor("ZigZag_color", "Color of ZigZag", "Color of ZigZag", core.rgb(255, 0, 0));
end
-- Indicator instance initialization routine
-- Processes indicator parameters and creates output streams
-- Parameters block
local Depth;
local Deviation;
local Backstep;
local first;
local source = nil;
-- Streams block
local ZigZag = nil;
local HighMap = nil;
local LowMap = nil;
-- Routine
function Prepare()
Depth = instance.parameters.Depth;
Deviation = instance.parameters.Deviation;
Backstep = instance.parameters.Backstep;
source = instance.source;
first = source:first();
local name = profile:id() .. "(" .. source:name() .. ", " .. Depth .. ", " .. Deviation .. ", " .. Backstep .. ")";
instance:name(name);
ZigZag = instance:addStream("ZigZag", core.Line, name, "ZigZag", instance.parameters.ZigZag_color, first);
HighMap = instance:addInternalStream(0, 0);
LowMap = instance:addInternalStream(0, 0);
end
local searchBoth = 0;
local searchPeak = 1;
local searchLawn = -1;
local lastlow = nil;
local lashhigh = nil;
-- optimization hint
local g_last_peak_date = nil;
local g_last_peak = nil;
local g_prev_peak_date = nil;
local g_searchMode = nil;
function Update(period, mode)
if period <= first + Depth then
-- inital calculation or re-calculation appeared
lastlow = nil;
lasthigh = nil;
g_last_peak_date = nil;
g_last_peak = nil;
g_prev_peak_date = nil;
g_searchMode = nil;
else
-- fill high/low maps
local range = core.rangeTo(period, Depth);
local val;
local i;
-- get the lowest low for the last depth periods
val = core.min(source, range);
if val == lastlow then
-- if lowest low is not changed - ignore it
val = nil;
else
-- keep it
lastlow = val;
-- if current low is higher for more than Deviation pips, ignore
if (source[period] - val) > (source:pipSize() * Deviation) then
val = nil;
else
-- check for the previous backstep lows
for i = period - 1, period - Backstep + 1, -1 do
if (LowMap[i] ~= 0) and (LowMap[i] > val) then
LowMap[i] = nil;
end
end
end
end
if source[period] == val then
LowMap[period] = val;
else
LowMap[period] = 0;
end
-- get the lowest low for the last depth periods
val = core.max(source, range);
if val == lasthigh then
-- if lowest low is not changed - ignore it
val = nil;
else
-- keep it
lasthigh = val;
-- if current low is higher for more than Deviation pips, ignore
if (val - source[period]) > (source:pipSize() * Deviation) then
val = nil;
else
-- check for the previous backstep lows
for i = period - 1, period - Backstep + 1, -1 do
if (HighMap[i] ~= 0) and (HighMap[i] < val) then
HighMap[i] = nil;
end
end
end
end
if source[period] == val then
HighMap[period] = val;
else
HighMap[period] = 0
end
local start;
local last_peak;
local last_peak_i;
local prev_peak;
last_peak = nil;
last_peak_i = nil;
prev_peak = nil;
local searchMode = searchBoth;
start = Depth;
if (g_last_peak_date ~= nil) then
for i = period, 0, -1 do
if source:date(i) == g_last_peak_date then
last_peak_i = i;
last_peak = g_last_peak;
start = i;
searchMode = g_searchMode;
if (g_prev_peak_date == nil) then
break;
end
end
if (source:date(i) == g_prev_peak_date) then
prev_peak = i;
break;
end
if (g_prev_peak_date ~= nil and source:date(i) < g_prev_peak_date) then
break;
end
end
end
for i = start, period, 1 do
if searchMode == searchBoth then
if (HighMap[i] ~= 0) then
last_peak_i = i;
last_peak = HighMap[i];
searchMode = searchLawn;
elseif (LowMap[i] ~= 0) then
last_peak_i = i;
last_peak = LowMap[i];
searchMode = searchPeak;
end
elseif searchMode == searchPeak then
if (LowMap[i] ~= 0 and LowMap[i] < last_peak) then
last_peak = LowMap[i];
last_peak_i = i;
if prev_peak ~= nil then
core.drawLine(ZigZag, core.range(prev_peak, i), ZigZag[prev_peak], prev_peak, LowMap[i], i);
end
end
if HighMap[i] ~= 0 and LowMap[i] == 0 then
core.drawLine(ZigZag, core.range(last_peak_i, i), last_peak, last_peak_i, HighMap[i], i);
prev_peak = last_peak_i;
last_peak = HighMap[i];
last_peak_i = i;
searchMode = searchLawn;
end
elseif searchMode == searchLawn then
if (HighMap[i] ~= 0 and HighMap[i] > last_peak) then
last_peak = HighMap[i];
last_peak_i = i;
if prev_peak ~= nil then
core.drawLine(ZigZag, core.range(prev_peak, i), ZigZag[prev_peak], prev_peak, HighMap[i], i);
end
end
if LowMap[i] ~= 0 and HighMap[i] == 0 then
core.drawLine(ZigZag, core.range(last_peak_i, i), last_peak, last_peak_i, LowMap[i], i);
prev_peak = last_peak_i;
last_peak = LowMap[i];
last_peak_i = i;
searchMode = searchPeak;
end
end
end
if (last_peak_i ~= nil) then
g_last_peak_date = source:date(last_peak_i)
end
if (prev_peak ~= nil) then
g_prev_peak_date = source:date(prev_peak)
end
g_searchMode = searchMode;
g_last_peak = last_peak;
end
end
cTrader - Zig Zag indicator /cAlgo Code Base (Copy Code)/
using System;
using cAlgo.API;
using cAlgo.API.Internals;
namespace cAlgo.Indicators
{
[Indicator(IsOverlay = true)]
public class ZigZag : Indicator
{
[Parameter(DefaultValue = 12)]
public int Depth { get; set; }
[Parameter(DefaultValue = 5)]
public int Deviation { get; set; }
[Parameter(DefaultValue = 3)]
public int BackStep { get; set; }
[Output("ZigZag", Color = Colors.OrangeRed)]
public IndicatorDataSeries Result { get; set; }
#region Private fields
private double _lastLow;
private double _lastHigh;
private double _low;
private double _high;
private int _lastHighIndex;
private int _lastLowIndex;
private int _type;
private double _point;
private double _currentLow;
private double _currentHigh;
private IndicatorDataSeries _highZigZags;
private IndicatorDataSeries _lowZigZags;
#endregion
protected override void Initialize()
{
_highZigZags = CreateDataSeries();
_lowZigZags = CreateDataSeries();
_point = Symbol.PointSize;
}
public override void Calculate(int index)
{
if (index < Depth)
{
Result[index] = 0;
_highZigZags[index] = 0;
_lowZigZags[index] = 0;
return;
}
_currentLow = Functions.Minimum(MarketSeries.Low, Depth);
if (Math.Abs(_currentLow - _lastLow) < double.Epsilon)
_currentLow = 0.0;
else
{
_lastLow = _currentLow;
if ((MarketSeries.Low[index] - _currentLow) > (Deviation * _point))
_currentLow = 0.0;
else
{
for (int i = 1; i <= BackStep; i++)
{
if (Math.Abs(_lowZigZags[index - i]) > double.Epsilon && _lowZigZags[index - i] > _currentLow)
_lowZigZags[index - i] = 0.0;
}
}
}
if (Math.Abs(MarketSeries.Low[index] - _currentLow) < double.Epsilon)
_lowZigZags[index] = _currentLow;
else
_lowZigZags[index] = 0.0;
_currentHigh = MarketSeries.High.Maximum(Depth);
if (Math.Abs(_currentHigh - _lastHigh) < double.Epsilon)
_currentHigh = 0.0;
else
{
_lastHigh = _currentHigh;
if ((_currentHigh - MarketSeries.High[index]) > (Deviation * _point))
_currentHigh = 0.0;
else
{
for (int i = 1; i <= BackStep; i++)
{
if (Math.Abs(_highZigZags[index - i]) > double.Epsilon && _highZigZags[index - i] < _currentHigh)
_highZigZags[index - i] = 0.0;
}
}
}
if (Math.Abs(MarketSeries.High[index] - _currentHigh) < double.Epsilon)
_highZigZags[index] = _currentHigh;
else
_highZigZags[index] = 0.0;
switch (_type)
{
case 0:
if (Math.Abs(_low - 0) < double.Epsilon && Math.Abs(_high - 0) < double.Epsilon)
{
if (Math.Abs(_highZigZags[index]) > double.Epsilon)
{
_high = MarketSeries.High[index];
_lastHighIndex = index;
_type = -1;
Result[index] = _high;
}
if (Math.Abs(_lowZigZags[index]) > double.Epsilon)
{
_low = MarketSeries.Low[index];
_lastLowIndex = index;
_type = 1;
Result[index] = _low;
}
}
break;
case 1:
if (Math.Abs(_lowZigZags[index]) > double.Epsilon && _lowZigZags[index] < _low && Math.Abs(_highZigZags[index] - 0.0) < double.Epsilon)
{
Result[_lastLowIndex] = double.NaN;
_lastLowIndex = index;
_low = _lowZigZags[index];
Result[index] = _low;
}
if (Math.Abs(_highZigZags[index] - 0.0) > double.Epsilon && Math.Abs(_lowZigZags[index] - 0.0) < double.Epsilon)
{
_high = _highZigZags[index];
_lastHighIndex = index;
Result[index] = _high;
_type = -1;
}
break;
case -1:
if (Math.Abs(_highZigZags[index]) > double.Epsilon && _highZigZags[index] > _high && Math.Abs(_lowZigZags[index] - 0.0) < double.Epsilon)
{
Result[_lastHighIndex] = double.NaN;
_lastHighIndex = index;
_high = _highZigZags[index];
Result[index] = _high;
}
if (Math.Abs(_lowZigZags[index]) > double.Epsilon && Math.Abs(_highZigZags[index]) <= double.Epsilon)
{
_low = _lowZigZags[index];
_lastLowIndex = index;
Result[index] = _low;
_type = 1;
}
break;
default:
return;
}
}
}
}
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
 |
| Zig Zag Indicator |
