Description
Follow my cTrader Telegram group at https://t.me/cTraderCommunity; it's a new community but it will grow fast, plus everyone can talk about cTrader indicators and algorithm without restrictions, though it is not allowed to spam commercial indicators to sell them.
This is a harmonic pattern scanner, it is completely free and has both live and backtesting mode.
Please note that this scanner will find EVERY pattern that meets the required conditions, the 'Magnitude' parameter is just a filter for the amplitude of the pattern based on volatility.
Patterns are color-coded in this way: orange for gartleys, cyan for cyphers, purple for bats and green for butterflies.
If too many patterns are shown, you can use the settings to focus on the ones you want to analyze.
For help, comment or ask me directly on the telegram group linked above.
using System;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;
using cAlgo.Indicators;
namespace cAlgo
{
[Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class Harmonics : Indicator
{
[Parameter("Max Lenght", DefaultValue = 150)]
public int max_len { get; set; }
[Parameter("Magnitude", DefaultValue = 2, Step = 0.1)]
public double atr_mul { get; set; }
[Parameter("Gartleys", DefaultValue = true)]
public bool gar { get; set; }
[Parameter("Bats", DefaultValue = true)]
public bool bat { get; set; }
[Parameter("Cyphers", DefaultValue = true)]
public bool cyph { get; set; }
[Parameter("Butterflys", DefaultValue = false)]
public bool butt { get; set; }
[Parameter("Backtest Mode", DefaultValue = false)]
public bool bckt { get; set; }
[Parameter("Bull / Bear / Both", DefaultValue = "both")]
public string dir { get; set; }
private ZigZagAndFiboLevels zz;
protected override void Initialize()
{
double atr = 100 * atr_mul * Indicators.SimpleMovingAverage(Indicators.AverageTrueRange(200, MovingAverageType.Exponential).Result, 200).Result.LastValue / MarketSeries.Close.LastValue;
zz = Indicators.GetIndicator<ZigZagAndFiboLevels>(atr, false, false, false);
Print(atr);
}
public override void Calculate(int index)
{
if (!IsLastBar)
return;
if (!bckt)
{
if (gar)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBearishGartley(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBullishGartley(index);
}
if (bat)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBearishBat(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBullishBat(index);
}
if (cyph)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBearishCypher(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBullishCypher(index);
}
if (butt)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBearishButterfly(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBullishButterfly(index);
}
}
else if (bckt)
{
if (gar)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBacktestingBearishGartley(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBacktestingBullishGartley(index);
}
if (bat)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBacktestingBearishBat(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBacktestingBullishBat(index);
}
if (cyph)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBacktestingBearishCypher(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBacktestingBullishCypher(index);
}
if (butt)
{
if (dir == "both" || dir == "Both" || dir == "bear" || dir == "Bear")
LookForBacktestingBearishButterfly(index);
if (dir == "both" || dir == "Both" || dir == "bull" || dir == "Bull")
LookForBacktestingBullishButterfly(index);
}
}
}
private void LookForBearishGartley(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= 0.786 * XA_len)
break;
#endregion
else if (AB_len >= 0.618 * XA_len && AB_len < 0.786 * XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[j] || zz.Value[l] < zz.Value[k])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.618 * AB_len && BC_len < AB_len)
{
Chart.DrawTriangle("Bearish_Gartley_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Orange, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Gartley_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[k] + 0.786 * XA_len, Color.Orange, 1, LineStyle.DotsRare);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.Low[verify] < zz.Value[l])
{
Chart.RemoveObject("Bearish_Gartley_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Gartley_ala_dx" + i + j + k + l);
}
if (MarketSeries.High[verify] >= zz.Value[i])
{
Chart.RemoveObject("Bearish_Gartley_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Gartley_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBullishGartley(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un massimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che X sia più basso di A
if (zz.Value[i] >= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di X e nessun massimo maggiore di A
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un minimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di B e nessun massimo maggiore di A
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= 0.786 * XA_len)
break;
#endregion
else if (AB_len >= 0.618 * XA_len && AB_len < 0.786 * XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un massimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[k] || zz.Value[l] < zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di B e nessun massimo maggiore di C
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.618 * AB_len && BC_len < AB_len)
{
Chart.DrawTriangle("Bullish_Gartley_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Orange);
Chart.DrawTriangle("Bullish_Gartley_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[k] - 0.786 * XA_len, Color.Orange);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.High[verify] > zz.Value[l])
{
Chart.RemoveObject("Bullish_Gartley_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Gartley_ala_dx" + i + j + k + l);
}
if (MarketSeries.Low[verify] <= zz.Value[i])
{
Chart.RemoveObject("Bullish_Gartley_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Gartley_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBearishBat(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.5 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[j] || zz.Value[l] < zz.Value[k])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < AB_len)
{
Chart.DrawTriangle("Bearish_Bat_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Violet, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Bat_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[k] + 0.886 * XA_len, Color.Violet, 1, LineStyle.DotsRare);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.Low[verify] < zz.Value[l])
{
Chart.RemoveObject("Bearish_Bat_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Bat_ala_dx" + i + j + k + l);
}
if (MarketSeries.High[verify] >= zz.Value[i])
{
Chart.RemoveObject("Bearish_Bat_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Bat_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBullishBat(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un massimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che X sia più basso di A
if (zz.Value[i] >= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di X e nessun massimo maggiore di A
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un minimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di B e nessun massimo maggiore di A
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.5 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un massimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[k] || zz.Value[l] < zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di B e nessun massimo maggiore di C
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < AB_len)
{
Chart.DrawTriangle("Bullish_Bat_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Violet);
Chart.DrawTriangle("Bullish_Bat_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[k] - 0.886 * XA_len, Color.Violet);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.High[verify] > zz.Value[l])
{
Chart.RemoveObject("Bullish_Bat_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Bat_ala_dx" + i + j + k + l);
}
if (MarketSeries.Low[verify] <= zz.Value[i])
{
Chart.RemoveObject("Bullish_Bat_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Bat_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBearishCypher(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.382 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia minore di B
if (zz.Value[l] > zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
double XC_len = zz.Value[i] - zz.Value[l];
if (BC_len > 1.414 * XA_len)
break;
#endregion
else if (XC_len >= 1.272 * XA_len && XC_len <= 1.414 * XA_len)
{
Chart.DrawTriangle("Bearish_Cypher_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Cyan, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Cypher_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[l] + 0.786 * XC_len, Color.Cyan, 1, LineStyle.DotsRare);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.Low[verify] < zz.Value[l])
{
Chart.RemoveObject("Bearish_Cypher_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Cypher_ala_dx" + i + j + k + l);
}
if (MarketSeries.High[verify] >= zz.Value[i])
{
Chart.RemoveObject("Bearish_Cypher_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Cypher_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBullishCypher(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[k] <= zz.Value[i])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.382 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia minore di B
if (zz.Value[j] > zz.Value[l])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
double XC_len = zz.Value[l] - zz.Value[i];
if (BC_len > 1.414 * XA_len)
break;
#endregion
else if (XC_len >= 1.272 * XA_len && XC_len <= 1.414 * XA_len)
{
Chart.DrawTriangle("Bullish_Cypher_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Cyan);
Chart.DrawTriangle("Bullish_Cypher_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[l] - 0.786 * XC_len, Color.Cyan);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.High[verify] > zz.Value[l])
{
Chart.RemoveObject("Bullish_Cypher_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Cypher_ala_dx" + i + j + k + l);
}
if (MarketSeries.Low[verify] <= zz.Value[i])
{
Chart.RemoveObject("Bullish_Cypher_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Cypher_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBearishButterfly(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= XA_len)
break;
#endregion
else if (AB_len >= 0.786 * XA_len && AB_len < XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[j] || zz.Value[l] < zz.Value[k])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
if (BC_len >= 0.886 * AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < 0.886 * AB_len)
{
Chart.DrawTriangle("Bearish_Butterfly_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Green, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Butterfly_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[k] + 1.272 * XA_len, Color.Green, 1, LineStyle.DotsRare);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.Low[verify] < zz.Value[l])
{
Chart.RemoveObject("Bearish_Butterfly_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Butterfly_ala_dx" + i + j + k + l);
}
if (MarketSeries.High[verify] >= zz.Value[i])
{
Chart.RemoveObject("Bearish_Butterfly_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bearish_Butterfly_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBullishButterfly(int index)
{
for (int i = index - max_len; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < index; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un massimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che X sia più basso di A
if (zz.Value[i] >= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di X e nessun massimo maggiore di A
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < index; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un minimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di B e nessun massimo maggiore di A
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= XA_len)
break;
#endregion
else if (AB_len >= 0.886 * XA_len && AB_len < XA_len)
//BC
for (int l = j + 1; l <= index; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un massimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[k] || zz.Value[l] < zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di B e nessun massimo maggiore di C
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < 0.886 * AB_len)
{
Chart.DrawTriangle("Bullish_Butterfly_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Green);
Chart.DrawTriangle("Bullish_Butterfly_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], l < (2 * j - i) ? (2 * j - i) : (int)(1.5 * l - 0.5 * j), zz.Value[k] - 1.272 * XA_len, Color.Green);
}
for (int verify = l + 1; verify <= index; verify++)
{
if (MarketSeries.High[verify] > zz.Value[l])
{
Chart.RemoveObject("Bullish_Butterfly_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Butterfly_ala_dx" + i + j + k + l);
}
if (MarketSeries.Low[verify] <= zz.Value[i])
{
Chart.RemoveObject("Bullish_Butterfly_ala_sx" + i + j + k + l);
Chart.RemoveObject("Bullish_Butterfly_ala_dx" + i + j + k + l);
}
}
}
}
}
}
}
}
}
return;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////BACKTESTING REGION///////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void LookForBacktestingBearishGartley(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= 0.786 * XA_len)
break;
#endregion
else if (AB_len >= 0.618 * XA_len && AB_len < 0.786 * XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[j] || zz.Value[l] < zz.Value[k])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.618 * AB_len && BC_len < AB_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.Low[d] > zz.Value[l] && MarketSeries.High[d] > zz.Value[k] + 0.786 * XA_len)
{
Chart.DrawTriangle("Bearish_Gartley_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Orange, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Gartley_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[k] + 0.786 * XA_len, Color.Orange, 1, LineStyle.DotsRare);
break;
}
else if (MarketSeries.Low[d] <= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBullishGartley(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un massimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che X sia più basso di A
if (zz.Value[i] >= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di X e nessun massimo maggiore di A
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un minimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di B e nessun massimo maggiore di A
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= 0.786 * XA_len)
break;
#endregion
else if (AB_len >= 0.618 * XA_len && AB_len < 0.786 * XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un massimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[k] || zz.Value[l] < zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di B e nessun massimo maggiore di C
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.618 * AB_len && BC_len < AB_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.High[d] < zz.Value[l] && MarketSeries.Low[d] <= zz.Value[k] - 0.786 * XA_len)
{
Chart.DrawTriangle("Bullish_Gartley_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Orange);
Chart.DrawTriangle("Bullish_Gartley_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[k] - 0.786 * XA_len, Color.Orange);
break;
}
else if (MarketSeries.High[d] >= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBearishBat(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.5 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[j] || zz.Value[l] < zz.Value[k])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < AB_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.Low[d] > zz.Value[l] && MarketSeries.Low[d] >= zz.Value[k] + 0.886 * XA_len)
{
Chart.DrawTriangle("Bearish_Bat_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Violet, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Bat_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[k] + 0.886 * XA_len, Color.Violet, 1, LineStyle.DotsRare);
break;
}
else if (MarketSeries.Low[d] <= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBullishBat(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un massimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che X sia più basso di A
if (zz.Value[i] >= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di X e nessun massimo maggiore di A
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un minimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di B e nessun massimo maggiore di A
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.5 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un massimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[k] || zz.Value[l] < zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di B e nessun massimo maggiore di C
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < AB_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.High[d] < zz.Value[l] && MarketSeries.Low[d] <= zz.Value[k] - 0.886 * XA_len)
{
Chart.DrawTriangle("Bullish_Bat_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Violet);
Chart.DrawTriangle("Bullish_Bat_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[k] - 0.886 * XA_len, Color.Violet);
break;
}
else if (MarketSeries.High[d] >= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBearishCypher(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.382 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia minore di B
if (zz.Value[l] > zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
double XC_len = zz.Value[i] - zz.Value[l];
if (BC_len > 1.414 * XA_len)
break;
#endregion
else if (XC_len >= 1.272 * XA_len && XC_len <= 1.414 * XA_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.Low[d] > zz.Value[l] && MarketSeries.High[d] >= zz.Value[l] + 0.786 * XC_len)
{
Chart.DrawTriangle("Bearish_Cypher_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Cyan, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Cypher_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[l] + 0.786 * XC_len, Color.Cyan, 1, LineStyle.DotsRare);
break;
}
else if (MarketSeries.Low[d] <= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBullishCypher(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[k] <= zz.Value[i])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= 0.618 * XA_len)
break;
#endregion
else if (AB_len >= 0.382 * XA_len && AB_len < 0.618 * XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia minore di B
if (zz.Value[j] > zz.Value[l])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
double XC_len = zz.Value[l] - zz.Value[i];
if (BC_len > 1.414 * XA_len)
break;
#endregion
else if (XC_len >= 1.272 * XA_len && XC_len <= 1.414 * XA_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.High[d] < zz.Value[l] && MarketSeries.Low[d] <= zz.Value[l] - 0.786 * XC_len)
{
Chart.DrawTriangle("Bullish_Cypher_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Cyan);
Chart.DrawTriangle("Bullish_Cypher_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[l] - 0.786 * XC_len, Color.Cyan);
break;
}
else if (MarketSeries.High[d] >= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBearishButterfly(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.High[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un minimo
if (zz.Value[k] != MarketSeries.Low[k])
continue;
//controllo che A sia più basso di X
if (zz.Value[i] <= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di A e nessun massimo maggiore di X
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[i])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[i] - zz.Value[k];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un massimo
if (zz.Value[j] != MarketSeries.High[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[i] || zz.Value[j] < zz.Value[k])
break;
//controllo che nessun minimo della gamba ab sia minore di A e nessun massimo maggiore di B
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[k] || MarketSeries.High[cont] >= zz.Value[j])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[j] - zz.Value[k];
if (AB_len >= XA_len)
break;
#endregion
else if (AB_len >= 0.786 * XA_len && AB_len < XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un minimo
if (zz.Value[l] != MarketSeries.Low[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[j] || zz.Value[l] < zz.Value[k])
break;
//controllo che nessun minimo della gamba bc sia minore di C e nessun massimo maggiore di B
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[l] || MarketSeries.High[cont] >= zz.Value[j])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[j] - zz.Value[l];
if (BC_len >= 0.886 * AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < 0.886 * AB_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.Low[d] > zz.Value[l] && MarketSeries.High[d] >= zz.Value[k] + 1.272 * XA_len)
{
Chart.DrawTriangle("Bearish_Butterfly_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Green, 1, LineStyle.DotsRare);
Chart.DrawTriangle("Bearish_Butterfly_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[k] + 1.272 * XA_len, Color.Green, 1, LineStyle.DotsRare);
break;
}
else if (MarketSeries.Low[d] <= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
private void LookForBacktestingBullishButterfly(int index)
{
for (int i = 0; i < index; i++)
{
if (!double.IsNaN(zz.Value[i]))
if (zz.Value[i] != MarketSeries.Low[i])
continue;
//XA
for (int k = i + 1; k < i + max_len; k++)
{
if (!double.IsNaN(zz.Value[k]))
{
//controllo XA
#region controllo XA
//controllo che A sia un massimo
if (zz.Value[k] != MarketSeries.High[k])
continue;
//controllo che X sia più basso di A
if (zz.Value[i] >= zz.Value[k])
break;
//controllo che nessun minimo della gamba xa sia minore di X e nessun massimo maggiore di A
bool valid_XA = true;
for (int cont = k - 1; cont > i; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[i] || MarketSeries.High[cont] >= zz.Value[k])
valid_XA = false;
}
if (!valid_XA)
continue;
#endregion
double XA_len = zz.Value[k] - zz.Value[i];
//AB
for (int j = k + 1; j < i + max_len; j++)
{
if (!double.IsNaN(zz.Value[j]))
{
//controllo AB
#region controllo AB
//controllo che B sia un minimo
if (zz.Value[j] != MarketSeries.Low[j])
continue;
//controllo che B sia compreso tra A e X
if (zz.Value[j] > zz.Value[k] || zz.Value[j] < zz.Value[i])
break;
//controllo che nessun minimo della gamba ab sia minore di B e nessun massimo maggiore di A
bool valid_AB = true;
for (int cont = j - 1; cont > k; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[k])
valid_AB = false;
}
if (!valid_AB)
continue;
double AB_len = zz.Value[k] - zz.Value[j];
if (AB_len >= XA_len)
break;
#endregion
else if (AB_len >= 0.886 * XA_len && AB_len < XA_len)
//BC
for (int l = j + 1; l <= i + max_len; l++)
{
if (!double.IsNaN(zz.Value[l]))
{
//controllo BC
#region controollo BC
//controllo che C sia un massimo
if (zz.Value[l] != MarketSeries.High[l])
continue;
//controllo che C sia compreso tra A e B
if (zz.Value[l] > zz.Value[k] || zz.Value[l] < zz.Value[j])
break;
//controllo che nessun minimo della gamba bc sia minore di B e nessun massimo maggiore di C
bool valid_BC = true;
for (int cont = l - 1; cont > j; cont--)
{
if (MarketSeries.Low[cont] <= zz.Value[j] || MarketSeries.High[cont] >= zz.Value[l])
valid_BC = false;
}
if (!valid_BC)
continue;
double BC_len = zz.Value[l] - zz.Value[j];
if (BC_len >= AB_len)
break;
#endregion
else if (BC_len >= 0.382 * AB_len && BC_len < 0.886 * AB_len)
{
for (int d = l + 1; d < index; d++)
{
if (MarketSeries.High[d] < zz.Value[l] && MarketSeries.Low[d] <= zz.Value[k] - 1.272 * XA_len)
{
Chart.DrawTriangle("Bullish_Butterfly_ala_sx" + i + j + k + l, i, zz.Value[i], k, zz.Value[k], j, zz.Value[j], Color.Green);
Chart.DrawTriangle("Bullish_Butterfly_ala_dx" + i + j + k + l, j, zz.Value[j], l, zz.Value[l], d, zz.Value[k] - 1.272 * XA_len, Color.Green);
break;
}
else if (MarketSeries.High[d] >= zz.Value[l])
break;
}
}
}
}
}
}
}
}
}
return;
}
}
}
CY
cysecsbin.01
Joined on 10.11.2018 Blocked
- Distribution: Free
- Language: C#
- Trading platform: cTrader Automate
- File name: Harmonics.algo
- Rating: 5
- Installs: 3372
- Modified: 13/10/2021 09:54
Note that publishing copyrighted material is strictly prohibited. If you believe there is copyrighted material in this section, please use the Copyright Infringement Notification form to submit a claim.
Comments
Log in to add a comment.
hi. there is error for
private ZigZagAndFiboLevels zz;
pls help me to fix it. thanks