/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Calculation
int iFirstBar = 2;
double[] adIB = new double[Bars];
for (int iBar = 2; iBar < Bars; iBar++)
{
adIB[iBar] = ((High[iBar - 1] < High[iBar - 2]) && (Low[iBar - 1] > Low[iBar - 2])) ? 1 : 0;
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Allow long entry";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adIB;
Component[1] = new IndicatorComp();
Component[1].CompName = "Allow short entry";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adIB;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iEntryHour = (int)IndParam.NumParam[0].Value;
int iEntryMinute = (int)IndParam.NumParam[1].Value;
TimeSpan tsEntryHour = new TimeSpan(iEntryHour, iEntryMinute, 0);
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adBars[iBar] = Time[iBar].TimeOfDay == tsEntryHour ? Open[iBar] : 0;
}
// Saving the components
Component = new IndicatorComp[1];
Component[0] = new IndicatorComp();
Component[0].CompName = "Entry hour";
Component[0].DataType = IndComponentType.OpenPrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Calculation
int iFirstBar = 2;
double[] adIB = new double[Bars];
for (int iBar = 2; iBar < Bars; iBar++)
{
adIB[iBar] = ((High[iBar - 1] < High[iBar - 2]) && (Low[iBar - 1] > Low[iBar - 2])) ? 1 : 0;
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Allow long entry";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adIB;
Component[1] = new IndicatorComp();
Component[1].CompName = "Allow short entry";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adIB;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Calculation
double[] adClosePrice = new double[Bars];
for (int iBar = 1; iBar < Bars; iBar++)
if (Time[iBar - 1].Day != Time[iBar].Day)
adClosePrice[iBar - 1] = Close[iBar - 1];
// Check the last bar
TimeSpan tsBarClosing = Time[Bars - 1].TimeOfDay.Add(new TimeSpan(0, (int)Period, 0));
TimeSpan tsDayClosing = new TimeSpan(24, 0, 0);
if (tsBarClosing == tsDayClosing)
adClosePrice[Bars - 1] = Close[Bars - 1];
// Saving the components
Component = new IndicatorComp[1];
Component[0] = new IndicatorComp();
Component[0].CompName = "Closing price of the day";
Component[0].DataType = IndComponentType.ClosePrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].FirstBar = 2;
Component[0].Value = adClosePrice;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iFromHour = (int)IndParam.NumParam[0].Value;
int iFromMin = (int)IndParam.NumParam[1].Value;
int iUntilHour = (int)IndParam.NumParam[2].Value;
int iUntilMin = (int)IndParam.NumParam[3].Value;
TimeSpan tsFromTime = new TimeSpan(iFromHour, iFromMin, 0);
TimeSpan tsUntilTime = new TimeSpan(iUntilHour, iUntilMin, 0);
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (tsFromTime < tsUntilTime)
{
adBars[iBar] = Time[iBar].TimeOfDay >= tsFromTime &&
Time[iBar].TimeOfDay < tsUntilTime ? 1 : 0;
}
else if (tsFromTime > tsUntilTime)
{
adBars[iBar] = Time[iBar].TimeOfDay >= tsFromTime ||
Time[iBar].TimeOfDay < tsUntilTime ? 1 : 0;
}
else
{
adBars[iBar] = 1;
}
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Is long entry allowed";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
Component[1] = new IndicatorComp();
Component[1].CompName = "Is short entry allowed";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
DayOfWeek dowFromDay = (DayOfWeek)IndParam.ListParam[1].Index;
DayOfWeek dowUntilDay = (DayOfWeek)IndParam.ListParam[2].Index;
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (dowFromDay < dowUntilDay)
{
adBars[iBar] = Time[iBar].DayOfWeek >= dowFromDay &&
Time[iBar].DayOfWeek < dowUntilDay ? 1 : 0;
}
else if (dowFromDay > dowUntilDay)
{
adBars[iBar] = Time[iBar].DayOfWeek >= dowFromDay ||
Time[iBar].DayOfWeek < dowUntilDay ? 1 : 0;
}
else
{
adBars[iBar] = 1;
}
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Allow long entry";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
Component[1] = new IndicatorComp();
Component[1].CompName = "Allow short entry";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBars;
return;
}
/// <summary>
/// Returns signals for the logic rule "The Indicator is lower than the AnotherIndicator"
/// </summary>
protected void IndicatorIsLowerThanAnotherIndicatorLogic(int firstBar, int previous, double[] adIndValue, double[] adAnotherIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
indCompLong.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iExitHour = (int)IndParam.NumParam[0].Value;
TimeSpan tsExitHour = new TimeSpan(iExitHour, 0, 0);
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (Time[iBar - 1].DayOfYear == Time[iBar].DayOfYear &&
Time[iBar - 1].TimeOfDay < tsExitHour &&
Time[iBar].TimeOfDay >= tsExitHour)
{
adBars[iBar - 1] = Close[iBar - 1];
}
else if (Time[iBar - 1].DayOfYear != Time[iBar].DayOfYear &&
Time[iBar - 1].TimeOfDay < tsExitHour)
{
adBars[iBar - 1] = Close[iBar - 1];
}
else
{
adBars[iBar] = 0;
}
}
// Check the last bar
if (Time[Bars - 1].TimeOfDay.Add(new TimeSpan(0, (int)Period, 0)) == tsExitHour)
{
adBars[Bars - 1] = Close[Bars - 1];
}
// Saving the components
Component = new IndicatorComp[1];
Component[0] = new IndicatorComp();
Component[0].CompName = "Exit hour";
Component[0].DataType = IndComponentType.ClosePrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int period = (int)IndParam.NumParam[0].Value;
int multipl = (int)IndParam.NumParam[1].Value;
int prev = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int firstBar = period + 2;
double[] ATR = new double[Bars];
for (int bar = 1; bar < Bars; bar++)
{
ATR[bar] = Math.Max(High[bar], Close[bar - 1]) - Math.Min(Low[bar], Close[bar - 1]);
}
ATR = MovingAverage(period, 0, maMethod, ATR);
double[] ATRStop = new double[Bars];
double pip = (Digits == 5 || Digits == 3) ? 10 * Point : Point;
double minStop = 5 * pip;
for (int bar = firstBar; bar < Bars - prev; bar++)
{
ATRStop[bar + prev] = Math.Max(ATR[bar] * multipl, minStop);
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "ATR Stop margin";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].FirstBar = firstBar;
Component[0].ShowInDynInfo = false;
Component[0].Value = ATRStop;
Component[1] = new IndicatorComp();
Component[1].CompName = "ATR Stop for the transferred position";
Component[1].DataType = IndComponentType.Other;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = firstBar;
Component[1].Value = new double[Bars];
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = 0; iBar < Bars - 1; iBar++)
{
if (Time[iBar].DayOfWeek > DayOfWeek.Wednesday &&
Time[iBar + 1].DayOfWeek < DayOfWeek.Wednesday)
{
adBars[iBar] = Close[iBar];
}
else
{
adBars[iBar] = 0;
}
}
// Check the last bar
TimeSpan tsBarClosing = Time[Bars - 1].TimeOfDay.Add(new TimeSpan(0, (int)Period, 0));
TimeSpan tsDayClosing = new TimeSpan(24, 0, 0);
if (Time[Bars - 1].DayOfWeek == DayOfWeek.Friday && tsBarClosing == tsDayClosing)
{
adBars[Bars - 1] = Close[Bars - 1];
}
// Saving the components
Component = new IndicatorComp[1];
Component[0] = new IndicatorComp();
Component[0].CompName = "Week Closing";
Component[0].DataType = IndComponentType.ClosePrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
// Calculation
int iFirstBar = 0;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adBars[iBar] = 1;
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Allow Open Long";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
Component[1] = new IndicatorComp();
Component[1].CompName = "Allow Open Short";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBars;
return;
}
/// <summary>
/// Returns signals for the logic rule "The Indicator crosses AnotherIndicator downward"
/// </summary>
protected void IndicatorCrossesAnotherIndicatorDownwardLogic(int firstBar, int previous, double[] adIndValue, double[] adAnotherIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
int baseBar = currentBar - 1;
while (Math.Abs(adIndValue[baseBar] - adAnotherIndValue[baseBar]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma && adIndValue[baseBar] > adAnotherIndValue[baseBar] + sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma && adIndValue[baseBar] < adAnotherIndValue[baseBar] - sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Returns a copy
/// </summary>
public IndicatorComp Clone()
{
IndicatorComp component = new IndicatorComp();
component.compName = compName;
component.dataType = dataType;
component.chartType = chartType;
component.chartColor = chartColor;
component.firstBar = firstBar;
component.previous = previous;
component.isDynInfo = isDynInfo;
component.posPriceDependence = posPriceDependence;
if (values != null)
{
component.values = new double[values.Length];
values.CopyTo(component.values, 0);
}
return(component);
}
/// <summary>
/// Returns a copy.
/// </summary>
public IndicatorComp Clone()
{
var indicatorComp = new IndicatorComp
{
CompName = CompName,
DataType = DataType,
ChartType = ChartType,
ChartColor = ChartColor,
FirstBar = FirstBar,
UsePreviousBar = UsePreviousBar,
ShowInDynInfo = ShowInDynInfo,
PosPriceDependence = PosPriceDependence
};
if (Value != null)
{
indicatorComp.Value = new double[Value.Length];
Value.CopyTo(indicatorComp.Value, 0);
}
return(indicatorComp);
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int period = (int)IndParam.NumParam[0].Value;
int multipl = (int)IndParam.NumParam[1].Value;
int prev = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int firstBar = period + 2;
double[] ATR = new double[Bars];
for (int bar = 1; bar < Bars; bar++)
ATR[bar] = Math.Max(High[bar], Close[bar - 1]) - Math.Min(Low[bar], Close[bar - 1]);
ATR = MovingAverage(period, 0, maMethod, ATR);
double[] ATRStop = new double[Bars];
double minStop = 5 * Point;
for (int bar = firstBar; bar < Bars - prev; bar++)
ATRStop[bar + prev] = Math.Max(ATR[bar] * multipl, minStop);
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "ATR Stop margin";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].FirstBar = firstBar;
Component[0].ShowInDynInfo = false;
Component[0].Value = ATRStop;
Component[1] = new IndicatorComp();
Component[1].CompName = "ATR Stop for the transferred position";
Component[1].DataType = IndComponentType.Other;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = firstBar;
Component[1].Value = new double[Bars];
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
double dShift = IndParam.NumParam[0].Value * Point;
int iDigids = (int)IndParam.NumParam[1].Value;
// Calculation
double[] adUpperRN = new double[Bars];
double[] adLowerRN = new double[Bars];
int iFirstBar = 1;
for (int iBar = 1; iBar < Bars; iBar++)
{
double dNearestRound;
int iCutDigids = Digits - iDigids;
if (iCutDigids >= 0)
dNearestRound = Math.Round(Open[iBar], iCutDigids);
else
dNearestRound = Math.Round(Open[iBar] * Math.Pow(10, iCutDigids)) / Math.Pow(10, iCutDigids);
if (dNearestRound < Open[iBar])
{
adUpperRN[iBar] = dNearestRound + (Point * Math.Pow(10, iDigids));
adLowerRN[iBar] = dNearestRound;
}
else
{
adUpperRN[iBar] = dNearestRound;
adLowerRN[iBar] = dNearestRound - (Point * Math.Pow(10, iDigids));
}
}
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "Higher round number";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Level;
Component[0].ChartColor = Color.SpringGreen;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adUpperRN;
Component[1] = new IndicatorComp();
Component[1].CompName = "Lower round number";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.DarkRed;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adLowerRN;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
if (slotType == SlotTypes.Open)
{
Component[2].CompName = "Long position entry price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Short position entry price";
Component[3].DataType = IndComponentType.OpenShortPrice;
}
else if (slotType == SlotTypes.Close)
{
Component[2].CompName = "Long position closing price";
Component[2].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Short position closing price";
Component[3].DataType = IndComponentType.CloseShortPrice;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter long at the higher round number":
case "Exit long at the higher round number":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[2].Value[iBar] = adUpperRN[iBar] + dShift;
Component[3].Value[iBar] = adLowerRN[iBar] - dShift;
}
break;
case "Enter long at the lower round number":
case "Exit long at the lower round number":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[2].Value[iBar] = adLowerRN[iBar] - dShift;
Component[3].Value[iBar] = adUpperRN[iBar] + dShift;
}
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int nPeriod = (int)IndParam.NumParam[0].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = 2 * nPeriod + 2;
double[] ma1 = MovingAverage(nPeriod, 0, maMethod, Price(basePrice));
double[] ma2 = MovingAverage(nPeriod, 0, maMethod, ma1);
double[] ma3 = MovingAverage(nPeriod, 0, maMethod, ma2);
double[] adTrix = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adTrix[iBar] = 100 * (ma3[iBar] - ma3[iBar - 1]) / ma3[iBar - 1];
}
double[] adSignal = MovingAverage(nPeriod, 0, maMethod, adTrix);
// adHistogram reprezents the Trix Index oscillator
double[] adHistogram = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adHistogram[iBar] = adTrix[iBar] - adSignal[iBar];
}
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "Histogram";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adHistogram;
Component[1] = new IndicatorComp();
Component[1].CompName = "Signal";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Gold;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adSignal;
Component[2] = new IndicatorComp();
Component[2].CompName = "Trix Line";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Blue;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adTrix;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
switch (IndParam.ListParam[0].Text)
{
case "The Trix Index line rises":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_rises);
break;
case "The Trix Index line falls":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_falls);
break;
case "The Trix Index line is higher than zero":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_higher_than_the_level_line);
break;
case "The Trix Index line is lower than zero":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_lower_than_the_level_line);
break;
case "The Trix Index line crosses the zero line upward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_upward);
break;
case "The Trix Index line crosses the zero line downward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_downward);
break;
case "The Trix Index line changes its direction upward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_changes_its_direction_upward);
break;
case "The Trix Index line changes its direction downward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_changes_its_direction_downward);
break;
case "The Trix Index line crosses the Signal line upward":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_upward);
break;
case "The Trix Index line crosses the Signal line downward":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_downward);
break;
case "The Trix Index line is higher than the Signal line":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_higher_than_the_level_line);
break;
case "The Trix Index line is lower than the Signal line":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_lower_than_the_level_line);
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iSense = (int)IndParam.NumParam[0].Value;
int iFirstBar = iSense;
double[] adFibo0;
double[] adFibo382;
double[] adFibo50;
double[] adFibo618;
double[] adFibo100;
bool bReverseLogic = (IndParam.ListParam[1].Text == "Retracement");
int iDeviation = 5;
int iBackStep = 3;
double[] adHighPoint = new double[Bars];
double[] adLowPoint = new double[Bars];
adFibo0 = new double[Bars];
adFibo382 = new double[Bars];
adFibo50 = new double[Bars];
adFibo618 = new double[Bars];
adFibo100 = new double[Bars];
double dLastHigh = 0;
double dLastLow = 0;
for (int iBar = iSense; iBar < Bars; iBar++)
{
// The highest High in the period [iBar-iSence, iBar]
double dHigh = 0;
for (int iShift = 0; iShift < iSense; iShift++)
if (dHigh < High[iBar - iShift])
dHigh = High[iBar - iShift];
if (dHigh == dLastHigh)
dHigh = 0;
else
{
dLastHigh = dHigh;
if (dHigh - High[iBar] > iDeviation * Point)
dHigh = 0;
else
for (int iBack = 1; iBack <= iBackStep; iBack++)
if (adHighPoint[iBar - iBack] > 0 && adHighPoint[iBar - iBack] < dHigh)
adHighPoint[iBar - iBack] = 0;
}
adHighPoint[iBar] = dHigh;
// The lowest Low in the period [iBar-iSence, iBar]
double dLow = 10000;
for (int iShift = 0; iShift < iSense; iShift++)
if (Low[iBar - iShift] < dLow)
dLow = Low[iBar - iShift];
if (dLow == dLastLow)
dLow = 0;
else
{
dLastLow = dLow;
if (Low[iBar] - dLow > iDeviation * Point)
dLow = 0;
else
for (int iBack = 1; iBack <= iBackStep; iBack++)
if (adLowPoint[iBar - iBack] > 0 && adLowPoint[iBar - iBack] > dLow)
adLowPoint[iBar - iBack] = 0;
}
adLowPoint[iBar] = dLow;
}
int iLastHighBar = -1;
int iLastLowBar = -1;
double dCurHigh;
double dCurLow;
dLastHigh = -1;
dLastLow = -1;
for (int iBar = iSense; iBar < Bars; iBar++)
{
dCurHigh = adHighPoint[iBar];
dCurLow = adLowPoint[iBar];
if (dCurLow == 0 && dCurHigh == 0) continue;
if (dCurHigh != 0)
{
if (dLastHigh > 0)
{
if (dLastHigh < dCurHigh) adHighPoint[iLastHighBar] = 0;
else adHighPoint[iBar] = 0;
}
if (dLastHigh < dCurHigh || dLastHigh < 0)
{
dLastHigh = dCurHigh;
iLastHighBar = iBar;
}
dLastLow = -1;
}
if (dCurLow != 0)
{
if (dLastLow > 0)
{
if (dLastLow > dCurLow) adLowPoint[iLastLowBar] = 0;
else adLowPoint[iBar] = 0;
}
if (dCurLow < dLastLow || dLastLow < 0)
{
dLastLow = dCurLow;
iLastLowBar = iBar;
}
dLastHigh = -1;
}
}
dLastHigh = 0;
dLastLow = 0;
int iFirstLowBar = 0;
int iFirstHighBar = 0;
for (int iBar = 0; iBar < Bars; iBar++)
{
if (adHighPoint[iBar] > 0)
{
dLastHigh = adHighPoint[iBar];
iFirstHighBar = iBar;
}
if (adLowPoint[iBar] > 0)
{
dLastLow = adLowPoint[iBar];
iFirstLowBar = iBar;
}
if (iFirstHighBar > 0 && iFirstLowBar > 0) break;
}
for (int iBar = Math.Max(iFirstLowBar, iFirstHighBar); iBar < Bars; iBar++)
{
if (adHighPoint[iBar - 1] > 0)
{
dLastHigh = adHighPoint[iBar - 1];
adFibo0 [iBar] = dLastHigh;
adFibo382[iBar] = dLastHigh - (dLastHigh - dLastLow) * 0.382;
adFibo50 [iBar] = dLastHigh - (dLastHigh - dLastLow) * 0.500;
adFibo618[iBar] = dLastHigh - (dLastHigh - dLastLow) * 0.618;
adFibo100[iBar] = dLastLow;
}
else if (adLowPoint[iBar - 1] > 0)
{
dLastLow = adLowPoint[iBar - 1];
adFibo0 [iBar] = dLastLow;
adFibo382[iBar] = dLastLow + (dLastHigh - dLastLow) * 0.382;
adFibo50 [iBar] = dLastLow + (dLastHigh - dLastLow) * 0.500;
adFibo618[iBar] = dLastLow + (dLastHigh - dLastLow) * 0.618;
adFibo100[iBar] = dLastHigh;
}
else
{
adFibo0 [iBar] = adFibo0 [iBar - 1];
adFibo382[iBar] = adFibo382[iBar - 1];
adFibo50 [iBar] = adFibo50 [iBar - 1];
adFibo618[iBar] = adFibo618[iBar - 1];
adFibo100[iBar] = adFibo100[iBar - 1];
}
}
// Saving the components
Component = new IndicatorComp[8];
Component[0] = new IndicatorComp();
Component[0].CompName = "Position entry price";
Component[0].DataType = IndComponentType.OpenPrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].FirstBar = iFirstBar;
Component[0].Value = new double[Bars];
Component[1] = new IndicatorComp();
Component[1].CompName = "Fibonacci retracement 0%";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.Green;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adFibo0;
Component[2] = new IndicatorComp();
Component[2].CompName = "Fibonacci retracement 38.2%";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Level;
Component[2].ChartColor = Color.Gold;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adFibo382;
Component[3] = new IndicatorComp();
Component[3].CompName = "Fibonacci retracement 50%";
Component[3].DataType = IndComponentType.IndicatorValue;
Component[3].ChartType = IndChartType.Level;
Component[3].ChartColor = Color.Orchid;
Component[3].FirstBar = iFirstBar;
Component[3].Value = adFibo50;
Component[4] = new IndicatorComp();
Component[4].CompName = "Fibonacci retracement 61.8%";
Component[4].DataType = IndComponentType.IndicatorValue;
Component[4].ChartType = IndChartType.Level;
Component[4].ChartColor = Color.Purple;
Component[4].FirstBar = iFirstBar;
Component[4].Value = adFibo618;
Component[5] = new IndicatorComp();
Component[5].CompName = "Fibonacci retracement 100%";
Component[5].DataType = IndComponentType.IndicatorValue;
Component[5].ChartType = IndChartType.Level;
Component[5].ChartColor = Color.Red;
Component[5].FirstBar = iFirstBar;
Component[5].Value = adFibo100;
Component[6] = new IndicatorComp();
Component[6].CompName = "Is long entry allowed";
Component[6].DataType = IndComponentType.AllowOpenLong;
Component[6].ChartType = IndChartType.NoChart;
Component[6].FirstBar = iFirstBar;
Component[6].Value = new double[Bars];
Component[7] = new IndicatorComp();
Component[7].CompName = "Is short entry allowed";
Component[7].DataType = IndComponentType.AllowOpenShort;
Component[7].ChartType = IndChartType.NoChart;
Component[7].FirstBar = iFirstBar;
Component[7].Value = new double[Bars];
int iBarFibo382Reached = 0;
int iBarFibo500Reached = 0;
int iBarFibo618Reached = 0;
int iBarFibo100Reached = 0;
for (int iBar = Math.Max(iFirstLowBar, iFirstHighBar); iBar < Bars; iBar++)
{
Component[0].Value[iBar] = 0;
// Reset
if (adHighPoint[iBar - 1] > 0 || adLowPoint[iBar - 1] > 0)
{
iBarFibo382Reached = 0;
iBarFibo500Reached = 0;
iBarFibo618Reached = 0;
iBarFibo100Reached = 0;
}
// Up trend
if (adFibo0[iBar] < adFibo100[iBar])
{
if (iBarFibo382Reached == 0 && Low[iBar] <= adFibo382[iBar] && High[iBar] >= adFibo382[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
Component[0].Value[iBar] = adFibo382[iBar];
iBarFibo382Reached = iBar;
}
if (iBarFibo500Reached == 0 && Low[iBar] <= adFibo50[iBar] && High[iBar] >= adFibo50[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
if (iBarFibo382Reached != iBar)
Component[0].Value[iBar] = adFibo50[iBar];
iBarFibo500Reached = iBar;
}
if (iBarFibo618Reached == 0 && Low[iBar] <= adFibo618[iBar] && High[iBar] >= adFibo618[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
if (iBarFibo500Reached != iBar)
Component[0].Value[iBar] = adFibo618[iBar];
iBarFibo618Reached = iBar;
}
if (iBarFibo100Reached == 0 && Low[iBar] <= adFibo100[iBar] && High[iBar] >= adFibo100[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
if (iBarFibo618Reached != iBar)
Component[0].Value[iBar] = adFibo100[iBar];
iBarFibo100Reached = iBar;
}
}
// Down trend
if (adFibo0[iBar] > adFibo100[iBar])
{
if (iBarFibo382Reached == 0 && Low[iBar] <= adFibo382[iBar] && High[iBar] >= adFibo382[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
Component[0].Value[iBar] = adFibo382[iBar];
iBarFibo382Reached = iBar;
}
if (iBarFibo500Reached == 0 && Low[iBar] <= adFibo50[iBar] && High[iBar] >= adFibo50[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
if (iBarFibo382Reached != iBar)
Component[0].Value[iBar] = adFibo50[iBar];
iBarFibo500Reached = iBar;
}
if (iBarFibo618Reached == 0 && Low[iBar] <= adFibo618[iBar] && High[iBar] >= adFibo618[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
if (iBarFibo500Reached != iBar)
Component[0].Value[iBar] = adFibo618[iBar];
iBarFibo618Reached = iBar;
}
if (iBarFibo100Reached == 0 && Low[iBar] <= adFibo100[iBar] && High[iBar] >= adFibo100[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
if (iBarFibo618Reached != iBar)
Component[0].Value[iBar] = adFibo100[iBar];
iBarFibo100Reached = iBar;
}
}
}
return;
}
/// <summary>
/// Returns a copy
/// </summary>
public IndicatorComp Clone()
{
IndicatorComp component = new IndicatorComp();
component.compName = compName;
component.dataType = dataType;
component.chartType = chartType;
component.chartColor = chartColor;
component.firstBar = firstBar;
component.previous = previous;
component.isDynInfo = isDynInfo;
component.posPriceDependence = posPriceDependence;
if (values != null)
{
component.values = new double[values.Length];
values.CopyTo(component.values, 0);
}
return component;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice price = (BasePrice)IndParam.ListParam[2].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
int iShift = (int)IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// TimeExecution
if (price == BasePrice.Open && iPeriod == 1 && iShift == 0)
IndParam.ExecutionTime = ExecutionTime.AtBarOpening;
// Calculation
double[] adMA = MovingAverage(iPeriod, iShift, maMethod, Price(price));
int iFirstBar = iPeriod + iShift + 1 + iPrvs;
// Saving the components
if (slotType == SlotTypes.Open || slotType == SlotTypes.Close)
{
Component = new IndicatorComp[2];
Component[1] = new IndicatorComp();
Component[1].Value = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{ // Covers the cases when the price can pass through the MA without a signal
double dValue = adMA[iBar - iPrvs]; // Current value
double dValue1 = adMA[iBar - iPrvs - 1]; // Previous value
double dTempVal = dValue;
if ((dValue1 > High[iBar - 1] && dValue < Open[iBar]) || // The Open price jumps above the indicator
(dValue1 < Low[iBar - 1] && dValue > Open[iBar]) || // The Open price jumps below the indicator
(Close[iBar - 1] < dValue && dValue < Open[iBar]) || // The Open price is in a positive gap
(Close[iBar - 1] > dValue && dValue > Open[iBar])) // The Open price is in a negative gap
dTempVal = Open[iBar];
Component[1].Value[iBar] = dTempVal; // Entry or exit value
}
}
else
{
Component = new IndicatorComp[3];
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
}
Component[0] = new IndicatorComp();
Component[0].CompName = "MA Value";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Red;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adMA;
if (slotType == SlotTypes.Open)
{
Component[1].CompName = "Position opening price";
Component[1].DataType = IndComponentType.OpenPrice;
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.Close)
{
Component[1].CompName = "Position closing price";
Component[1].DataType = IndComponentType.ClosePrice;
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
if (slotType == SlotTypes.OpenFilter || slotType == SlotTypes.CloseFilter)
{
switch (IndParam.ListParam[0].Text)
{
case "The Moving Average rises":
IndicatorRisesLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The Moving Average falls":
IndicatorFallsLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The bar opens above the Moving Average":
BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The bar opens below the Moving Average":
BarOpensBelowIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The bar opens above the Moving Average after opening below it":
BarOpensAboveIndicatorAfterOpeningBelowLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The bar opens below the Moving Average after opening above it":
BarOpensBelowIndicatorAfterOpeningAboveLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The position opens above the Moving Average":
Component[0].PosPriceDependence = PositionPriceDependence.BuyHigherSellLower;
Component[0].UsePreviousBar = iPrvs;
Component[1].DataType = IndComponentType.Other;
Component[1].ShowInDynInfo = false;
Component[2].DataType = IndComponentType.Other;
Component[2].ShowInDynInfo = false;
break;
case "The position opens below the Moving Average":
Component[0].PosPriceDependence = PositionPriceDependence.BuyLowerSelHigher;
Component[0].UsePreviousBar = iPrvs;
Component[1].DataType = IndComponentType.Other;
Component[1].ShowInDynInfo = false;
Component[2].DataType = IndComponentType.Other;
Component[2].ShowInDynInfo = false;
break;
case "The bar closes below the Moving Average":
BarClosesBelowIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
case "The bar closes above the Moving Average":
BarClosesAboveIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]);
break;
default:
break;
}
}
return;
}
/// <summary>
/// Calculates the indicator's components.
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice price = (BasePrice)IndParam.ListParam[2].Index;
int nMA = (int)IndParam.NumParam[0].Value;
double dMpl = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
double[] adPrice = Price(price);
double[] adMA = MovingAverage(nMA, 0, maMethod, adPrice);
double[] adUpBand = new double[Bars];
double[] adDnBand = new double[Bars];
int iFirstBar = nMA + iPrvs + 2;
double dSum;
double dStdDev;
double dDelta;
for (int iBar = nMA; iBar < Bars; iBar++)
{
dSum = 0;
for (int i = 0; i < nMA; i++)
{
dDelta = (adPrice[iBar - i] - adMA[iBar]);
dSum += dDelta * dDelta;
}
dStdDev = Math.Sqrt(dSum / nMA);
adUpBand[iBar] = adMA[iBar] + dMpl * dStdDev;
adDnBand[iBar] = adMA[iBar] - dMpl * dStdDev;
}
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "Upper Band";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adUpBand;
Component[1] = new IndicatorComp();
Component[1].CompName = "Moving Average";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Gold;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adMA;
Component[2] = new IndicatorComp();
Component[2].CompName = "Lower Band";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Blue;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adDnBand;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type.
if (slotType == SlotTypes.Open)
{
Component[3].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Long position entry price";
Component[4].DataType = IndComponentType.OpenShortPrice;
Component[4].CompName = "Short position entry price";
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.Close)
{
Component[3].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Long position closing price";
Component[4].DataType = IndComponentType.CloseShortPrice;
Component[4].CompName = "Short position closing price";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
if (slotType == SlotTypes.Open || slotType == SlotTypes.Close)
{
if (nMA > 1)
{
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{ // Covers the cases when the price can pass through the band without a signal.
double dOpen = Open[iBar]; // Current open price
// Upper band
double dValueUp = adUpBand[iBar - iPrvs]; // Current value
double dValueUp1 = adUpBand[iBar - iPrvs - 1]; // Previous value
double dTempValUp = dValueUp;
if ((dValueUp1 > High[iBar - 1] && dValueUp < dOpen) || // The Open price jumps above the indicator
(dValueUp1 < Low[iBar - 1] && dValueUp > dOpen) || // The Open price jumps below the indicator
(Close[iBar - 1] < dValueUp && dValueUp < dOpen) || // The Open price is in a positive gap
(Close[iBar - 1] > dValueUp && dValueUp > dOpen)) // The Open price is in a negative gap
dTempValUp = dOpen; // The entry/exit level is moved to Open price
// Lower band
double dValueDown = adDnBand[iBar - iPrvs]; // Current value
double dValueDown1 = adDnBand[iBar - iPrvs - 1]; // Previous value
double dTempValDown = dValueDown;
if ((dValueDown1 > High[iBar - 1] && dValueDown < dOpen) || // The Open price jumps above the indicator
(dValueDown1 < Low[iBar - 1] && dValueDown > dOpen) || // The Open price jumps below the indicator
(Close[iBar - 1] < dValueDown && dValueDown < dOpen) || // The Open price is in a positive gap
(Close[iBar - 1] > dValueDown && dValueDown > dOpen)) // The Open price is in a negative gap
dTempValDown = dOpen; // The entry/exit level is moved to Open price
if (IndParam.ListParam[0].Text == "Enter long at the Upper Band" ||
IndParam.ListParam[0].Text == "Exit long at the Upper Band")
{
Component[3].Value[iBar] = dTempValUp;
Component[4].Value[iBar] = dTempValDown;
}
else
{
Component[3].Value[iBar] = dTempValDown;
Component[4].Value[iBar] = dTempValUp;
}
}
}
else
{
for (int iBar = 2; iBar < Bars; iBar++)
{
if (IndParam.ListParam[0].Text == "Enter long at the Upper Band" ||
IndParam.ListParam[0].Text == "Exit long at the Upper Band")
{
Component[3].Value[iBar] = adUpBand[iBar - iPrvs];
Component[4].Value[iBar] = adDnBand[iBar - iPrvs];
}
else
{
Component[3].Value[iBar] = adDnBand[iBar - iPrvs];
Component[4].Value[iBar] = adUpBand[iBar - iPrvs];
}
}
}
}
else
{
switch (IndParam.ListParam[0].Text)
{
case "The bar opens below the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Upper_Band);
break;
case "The bar opens above the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Upper_Band);
break;
case "The bar opens below the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Lower_Band);
break;
case "The bar opens above the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Lower_Band);
break;
case "The bar opens below the Upper Band after opening above it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Upper_Band_after_opening_above_it);
break;
case "The bar opens above the Upper Band after opening below it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Upper_Band_after_opening_below_it);
break;
case "The bar opens below the Lower Band after opening above it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Lower_Band_after_opening_above_it);
break;
case "The bar opens above the Lower Band after opening below it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Lower_Band_after_opening_below_it);
break;
case "The position opens above the Upper Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[2].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The position opens below the Upper Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[2].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The position opens above the Lower Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The position opens below the Lower Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The bar closes below the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_below_the_Upper_Band);
break;
case "The bar closes above the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_above_the_Upper_Band);
break;
case "The bar closes below the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_below_the_Lower_Band);
break;
case "The bar closes above the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_above_the_Lower_Band);
break;
default:
break;
}
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
int iSmooth = (int)IndParam.NumParam[1].Value;
double dLevel = IndParam.NumParam[2].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
int iFirstBar = iPrvs + iPeriod + iSmooth + 2;
double[] adMomentum = new double[Bars];
double[] adBasePrice = Price(basePrice);
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
adMomentum[iBar] = adBasePrice[iBar] - adBasePrice[iBar - iPeriod];
}
if (iSmooth > 0)
{
adMomentum = MovingAverage(iSmooth, 0, maMethod, adMomentum);
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Momentum";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adMomentum;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Momentum rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] {
0
};
break;
case "The Momentum falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] {
0
};
break;
case "The Momentum is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] {
dLevel, -dLevel
};
break;
case "The Momentum is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] {
dLevel, -dLevel
};
break;
case "The Momentum crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] {
dLevel, -dLevel
};
break;
case "The Momentum crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] {
dLevel, -dLevel
};
break;
case "The Momentum changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] {
0
};
break;
case "The Momentum changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] {
0
};
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adMomentum, dLevel, -dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int iNJaws = (int)IndParam.NumParam[0].Value;
int iSJaws = (int)IndParam.NumParam[1].Value;
int iNTeeth = (int)IndParam.NumParam[2].Value;
int iSTeeth = (int)IndParam.NumParam[3].Value;
int iNLips = (int)IndParam.NumParam[4].Value;
int iSLips = (int)IndParam.NumParam[5].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
int iFirstBar = Math.Max(iNJaws + iSJaws + 2, iNTeeth + iSTeeth + 2);
iFirstBar = Math.Max(iFirstBar, iNLips + iSLips + 2);
// Calculation
double[] adJaws = MovingAverage(iNJaws , iSJaws , maMethod, Price(basePrice));
double[] adTeeth = MovingAverage(iNTeeth, iSTeeth, maMethod, Price(basePrice));
double[] adLips = MovingAverage(iNLips , iSLips , maMethod, Price(basePrice));
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "Jaws";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adJaws;
Component[1] = new IndicatorComp();
Component[1].CompName = "Teeth";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Red;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adTeeth;
Component[2] = new IndicatorComp();
Component[2].CompName = "Lips";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Lime;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adLips;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type.
if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
switch (IndParam.ListParam[0].Text)
{
case "The Jaws rises":
IndicatorRisesLogic(iFirstBar, iPrvs, adJaws, ref Component[3], ref Component[4]);
break;
case "The Jaws falls":
IndicatorFallsLogic(iFirstBar, iPrvs, adJaws, ref Component[3], ref Component[4]);
break;
case "The Teeth rises":
IndicatorRisesLogic(iFirstBar, iPrvs, adTeeth, ref Component[3], ref Component[4]);
break;
case "The Teeth falls":
IndicatorFallsLogic(iFirstBar, iPrvs, adTeeth, ref Component[3], ref Component[4]);
break;
case "The Lips rises":
IndicatorRisesLogic(iFirstBar, iPrvs, adLips, ref Component[3], ref Component[4]);
break;
case "The Lips falls":
IndicatorFallsLogic(iFirstBar, iPrvs, adLips, ref Component[3], ref Component[4]);
break;
case "The Lips crosses the Teeth upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adLips, adTeeth, ref Component[3], ref Component[4]);
break;
case "The Lips crosses the Teeth downward":
IndicatorCrossesAnotherIndicatorDownwardLogic(iFirstBar, iPrvs, adLips, adTeeth, ref Component[3], ref Component[4]);
break;
case "The Lips crosses the Jaws upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adLips, adJaws, ref Component[3], ref Component[4]);
break;
case "The Lips crosses the Jaws downward":
IndicatorCrossesAnotherIndicatorDownwardLogic(iFirstBar, iPrvs, adLips, adJaws, ref Component[3], ref Component[4]);
break;
case "The Teeth crosses the Jaws upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adTeeth, adJaws, ref Component[3], ref Component[4]);
break;
case "The Teeth crosses the Jaws downward":
IndicatorCrossesAnotherIndicatorDownwardLogic(iFirstBar, iPrvs, adTeeth, adJaws, ref Component[3], ref Component[4]);
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
BasePrice basePrice = (BasePrice)IndParam.ListParam[1].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod + 2;
double[] adBasePrice = Price(basePrice);
double[] adUp = new double[Bars];
double[] adDown = new double[Bars];
double[] adAroon = new double[Bars];
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iPeriod; i++)
{
int iBaseBar = iBar - iPeriod + 1 + i;
if (adBasePrice[iBaseBar] > dHighestHigh)
{
dHighestHigh = adBasePrice[iBaseBar];
adUp[iBar] = 100.0 * i / (iPeriod - 1);
}
if (adBasePrice[iBaseBar] < dLowestLow)
{
dLowestLow = adBasePrice[iBaseBar];
adDown[iBar] = 100.0 * i / (iPeriod - 1);
}
}
}
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adAroon[iBar] = adUp[iBar] - adDown[iBar];
}
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "Aroon Histogram";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adAroon;
Component[1] = new IndicatorComp();
Component[1].CompName = "Aroon Up";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Green;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adUp;
Component[2] = new IndicatorComp();
Component[2].CompName = "Aroon Down";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Red;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adDown;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Aroon Histogram rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] { 0 };
break;
case "The Aroon Histogram falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] { 0 };
break;
case "The Aroon Histogram is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The Aroon Histogram is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The Aroon Histogram crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The Aroon Histogram crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The Aroon Histogram changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] { 0 };
break;
case "The Aroon Histogram changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] { 0 };
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adAroon, dLevel, -dLevel, ref Component[3], ref Component[4], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice price = BasePrice.Close;
int nMA = (int)IndParam.NumParam[0].Value;
int iATRPeriod = (int)IndParam.NumParam[1].Value;
int iATRMultiplier = (int)IndParam.NumParam[3].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
double[] adMA = MovingAverage(nMA, 0, maMethod, Price(price));
double[] adATR = new double[Bars];
double[] adUpBand = new double[Bars];
double[] adDnBand = new double[Bars];
int iFirstBar = (int)Math.Max(nMA, iATRPeriod) + iPrvs + 2;
for (int iBar = 1; iBar < Bars; iBar++)
{
adATR[iBar] = Math.Max(Math.Abs(High[iBar] - Close[iBar - 1]), Math.Abs(Close[iBar - 1] - Low[iBar]));
adATR[iBar] = Math.Max(Math.Abs(High[iBar] - Low[iBar]), adATR[iBar]);
}
adATR = MovingAverage(iATRPeriod, 0, maMethod, adATR);
for (int iBar = nMA; iBar < Bars; iBar++)
{
adUpBand[iBar] = adMA[iBar] + adATR[iBar] * iATRMultiplier;
adDnBand[iBar] = adMA[iBar] - adATR[iBar] * iATRMultiplier;
}
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "Upper Band";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adUpBand;
Component[1] = new IndicatorComp();
Component[1].CompName = "Moving Average";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Gold;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adMA;
Component[2] = new IndicatorComp();
Component[2].CompName = "Lower Band";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Blue;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adDnBand;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.Open)
{
Component[3].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Long position entry price";
Component[4].DataType = IndComponentType.OpenShortPrice;
Component[4].CompName = "Short position entry price";
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.Close)
{
Component[3].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Long position closing price";
Component[4].DataType = IndComponentType.CloseShortPrice;
Component[4].CompName = "Short position closing price";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
if (slotType == SlotTypes.Open || slotType == SlotTypes.Close)
{
if (nMA > 1)
{
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{ // Covers the cases when the price can pass through the band without a signal.
double dOpen = Open[iBar]; // Current open price
// Upper band
double dValueUp = adUpBand[iBar - iPrvs]; // Current value
double dValueUp1 = adUpBand[iBar - iPrvs - 1]; // Previous value
double dTempValUp = dValueUp;
if ((dValueUp1 > High[iBar - 1] && dValueUp < dOpen) || // The Open price jumps above the indicator
(dValueUp1 <Low[iBar - 1] && dValueUp> dOpen) || // The Open price jumps below the indicator
(Close[iBar - 1] < dValueUp && dValueUp < dOpen) || // The Open price is in a positive gap
(Close[iBar - 1] > dValueUp && dValueUp > dOpen)) // The Open price is in a negative gap
{
dTempValUp = dOpen; // The entry/exit level is moved to Open price
}
// Lower band
double dValueDown = adDnBand[iBar - iPrvs]; // Current value
double dValueDown1 = adDnBand[iBar - iPrvs - 1]; // Previous value
double dTempValDown = dValueDown;
if ((dValueDown1 > High[iBar - 1] && dValueDown < dOpen) || // The Open price jumps above the indicator
(dValueDown1 <Low[iBar - 1] && dValueDown> dOpen) || // The Open price jumps below the indicator
(Close[iBar - 1] < dValueDown && dValueDown < dOpen) || // The Open price is in a positive gap
(Close[iBar - 1] > dValueDown && dValueDown > dOpen)) // The Open price is in a negative gap
{
dTempValDown = dOpen; // The entry/exit level is moved to Open price
}
if (IndParam.ListParam[0].Text == "Enter long at the Upper Band" ||
IndParam.ListParam[0].Text == "Exit long at the Upper Band")
{
Component[3].Value[iBar] = dTempValUp;
Component[4].Value[iBar] = dTempValDown;
}
else
{
Component[3].Value[iBar] = dTempValDown;
Component[4].Value[iBar] = dTempValUp;
}
}
}
else
{
for (int iBar = 2; iBar < Bars; iBar++)
{
if (IndParam.ListParam[0].Text == "Enter long at the Upper Band" ||
IndParam.ListParam[0].Text == "Exit long at the Upper Band")
{
Component[3].Value[iBar] = adUpBand[iBar - iPrvs];
Component[4].Value[iBar] = adDnBand[iBar - iPrvs];
}
else
{
Component[3].Value[iBar] = adDnBand[iBar - iPrvs];
Component[4].Value[iBar] = adUpBand[iBar - iPrvs];
}
}
}
}
else
{
switch (IndParam.ListParam[0].Text)
{
case "The bar opens below the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Upper_Band);
break;
case "The bar opens above the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Upper_Band);
break;
case "The bar opens below the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Lower_Band);
break;
case "The bar opens above the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Lower_Band);
break;
case "The bar opens below the Upper Band after opening above it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Upper_Band_after_opening_above_it);
break;
case "The bar opens above the Upper Band after opening below it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Upper_Band_after_opening_below_it);
break;
case "The bar opens below the Lower Band after opening above it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_below_the_Lower_Band_after_opening_above_it);
break;
case "The bar opens above the Lower Band after opening below it":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_opens_above_the_Lower_Band_after_opening_below_it);
break;
case "The position opens above the Upper Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[2].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The position opens below the Upper Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[2].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The position opens above the Lower Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The position opens below the Lower Band":
Component[0].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[0].UsePreviousBar = iPrvs;
Component[2].UsePreviousBar = iPrvs;
Component[3].DataType = IndComponentType.Other;
Component[4].DataType = IndComponentType.Other;
Component[3].ShowInDynInfo = false;
Component[4].ShowInDynInfo = false;
break;
case "The bar closes below the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_below_the_Upper_Band);
break;
case "The bar closes above the Upper Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_above_the_Upper_Band);
break;
case "The bar closes below the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_below_the_Lower_Band);
break;
case "The bar closes above the Lower Band":
BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[3], ref Component[4], BandIndLogic.The_bar_closes_above_the_Lower_Band);
break;
default:
break;
}
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iPeriod = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
int iFirstBar = iPeriod + iPrvs;
// Calculating Money Flow
double[] adMF = new double[Bars];
for (int iBar = 1; iBar < Bars; iBar++)
{
double dAVG = (High[iBar] + Low[iBar] + Close[iBar]) / 3;
double dAVG1 = (High[iBar - 1] + Low[iBar - 1] + Close[iBar - 1]) / 3;
if (dAVG > dAVG1)
{
adMF[iBar] = adMF[iBar - 1] + dAVG * Volume[iBar];
}
else if (dAVG < dAVG1)
{
adMF[iBar] = adMF[iBar - 1] - dAVG * Volume[iBar];
}
else
{
adMF[iBar] = adMF[iBar - 1];
}
}
// Calculating Money Flow Index
double[] adMFI = new double[Bars];
for (int iBar = iPeriod + 1; iBar < Bars; iBar++)
{
double dPMF = 0;
double dNMF = 0;
for (int index = 0; index < iPeriod; index++)
{
if (adMF[iBar - index] > adMF[iBar - index - 1])
{
dPMF += adMF[iBar - index] - adMF[iBar - index - 1];
}
if (adMF[iBar - index] < adMF[iBar - index - 1])
{
dNMF += adMF[iBar - index - 1] - adMF[iBar - index];
}
}
if (dNMF == 0)
{
adMFI[iBar] = 100.0;
}
else
{
adMFI[iBar] = 100.0 - (100.0 / (1.0 + (dPMF / dNMF)));
}
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Money Flow Index";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adMFI;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The MFI rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] {
50
};
break;
case "The MFI falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] {
50
};
break;
case "The MFI is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The MFI is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The MFI crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The MFI crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The MFI changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] {
50
};
break;
case "The MFI changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] {
50
};
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adMFI, dLevel, 100 - dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iPeriod = (int)IndParam.NumParam[0].Value;
int dLevel = (int)IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod + 2;
double[] adOBOS = new double[Bars];
double dMin = double.MaxValue;
double dMax = double.MinValue;
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
dMin = double.MaxValue;
dMax = double.MinValue;
for (int index = 0; index < iPeriod; index++)
{
if (High[iBar - index] > dMax)
{
dMax = High[iBar - index];
}
if (Low[iBar - index] < dMin)
{
dMin = Low[iBar - index];
}
}
adOBOS[iBar] = 100 * (Close[iBar] - dMin) / (dMax - dMin);
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "OBOS";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Brown;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adOBOS;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Overbought Oversold Index rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] {
50
};
break;
case "The Overbought Oversold Index falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] {
50
};
break;
case "The Overbought Oversold Index is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The Overbought Oversold Index is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The Overbought Oversold Index crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The Overbought Oversold Index crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] {
dLevel, 100 - dLevel
};
break;
case "The Overbought Oversold Index changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] {
50
};
break;
case "The Overbought Oversold Index changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] {
50
};
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adOBOS, dLevel, 100 - dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
double[] adHAOpen = new double[Bars];
double[] adHAHigh = new double[Bars];
double[] adHALow = new double[Bars];
double[] adHAClose = new double[Bars];
adHAOpen[0] = Open[0];
adHAHigh[0] = High[0];
adHALow[0] = Low[0];
adHAClose[0] = Close[0];
int iFirstBar = 1 + iPrvs;
for (int iBar = 1; iBar < Bars; iBar++)
{
adHAClose[iBar] = (Open[iBar] + High[iBar] + Low[iBar] + Close[iBar]) / 4;
adHAOpen[iBar] = (adHAOpen[iBar - 1] + adHAClose[iBar - 1]) / 2;
adHAHigh[iBar] = High[iBar] > adHAOpen[iBar] ? High[iBar] : adHAOpen[iBar];
adHAHigh[iBar] = adHAClose[iBar] > adHAHigh[iBar] ? adHAClose[iBar] : adHAHigh[iBar];
adHALow[iBar] = Low[iBar] < adHAOpen[iBar] ? Low[iBar] : adHAOpen[iBar];
adHALow[iBar] = adHAClose[iBar] < adHALow[iBar] ? adHAClose[iBar] : adHALow[iBar];
}
// Saving the components
Component = new IndicatorComp[6];
Component[0] = new IndicatorComp();
Component[0].CompName = "H.A. Open";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Dot;
Component[0].ChartColor = Color.Green;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adHAOpen;
Component[1] = new IndicatorComp();
Component[1].CompName = "H.A. High";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Dot;
Component[1].ChartColor = Color.Blue;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adHAHigh;
Component[2] = new IndicatorComp();
Component[2].CompName = "H.A. Low";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Dot;
Component[2].ChartColor = Color.Blue;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adHALow;
Component[3] = new IndicatorComp();
Component[3].CompName = "H.A. Close";
Component[3].DataType = IndComponentType.IndicatorValue;
Component[3].ChartType = IndChartType.Dot;
Component[3].ChartColor = Color.Red;
Component[3].FirstBar = iFirstBar;
Component[3].Value = adHAClose;
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
Component[5] = new IndicatorComp();
Component[5].ChartType = IndChartType.NoChart;
Component[5].FirstBar = iFirstBar;
Component[5].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.Open)
{
Component[4].DataType = IndComponentType.OpenLongPrice;
Component[4].CompName = "Long position entry price";
Component[5].DataType = IndComponentType.OpenShortPrice;
Component[5].CompName = "Short position entry price";
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[4].DataType = IndComponentType.AllowOpenLong;
Component[4].CompName = "Is long entry allowed";
Component[5].DataType = IndComponentType.AllowOpenShort;
Component[5].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.Close)
{
Component[4].DataType = IndComponentType.CloseLongPrice;
Component[4].CompName = "Long position closing price";
Component[5].DataType = IndComponentType.CloseShortPrice;
Component[5].CompName = "Short position closing price";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[4].DataType = IndComponentType.ForceCloseLong;
Component[4].CompName = "Close out long position";
Component[5].DataType = IndComponentType.ForceCloseShort;
Component[5].CompName = "Close out short position";
}
if (slotType == SlotTypes.Open || slotType == SlotTypes.Close)
{
for (int iBar = 2; iBar < Bars; iBar++)
{
if (IndParam.ListParam[0].Text == "Enter long at the H.A. High" ||
IndParam.ListParam[0].Text == "Exit long at the H.A. High")
{
Component[4].Value[iBar] = adHAHigh[iBar - iPrvs];
Component[5].Value[iBar] = adHALow[iBar - iPrvs];
}
else
{
Component[4].Value[iBar] = adHALow[iBar - iPrvs];
Component[5].Value[iBar] = adHAHigh[iBar - iPrvs];
}
}
}
else
{
switch (IndParam.ListParam[0].Text)
{
case "White H.A. bar without lower shadow":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[4].Value[iBar] = adHAClose[iBar - iPrvs] > adHAOpen[iBar - iPrvs] &&
adHALow[iBar - iPrvs] == adHAOpen[iBar - iPrvs] ? 1 : 0;
Component[5].Value[iBar] = adHAClose[iBar - iPrvs] < adHAOpen[iBar - iPrvs] &&
adHAHigh[iBar - iPrvs] == adHAOpen[iBar - iPrvs] ? 1 : 0;
}
break;
case "White H.A. bar":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[4].Value[iBar] = adHAClose[iBar - iPrvs] > adHAOpen[iBar - iPrvs] ? 1 : 0;
Component[5].Value[iBar] = adHAClose[iBar - iPrvs] < adHAOpen[iBar - iPrvs] ? 1 : 0;
}
break;
case "Black H.A. bar":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[4].Value[iBar] = adHAClose[iBar - iPrvs] < adHAOpen[iBar - iPrvs] ? 1 : 0;
Component[5].Value[iBar] = adHAClose[iBar - iPrvs] > adHAOpen[iBar - iPrvs] ? 1 : 0;
}
break;
case "Black H.A. bar without upper shadow":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[4].Value[iBar] = adHAClose[iBar - iPrvs] < adHAOpen[iBar - iPrvs] &&
adHAHigh[iBar - iPrvs] == adHAOpen[iBar - iPrvs] ? 1 : 0;
Component[5].Value[iBar] = adHAClose[iBar - iPrvs] > adHAOpen[iBar - iPrvs] &&
adHALow[iBar - iPrvs] == adHAOpen[iBar - iPrvs] ? 1 : 0;
}
break;
default:
break;
}
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int iK = (int)IndParam.NumParam[0].Value;
int iDFast = (int)IndParam.NumParam[1].Value;
int iDSlow = (int)IndParam.NumParam[2].Value;
int iLevel = (int)IndParam.NumParam[3].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iK + iDFast + iDSlow + 3;
double[] adHighs = new double[Bars];
double[] adLows = new double[Bars];
for (int iBar = 0; iBar < iK; iBar++)
{
double dMin = double.MaxValue;
double dMax = double.MinValue;
for (int i = 0; i < iBar; i++)
{
if (High[iBar - i] > dMax) dMax = High[iBar - i];
if (Low[iBar - i] < dMin) dMin = Low[iBar - i];
}
adHighs[iBar] = dMax;
adLows[iBar] = dMin;
}
adHighs[0] = High[0];
adLows[0] = Low[0];
for (int iBar = iK; iBar < Bars; iBar++)
{
double dMin = double.MaxValue;
double dMax = double.MinValue;
for (int i = 0; i < iK; i++)
{
if (High[iBar - i] > dMax) dMax = High[iBar - i];
if (Low[iBar - i] < dMin) dMin = Low[iBar - i];
}
adHighs[iBar] = dMax;
adLows[iBar] = dMin;
}
double[] adK = new double[Bars];
for (int iBar = iK; iBar < Bars; iBar++)
{
if (adHighs[iBar] == adLows[iBar])
adK[iBar] = 50;
else
adK[iBar] = 100 * (Close[iBar] - adLows[iBar]) / (adHighs[iBar] - adLows[iBar]);
}
double[] adDFast = new double[Bars];
for (int iBar = iDFast; iBar < Bars; iBar++)
{
double dSumHigh = 0;
double dSumLow = 0;
for (int i = 0; i < iDFast; i++)
{
dSumLow += Close[iBar - i] - adLows[iBar - i];
dSumHigh += adHighs[iBar - i] - adLows[iBar - i];
}
if (dSumHigh == 0)
adDFast[iBar] = 100;
else
adDFast[iBar] = 100 * dSumLow / dSumHigh;
}
double[] adDSlow = MovingAverage(iDSlow, 0, maMethod, adDFast);
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "%K";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Brown;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adK;
Component[1] = new IndicatorComp();
Component[1].CompName = "Fast %D";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Gold;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adDFast;
Component[2] = new IndicatorComp();
Component[2].CompName = "Slow %D";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Blue;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adDSlow;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
if (IndParam.ListParam[0].Text == "The %K crosses the Slow %D upward")
{
SpecialValues = new double[1] { 50 };
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs,adK, adDSlow, ref Component[3], ref Component[4]);
return;
}
else if (IndParam.ListParam[0].Text == "The %K crosses the Slow %D downward")
{
SpecialValues = new double[1] { 50 };
IndicatorCrossesAnotherIndicatorDownwardLogic(iFirstBar, iPrvs, adK, adDSlow, ref Component[3], ref Component[4]);
return;
}
else if (IndParam.ListParam[0].Text == "The %K is higher than the Slow %D")
{
SpecialValues = new double[1] { 50 };
IndicatorIsHigherThanAnotherIndicatorLogic(iFirstBar, iPrvs, adK, adDSlow, ref Component[3], ref Component[4]);
return;
}
else if (IndParam.ListParam[0].Text == "The %K is lower than the Slow %D")
{
SpecialValues = new double[1] { 50 };
IndicatorIsLowerThanAnotherIndicatorLogic(iFirstBar, iPrvs, adK, adDSlow, ref Component[3], ref Component[4]);
return;
}
else
{
switch (IndParam.ListParam[0].Text)
{
case "The Slow %D rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] { 50 };
break;
case "The Slow %D falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] { 50 };
break;
case "The Slow %D is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] { iLevel, 100 - iLevel };
break;
case "The Slow %D is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] { iLevel, 100 - iLevel };
break;
case "The Slow %D crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] { iLevel, 100 - iLevel };
break;
case "The Slow %D crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] { iLevel, 100 - iLevel };
break;
case "The Slow %D changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] { 50 };
break;
case "The Slow %D changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] { 50 };
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adDSlow, iLevel, 100 - iLevel, ref Component[3], ref Component[4], indLogic);
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int prev = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int firstBar = 3;
double[] AD = new double[Bars];
AD[0] = (Close[0] - Low[0]) - (High[0] - Close[0]);
if ((High[0] - Low[0]) > 0)
AD[0] = AD[0] / (High[0] - Low[0]) * Volume[0];
else
AD[0] = 0;
for (int bar = 1; bar < Bars; bar++)
{
double delta = 0;
double range = High[bar] - Low[bar];
if (range > 0)
delta = Volume[bar] * (2 * Close[bar] - High[bar] - Low[bar]) / range;
AD[bar] = AD[bar - 1] + delta;
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Accumulation Distribution";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = firstBar;
Component[0].Value = AD;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = firstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = firstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The AD rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The AD falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The AD changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The AD changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
OscillatorLogic(firstBar, prev, AD, 0, 0, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
int iTenkan = (int)IndParam.NumParam[0].Value;
int iKijun = (int)IndParam.NumParam[2].Value;
int iSenkou = (int)IndParam.NumParam[4].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
double[] adMedianPrice = Price(BasePrice.Median);
int iFirstBar = 1 + iKijun + iSenkou;
double[] adTenkanSen = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iTenkan; i++)
{
if (High[iBar - i] > dHighestHigh)
dHighestHigh = High[iBar - i];
if (Low[iBar - i] < dLowestLow)
dLowestLow = Low[iBar - i];
}
adTenkanSen[iBar] = (dHighestHigh + dLowestLow) / 2;
}
double[] adKijunSen = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iKijun; i++)
{
if (High[iBar - i] > dHighestHigh)
dHighestHigh = High[iBar - i];
if (Low[iBar - i] < dLowestLow)
dLowestLow = Low[iBar - i];
}
adKijunSen[iBar] = (dHighestHigh + dLowestLow) / 2;
}
double[] adChikouSpan = new double[Bars];
for (int iBar = 0; iBar < Bars - iKijun; iBar++)
{
adChikouSpan[iBar] = Close[iBar + iKijun];
}
double[] adSenkouSpanA = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars - iKijun; iBar++)
{
adSenkouSpanA[iBar + iKijun] = (adTenkanSen[iBar] + adKijunSen[iBar]) / 2;
}
double[] adSenkouSpanB = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars - iKijun; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iSenkou; i++)
{
if (High[iBar - i] > dHighestHigh)
dHighestHigh = High[iBar - i];
if (Low[iBar - i] < dLowestLow)
dLowestLow = Low[iBar - i];
}
adSenkouSpanB[iBar + iKijun] = (dHighestHigh + dLowestLow) / 2;
}
// Saving the components
if (slotType == SlotTypes.OpenFilter)
Component = new IndicatorComp[7];
else
Component = new IndicatorComp[6];
Component[0] = new IndicatorComp();
Component[0].CompName = "Tenkan Sen";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Red;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adTenkanSen;
Component[1] = new IndicatorComp();
Component[1].CompName = "Kijun Sen";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Blue;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adKijunSen;
Component[2] = new IndicatorComp();
Component[2].CompName = "Chikou Span";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Green;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adChikouSpan;
Component[3] = new IndicatorComp();
Component[3].CompName = "Senkou Span A";
Component[3].DataType = IndComponentType.IndicatorValue;
Component[3].ChartType = IndChartType.CloudUp;
Component[3].ChartColor = Color.SandyBrown;
Component[3].FirstBar = iFirstBar;
Component[3].Value = adSenkouSpanA;
Component[4] = new IndicatorComp();
Component[4].CompName = "Senkou Span B";
Component[4].DataType = IndComponentType.IndicatorValue;
Component[4].ChartType = IndChartType.CloudDown;
Component[4].ChartColor = Color.Thistle;
Component[4].FirstBar = iFirstBar;
Component[4].Value = adSenkouSpanB;
Component[5] = new IndicatorComp();
Component[5].FirstBar = iFirstBar;
Component[5].Value = new double[Bars];
Component[5].DataType = IndComponentType.Other;
if (slotType == SlotTypes.OpenFilter)
{
Component[5].CompName = "Is long entry allowed";
Component[5].DataType = IndComponentType.AllowOpenLong;
Component[6] = new IndicatorComp();
Component[6].FirstBar = iFirstBar;
Component[6].Value = new double[Bars];
Component[6].CompName = "Is short entry allowed";
Component[6].DataType = IndComponentType.AllowOpenShort;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter the market at the Tenkan Sen":
Component[5].CompName = "Tenkan Sen entry price";
Component[5].DataType = IndComponentType.OpenPrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs];
}
break;
case "Enter the market at the Kijun Sen":
Component[5].CompName = "Kijun Sen entry price";
Component[5].DataType = IndComponentType.OpenPrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs];
}
break;
case "Exit the market at the Tenkan Sen":
Component[5].CompName = "Tenkan Sen exit price";
Component[5].DataType = IndComponentType.ClosePrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs];
}
break;
case "Exit the market at the Kijun Sen":
Component[5].CompName = "Kijun Sen exit price";
Component[5].DataType = IndComponentType.ClosePrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs];
}
break;
case "The Tenkan Sen rises":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs] > adTenkanSen[iBar - iPrvs - 1] + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adTenkanSen[iBar - iPrvs] < adTenkanSen[iBar - iPrvs - 1] - Sigma() ? 1 : 0;
}
break;
case "The Kijun Sen rises":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs] > adKijunSen[iBar - iPrvs - 1] + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adKijunSen[iBar - iPrvs] < adKijunSen[iBar - iPrvs - 1] - Sigma() ? 1 : 0;
}
break;
case "The Tenkan Sen is higher than the Kijun Sen":
IndicatorIsHigherThanAnotherIndicatorLogic(iFirstBar, iPrvs, adTenkanSen, adKijunSen, ref Component[5], ref Component[6]);
break;
case "The Tenkan Sen crosses the Kijun Sen upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adTenkanSen, adKijunSen, ref Component[5], ref Component[6]);
break;
case "The bar opens above the Tenkan Sen":
BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adTenkanSen, ref Component[5], ref Component[6]);
break;
case "The bar opens above the Kijun Sen":
BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adKijunSen, ref Component[5], ref Component[6]);
break;
case "The Chikou Span is above the closing price":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adChikouSpan[iBar - iKijun - iPrvs] > Close[iBar - iKijun - iPrvs] + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adChikouSpan[iBar - iKijun - iPrvs] < Close[iBar - iKijun - iPrvs] - Sigma() ? 1 : 0;
}
break;
case "The position opens above the Kumo":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = Math.Max(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
Component[6].Value[iBar] = Math.Min(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
}
Component[5].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[5].DataType = IndComponentType.Other;
Component[5].UsePreviousBar = iPrvs;
Component[5].ShowInDynInfo = false;
Component[6].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[6].DataType = IndComponentType.Other;
Component[6].UsePreviousBar = iPrvs;
Component[6].ShowInDynInfo = false;
break;
case "The position opens inside or above the Kumo":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = Math.Min(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
Component[6].Value[iBar] = Math.Max(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
}
Component[5].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[5].DataType = IndComponentType.Other;
Component[5].UsePreviousBar = iPrvs;
Component[5].ShowInDynInfo = false;
Component[6].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[6].DataType = IndComponentType.Other;
Component[6].UsePreviousBar = iPrvs;
Component[6].ShowInDynInfo = false;
break;
case "The Tenkan Sen is above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs] > Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adTenkanSen[iBar - iPrvs] < Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Tenkan Sen is inside or above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs] > Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adTenkanSen[iBar - iPrvs] < Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Kijun Sen is above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs] > Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adKijunSen[iBar - iPrvs] < Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Kijun Sen is inside or above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs] > Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adKijunSen[iBar - iPrvs] < Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Senkou Span A is higher than the Senkou Span B":
IndicatorIsHigherThanAnotherIndicatorLogic(iFirstBar, iPrvs, adSenkouSpanA, adSenkouSpanB, ref Component[5], ref Component[6]);
break;
case "The Senkou Span A crosses the Senkou Span B upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adSenkouSpanA, adSenkouSpanB, ref Component[5], ref Component[6]);
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iSense = (int)IndParam.NumParam[0].Value;
int iFirstBar = iSense;
double[] adFibo0;
double[] adFibo382;
double[] adFibo50;
double[] adFibo618;
double[] adFibo100;
bool bReverseLogic = (IndParam.ListParam[1].Text == "Retracement");
int iDeviation = 5;
int iBackStep = 3;
double[] adHighPoint = new double[Bars];
double[] adLowPoint = new double[Bars];
adFibo0 = new double[Bars];
adFibo382 = new double[Bars];
adFibo50 = new double[Bars];
adFibo618 = new double[Bars];
adFibo100 = new double[Bars];
double dLastHigh = 0;
double dLastLow = 0;
for (int iBar = iSense; iBar < Bars; iBar++)
{
// The highest High in the period [iBar-iSence, iBar]
double dHigh = 0;
for (int iShift = 0; iShift < iSense; iShift++)
{
if (dHigh < High[iBar - iShift])
{
dHigh = High[iBar - iShift];
}
}
if (dHigh == dLastHigh)
{
dHigh = 0;
}
else
{
dLastHigh = dHigh;
if (dHigh - High[iBar] > iDeviation * Point)
{
dHigh = 0;
}
else
{
for (int iBack = 1; iBack <= iBackStep; iBack++)
{
if (adHighPoint[iBar - iBack] > 0 && adHighPoint[iBar - iBack] < dHigh)
{
adHighPoint[iBar - iBack] = 0;
}
}
}
}
adHighPoint[iBar] = dHigh;
// The lowest Low in the period [iBar-iSence, iBar]
double dLow = 10000;
for (int iShift = 0; iShift < iSense; iShift++)
{
if (Low[iBar - iShift] < dLow)
{
dLow = Low[iBar - iShift];
}
}
if (dLow == dLastLow)
{
dLow = 0;
}
else
{
dLastLow = dLow;
if (Low[iBar] - dLow > iDeviation * Point)
{
dLow = 0;
}
else
{
for (int iBack = 1; iBack <= iBackStep; iBack++)
{
if (adLowPoint[iBar - iBack] > 0 && adLowPoint[iBar - iBack] > dLow)
{
adLowPoint[iBar - iBack] = 0;
}
}
}
}
adLowPoint[iBar] = dLow;
}
int iLastHighBar = -1;
int iLastLowBar = -1;
double dCurHigh;
double dCurLow;
dLastHigh = -1;
dLastLow = -1;
for (int iBar = iSense; iBar < Bars; iBar++)
{
dCurHigh = adHighPoint[iBar];
dCurLow = adLowPoint[iBar];
if (dCurLow == 0 && dCurHigh == 0)
{
continue;
}
if (dCurHigh != 0)
{
if (dLastHigh > 0)
{
if (dLastHigh < dCurHigh)
{
adHighPoint[iLastHighBar] = 0;
}
else
{
adHighPoint[iBar] = 0;
}
}
if (dLastHigh < dCurHigh || dLastHigh < 0)
{
dLastHigh = dCurHigh;
iLastHighBar = iBar;
}
dLastLow = -1;
}
if (dCurLow != 0)
{
if (dLastLow > 0)
{
if (dLastLow > dCurLow)
{
adLowPoint[iLastLowBar] = 0;
}
else
{
adLowPoint[iBar] = 0;
}
}
if (dCurLow < dLastLow || dLastLow < 0)
{
dLastLow = dCurLow;
iLastLowBar = iBar;
}
dLastHigh = -1;
}
}
dLastHigh = 0;
dLastLow = 0;
int iFirstLowBar = 0;
int iFirstHighBar = 0;
for (int iBar = 0; iBar < Bars; iBar++)
{
if (adHighPoint[iBar] > 0)
{
dLastHigh = adHighPoint[iBar];
iFirstHighBar = iBar;
}
if (adLowPoint[iBar] > 0)
{
dLastLow = adLowPoint[iBar];
iFirstLowBar = iBar;
}
if (iFirstHighBar > 0 && iFirstLowBar > 0)
{
break;
}
}
for (int iBar = Math.Max(iFirstLowBar, iFirstHighBar); iBar < Bars; iBar++)
{
if (adHighPoint[iBar - 1] > 0)
{
dLastHigh = adHighPoint[iBar - 1];
adFibo0 [iBar] = dLastHigh;
adFibo382[iBar] = dLastHigh - (dLastHigh - dLastLow) * 0.382;
adFibo50 [iBar] = dLastHigh - (dLastHigh - dLastLow) * 0.500;
adFibo618[iBar] = dLastHigh - (dLastHigh - dLastLow) * 0.618;
adFibo100[iBar] = dLastLow;
}
else if (adLowPoint[iBar - 1] > 0)
{
dLastLow = adLowPoint[iBar - 1];
adFibo0 [iBar] = dLastLow;
adFibo382[iBar] = dLastLow + (dLastHigh - dLastLow) * 0.382;
adFibo50 [iBar] = dLastLow + (dLastHigh - dLastLow) * 0.500;
adFibo618[iBar] = dLastLow + (dLastHigh - dLastLow) * 0.618;
adFibo100[iBar] = dLastHigh;
}
else
{
adFibo0 [iBar] = adFibo0 [iBar - 1];
adFibo382[iBar] = adFibo382[iBar - 1];
adFibo50 [iBar] = adFibo50 [iBar - 1];
adFibo618[iBar] = adFibo618[iBar - 1];
adFibo100[iBar] = adFibo100[iBar - 1];
}
}
// Saving the components
Component = new IndicatorComp[8];
Component[0] = new IndicatorComp();
Component[0].CompName = "Position entry price";
Component[0].DataType = IndComponentType.OpenPrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].FirstBar = iFirstBar;
Component[0].Value = new double[Bars];
Component[1] = new IndicatorComp();
Component[1].CompName = "Fibonacci retracement 0%";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.Green;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adFibo0;
Component[2] = new IndicatorComp();
Component[2].CompName = "Fibonacci retracement 38.2%";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Level;
Component[2].ChartColor = Color.Gold;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adFibo382;
Component[3] = new IndicatorComp();
Component[3].CompName = "Fibonacci retracement 50%";
Component[3].DataType = IndComponentType.IndicatorValue;
Component[3].ChartType = IndChartType.Level;
Component[3].ChartColor = Color.Orchid;
Component[3].FirstBar = iFirstBar;
Component[3].Value = adFibo50;
Component[4] = new IndicatorComp();
Component[4].CompName = "Fibonacci retracement 61.8%";
Component[4].DataType = IndComponentType.IndicatorValue;
Component[4].ChartType = IndChartType.Level;
Component[4].ChartColor = Color.Purple;
Component[4].FirstBar = iFirstBar;
Component[4].Value = adFibo618;
Component[5] = new IndicatorComp();
Component[5].CompName = "Fibonacci retracement 100%";
Component[5].DataType = IndComponentType.IndicatorValue;
Component[5].ChartType = IndChartType.Level;
Component[5].ChartColor = Color.Red;
Component[5].FirstBar = iFirstBar;
Component[5].Value = adFibo100;
Component[6] = new IndicatorComp();
Component[6].CompName = "Is long entry allowed";
Component[6].DataType = IndComponentType.AllowOpenLong;
Component[6].ChartType = IndChartType.NoChart;
Component[6].FirstBar = iFirstBar;
Component[6].Value = new double[Bars];
Component[7] = new IndicatorComp();
Component[7].CompName = "Is short entry allowed";
Component[7].DataType = IndComponentType.AllowOpenShort;
Component[7].ChartType = IndChartType.NoChart;
Component[7].FirstBar = iFirstBar;
Component[7].Value = new double[Bars];
int iBarFibo382Reached = 0;
int iBarFibo500Reached = 0;
int iBarFibo618Reached = 0;
int iBarFibo100Reached = 0;
for (int iBar = Math.Max(iFirstLowBar, iFirstHighBar); iBar < Bars; iBar++)
{
Component[0].Value[iBar] = 0;
// Reset
if (adHighPoint[iBar - 1] > 0 || adLowPoint[iBar - 1] > 0)
{
iBarFibo382Reached = 0;
iBarFibo500Reached = 0;
iBarFibo618Reached = 0;
iBarFibo100Reached = 0;
}
// Up trend
if (adFibo0[iBar] < adFibo100[iBar])
{
if (iBarFibo382Reached == 0 && Low[iBar] <= adFibo382[iBar] && High[iBar] >= adFibo382[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
Component[0].Value[iBar] = adFibo382[iBar];
iBarFibo382Reached = iBar;
}
if (iBarFibo500Reached == 0 && Low[iBar] <= adFibo50[iBar] && High[iBar] >= adFibo50[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
if (iBarFibo382Reached != iBar)
{
Component[0].Value[iBar] = adFibo50[iBar];
}
iBarFibo500Reached = iBar;
}
if (iBarFibo618Reached == 0 && Low[iBar] <= adFibo618[iBar] && High[iBar] >= adFibo618[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
if (iBarFibo500Reached != iBar)
{
Component[0].Value[iBar] = adFibo618[iBar];
}
iBarFibo618Reached = iBar;
}
if (iBarFibo100Reached == 0 && Low[iBar] <= adFibo100[iBar] && High[iBar] >= adFibo100[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 0 : 1;
Component[7].Value[iBar] = bReverseLogic ? 1 : 0;
if (iBarFibo618Reached != iBar)
{
Component[0].Value[iBar] = adFibo100[iBar];
}
iBarFibo100Reached = iBar;
}
}
// Down trend
if (adFibo0[iBar] > adFibo100[iBar])
{
if (iBarFibo382Reached == 0 && Low[iBar] <= adFibo382[iBar] && High[iBar] >= adFibo382[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
Component[0].Value[iBar] = adFibo382[iBar];
iBarFibo382Reached = iBar;
}
if (iBarFibo500Reached == 0 && Low[iBar] <= adFibo50[iBar] && High[iBar] >= adFibo50[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
if (iBarFibo382Reached != iBar)
{
Component[0].Value[iBar] = adFibo50[iBar];
}
iBarFibo500Reached = iBar;
}
if (iBarFibo618Reached == 0 && Low[iBar] <= adFibo618[iBar] && High[iBar] >= adFibo618[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
if (iBarFibo500Reached != iBar)
{
Component[0].Value[iBar] = adFibo618[iBar];
}
iBarFibo618Reached = iBar;
}
if (iBarFibo100Reached == 0 && Low[iBar] <= adFibo100[iBar] && High[iBar] >= adFibo100[iBar])
{
Component[6].Value[iBar] = bReverseLogic ? 1 : 0;
Component[7].Value[iBar] = bReverseLogic ? 0 : 1;
if (iBarFibo618Reached != iBar)
{
Component[0].Value[iBar] = adFibo100[iBar];
}
iBarFibo100Reached = iBar;
}
}
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod + 2;
double[] adMA = MovingAverage(iPeriod, 0, maMethod, Price(BasePrice.Close));
double[] adBulls = new double[Bars];
double[] adBears = new double[Bars];
double[] adBBP = new double[Bars];
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
adBulls[iBar] = High[iBar] - adMA[iBar];
adBears[iBar] = Low[iBar] - adMA[iBar];
adBBP[iBar] = adBulls[iBar] + adBears[iBar];
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Bulls Bears Power";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.RoyalBlue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBBP;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The BBP rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] { 0 };
break;
case "The BBP falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] { 0 };
break;
case "The BBP is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The BBP is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The BBP crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The BBP crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] { dLevel, -dLevel };
break;
case "The BBP changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] { 0 };
break;
case "The BBP changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] { 0 };
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adBBP, dLevel, -dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iFromHour = (int)IndParam.NumParam[0].Value;
int iFromMin = (int)IndParam.NumParam[1].Value;
int iUntilHour = (int)IndParam.NumParam[2].Value;
int iUntilMin = (int)IndParam.NumParam[3].Value;
TimeSpan tsFromTime = new TimeSpan(iFromHour, iFromMin, 0);
TimeSpan tsUntilTime = new TimeSpan(iUntilHour, iUntilMin, 0);
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if(tsFromTime < tsUntilTime)
adBars[iBar] = Time[iBar].TimeOfDay >= tsFromTime &&
Time[iBar].TimeOfDay < tsUntilTime ? 1 : 0;
else if(tsFromTime > tsUntilTime)
adBars[iBar] = Time[iBar].TimeOfDay >= tsFromTime ||
Time[iBar].TimeOfDay < tsUntilTime ? 1 : 0;
else
adBars[iBar] = 1;
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Is long entry allowed";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
Component[1] = new IndicatorComp();
Component[1].CompName = "Is short entry allowed";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
double dMultiplier = IndParam.NumParam[2].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod + 3;
double[] adBasePrice = Price(basePrice);
double[] adSMABasePrice = MovingAverage(iPeriod, 0, MAMethod.Simple, adBasePrice);
double dSum;
double[] adMeanDev = new double[Bars];
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
dSum = 0;
for (int i = 0; i < iPeriod; i++)
{
dSum += Math.Abs(adBasePrice[iBar - i] - adSMABasePrice[iBar]);
}
adMeanDev[iBar] = dMultiplier * dSum / iPeriod;
}
double[] adCCI = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (adMeanDev[iBar] != 0)
adCCI[iBar] = (adBasePrice[iBar] - adSMABasePrice[iBar]) / adMeanDev[iBar];
else
adCCI[iBar] = 0;
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "CCI";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.RoyalBlue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adCCI;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type.
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The CCI rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[3] { -100, 0, 100 };
break;
case "The CCI falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[3] { -100, 0, 100 };
break;
case "The CCI is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[3] { dLevel, 0, - dLevel };
break;
case "The CCI is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[3] { dLevel, 0, -dLevel };
break;
case "The CCI crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[3] { dLevel, 0, -dLevel };
break;
case "The CCI crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[3] { dLevel, 0, -dLevel };
break;
case "The CCI changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[3] { -100, 0, 100 };
break;
case "The CCI changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[3] { -100, 0, 100 };
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adCCI, dLevel, - dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
BasePrice price = (BasePrice)IndParam.ListParam[2].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
double[] adPrice = Price(price);
double[] adMA = MovingAverage(iPeriod, 0, maMethod, adPrice);
double[] adSTDV = new double[Bars];
int iFirstBar = iPeriod + 1;
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
double dSum = 0;
for (int index = 0; index < iPeriod; index++)
{
double fDelta = (adPrice[iBar - index] - adMA[iBar]);
dSum += fDelta * fDelta;
}
adSTDV[iBar] = Math.Sqrt(dSum / iPeriod);
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Standard Deviation";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adSTDV;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Standard Deviation rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The Standard Deviation falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The Standard Deviation is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[1] {
dLevel
};
break;
case "The Standard Deviation is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[1] {
dLevel
};
break;
case "The Standard Deviation crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[1] {
dLevel
};
break;
case "The Standard Deviation crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[1] {
dLevel
};
break;
case "The Standard Deviation changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The Standard Deviation changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
NoDirectionOscillatorLogic(iFirstBar, iPrvs, adSTDV, dLevel, ref Component[1], indLogic);
Component[2].Value = Component[1].Value;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int period = (int)IndParam.NumParam[0].Value;
int prev = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int firstBar = period + 2;
double[] DIPos = new double[Bars];
double[] DINeg = new double[Bars];
for (int bar = 1; bar < Bars; bar++)
{
double trueRange = Math.Max(High[bar], Close[bar - 1]) - Math.Min(Low[bar], Close[bar - 1]);
if (trueRange < Point)
{
trueRange = Point;
}
double deltaHigh = High[bar] - High[bar - 1];
double deltaLow = Low[bar - 1] - Low[bar];
if (deltaHigh > 0 && deltaHigh > deltaLow)
{
DIPos[bar] = 100 * deltaHigh / trueRange;
}
else
{
DIPos[bar] = 0;
}
if (deltaLow > 0 && deltaLow > deltaHigh)
{
DINeg[bar] = 100 * deltaLow / trueRange;
}
else
{
DINeg[bar] = 0;
}
}
double[] ADIPos = MovingAverage(period, 0, maMethod, DIPos);
double[] ADINeg = MovingAverage(period, 0, maMethod, DINeg);
double[] ADIOsc = new double[Bars];
for (int bar = 0; bar < Bars; bar++)
{
ADIOsc[bar] = ADIPos[bar] - ADINeg[bar];
}
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "The ADI+";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Green;
Component[0].FirstBar = firstBar;
Component[0].Value = ADIPos;
Component[1] = new IndicatorComp();
Component[1].CompName = "The ADI-";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Red;
Component[1].FirstBar = firstBar;
Component[1].Value = ADINeg;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = firstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = firstBar;
Component[3].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[2].DataType = IndComponentType.AllowOpenLong;
Component[2].CompName = "Is long entry allowed";
Component[3].DataType = IndComponentType.AllowOpenShort;
Component[3].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[2].DataType = IndComponentType.ForceCloseLong;
Component[2].CompName = "Close out long position";
Component[3].DataType = IndComponentType.ForceCloseShort;
Component[3].CompName = "Close out short position";
}
switch (IndParam.ListParam[0].Text)
{
case "The ADI+ rises":
OscillatorLogic(firstBar, prev, ADIPos, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_rises);
break;
case "The ADI+ falls":
OscillatorLogic(firstBar, prev, ADIPos, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_falls);
break;
case "The ADI- rises":
OscillatorLogic(firstBar, prev, ADINeg, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_rises);
break;
case "The ADI- falls":
OscillatorLogic(firstBar, prev, ADINeg, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_falls);
break;
case "The ADI+ is higher than ADI-":
OscillatorLogic(firstBar, prev, ADIOsc, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_is_higher_than_the_level_line);
break;
case "The ADI+ is lower than ADI-":
OscillatorLogic(firstBar, prev, ADIOsc, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_is_lower_than_the_level_line);
break;
case "The ADI+ crosses the ADI- line upward":
OscillatorLogic(firstBar, prev, ADIOsc, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_crosses_the_level_line_upward);
break;
case "The ADI+ crosses the ADI- line downward":
OscillatorLogic(firstBar, prev, ADIOsc, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_crosses_the_level_line_downward);
break;
case "The ADI+ changes its direction upward":
OscillatorLogic(firstBar, prev, ADIPos, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_changes_its_direction_upward);
break;
case "The ADI+ changes its direction downward":
OscillatorLogic(firstBar, prev, ADIPos, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_changes_its_direction_downward);
break;
case "The ADI- changes its direction upward":
OscillatorLogic(firstBar, prev, ADINeg, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_changes_its_direction_upward);
break;
case "The ADI- changes its direction downward":
OscillatorLogic(firstBar, prev, ADINeg, 0, 0, ref Component[2], ref Component[3], IndicatorLogic.The_indicator_changes_its_direction_downward);
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
BasePrice basePrice = (BasePrice)IndParam.ListParam[1].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod + 2;
double[] adPrice = Price(basePrice);
double[] adValue = new double[Bars];
for (int iBar = 0; iBar < iPeriod; iBar++)
{
adValue[iBar] = 0;
}
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iPeriod; i++)
{
if (adPrice[iBar - i] > dHighestHigh)
{
dHighestHigh = adPrice[iBar - i];
}
if (adPrice[iBar - i] < dLowestLow)
{
dLowestLow = adPrice[iBar - i];
}
}
if (dHighestHigh == dLowestLow)
{
dHighestHigh = dLowestLow + Point;
}
if (dHighestHigh - dLowestLow == 0.5)
{
dHighestHigh += Point;
}
adValue[iBar] = 0.33 * 2 * ((adPrice[iBar] - dLowestLow) / (dHighestHigh - dLowestLow) - 0.5) + 0.67 * adValue[iBar - 1];
}
double[] adFT = new double[Bars];
adFT[0] = 0;
for (int iBar = 1; iBar < Bars; iBar++)
{
adFT[iBar] = 0.5 * (double)Math.Log10((1 + adValue[iBar]) / (1 - adValue[iBar])) + 0.5 * adFT[iBar - 1];
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Fisher Transform";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adFT;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Fisher Transform rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The Fisher Transform falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The Fisher Transform is higher than the zero line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
break;
case "The Fisher Transform is lower than the zero line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
break;
case "The Fisher Transform crosses the zero line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
break;
case "The Fisher Transform crosses the zero line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
break;
case "The Fisher Transform changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The Fisher Transform changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adFT, 0, 0, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int iPeriod1 = (int)IndParam.NumParam[0].Value;
int iPeriod2 = (int)IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod1 + iPeriod2 + 2;
double[] adIndicator1 = new double[Bars];
double[] adIndicator2 = new double[Bars];
double[] adOscllator = new double[Bars];
// ---------------------------------------------------------
Average_True_Range ATR1 = new Average_True_Range(slotType);
ATR1.IndParam.ListParam[1].Index = IndParam.ListParam[1].Index;
ATR1.IndParam.NumParam[0].Value = IndParam.NumParam[0].Value;
ATR1.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked;
ATR1.Calculate(slotType);
Average_True_Range ATR2 = new Average_True_Range(slotType);
ATR2.IndParam.ListParam[1].Index = IndParam.ListParam[1].Index;
ATR2.IndParam.NumParam[0].Value = IndParam.NumParam[1].Value;
ATR2.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked;
ATR2.Calculate(slotType);
adIndicator1 = ATR1.Component[0].Value;
adIndicator2 = ATR2.Component[0].Value;
// ----------------------------------------------------------
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adOscllator[iBar] = adIndicator1[iBar] - adIndicator2[iBar];
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Histogram";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adOscllator;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Oscillator rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The Oscillator falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The Oscillator is higher than the zero line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
break;
case "The Oscillator is lower than the zero line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
break;
case "The Oscillator crosses the zero line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
break;
case "The Oscillator crosses the zero line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
break;
case "The Oscillator changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The Oscillator changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
NoDirectionOscillatorLogic(iFirstBar, iPrvs, adOscllator, 0, ref Component[1], indLogic);
Component[2].Value = Component[1].Value;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Calculation
double[] adPrevBarClosing = new double[Bars];
int iFirstBar = 1;
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adPrevBarClosing[iBar] = Close[iBar - 1];
}
// Saving the components
if (slotType == SlotTypes.Open || slotType == SlotTypes.Close)
{
Component = new IndicatorComp[1];
}
else
{
Component = new IndicatorComp[3];
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
}
Component[0] = new IndicatorComp();
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].CompName = "Previous Bar Closing";
Component[0].ChartType = IndChartType.NoChart;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adPrevBarClosing;
// Sets the Component's type
if (slotType == SlotTypes.Open)
{
Component[0].DataType = IndComponentType.OpenPrice;
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.Close)
{
Component[0].DataType = IndComponentType.ClosePrice;
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
if (slotType == SlotTypes.OpenFilter || slotType == SlotTypes.CloseFilter)
{
switch (IndParam.ListParam[0].Text)
{
case "The bar opens below the previous Bar Closing":
BarOpensBelowIndicatorLogic(iFirstBar, 0, adPrevBarClosing, ref Component[1], ref Component[2]);
break;
case "The bar opens above the previous Bar Closing":
BarOpensAboveIndicatorLogic(iFirstBar, 0, adPrevBarClosing, ref Component[1], ref Component[2]);
break;
case "The position opens above the previous Bar Closing":
Component[0].PosPriceDependence = PositionPriceDependence.BuyHigherSellLower;
Component[1].DataType = IndComponentType.Other;
Component[2].DataType = IndComponentType.Other;
Component[1].ShowInDynInfo = false;
Component[2].ShowInDynInfo = false;
break;
case "The position opens below the previous Bar Closing":
Component[0].PosPriceDependence = PositionPriceDependence.BuyLowerSelHigher;
Component[1].DataType = IndComponentType.Other;
Component[2].DataType = IndComponentType.Other;
Component[1].ShowInDynInfo = false;
Component[2].ShowInDynInfo = false;
break;
case "The bar closes below the previous Bar Closing":
BarClosesBelowIndicatorLogic(iFirstBar, 0, adPrevBarClosing, ref Component[1], ref Component[2]);
break;
case "The bar closes above the previous Bar Closing":
BarClosesAboveIndicatorLogic(iFirstBar, 0, adPrevBarClosing, ref Component[1], ref Component[2]);
break;
default:
break;
}
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
int iTenkan = (int)IndParam.NumParam[0].Value;
int iKijun = (int)IndParam.NumParam[2].Value;
int iSenkou = (int)IndParam.NumParam[4].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
double[] adMedianPrice = Price(BasePrice.Median);
int iFirstBar = 1 + iKijun + iSenkou;
double[] adTenkanSen = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iTenkan; i++)
{
if (High[iBar - i] > dHighestHigh)
{
dHighestHigh = High[iBar - i];
}
if (Low[iBar - i] < dLowestLow)
{
dLowestLow = Low[iBar - i];
}
}
adTenkanSen[iBar] = (dHighestHigh + dLowestLow) / 2;
}
double[] adKijunSen = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iKijun; i++)
{
if (High[iBar - i] > dHighestHigh)
{
dHighestHigh = High[iBar - i];
}
if (Low[iBar - i] < dLowestLow)
{
dLowestLow = Low[iBar - i];
}
}
adKijunSen[iBar] = (dHighestHigh + dLowestLow) / 2;
}
double[] adChikouSpan = new double[Bars];
for (int iBar = 0; iBar < Bars - iKijun; iBar++)
{
adChikouSpan[iBar] = Close[iBar + iKijun];
}
double[] adSenkouSpanA = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars - iKijun; iBar++)
{
adSenkouSpanA[iBar + iKijun] = (adTenkanSen[iBar] + adKijunSen[iBar]) / 2;
}
double[] adSenkouSpanB = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars - iKijun; iBar++)
{
double dHighestHigh = double.MinValue;
double dLowestLow = double.MaxValue;
for (int i = 0; i < iSenkou; i++)
{
if (High[iBar - i] > dHighestHigh)
{
dHighestHigh = High[iBar - i];
}
if (Low[iBar - i] < dLowestLow)
{
dLowestLow = Low[iBar - i];
}
}
adSenkouSpanB[iBar + iKijun] = (dHighestHigh + dLowestLow) / 2;
}
// Saving the components
if (slotType == SlotTypes.OpenFilter)
{
Component = new IndicatorComp[7];
}
else
{
Component = new IndicatorComp[6];
}
Component[0] = new IndicatorComp();
Component[0].CompName = "Tenkan Sen";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Red;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adTenkanSen;
Component[1] = new IndicatorComp();
Component[1].CompName = "Kijun Sen";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Blue;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adKijunSen;
Component[2] = new IndicatorComp();
Component[2].CompName = "Chikou Span";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Green;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adChikouSpan;
Component[3] = new IndicatorComp();
Component[3].CompName = "Senkou Span A";
Component[3].DataType = IndComponentType.IndicatorValue;
Component[3].ChartType = IndChartType.CloudUp;
Component[3].ChartColor = Color.SandyBrown;
Component[3].FirstBar = iFirstBar;
Component[3].Value = adSenkouSpanA;
Component[4] = new IndicatorComp();
Component[4].CompName = "Senkou Span B";
Component[4].DataType = IndComponentType.IndicatorValue;
Component[4].ChartType = IndChartType.CloudDown;
Component[4].ChartColor = Color.Thistle;
Component[4].FirstBar = iFirstBar;
Component[4].Value = adSenkouSpanB;
Component[5] = new IndicatorComp();
Component[5].FirstBar = iFirstBar;
Component[5].Value = new double[Bars];
Component[5].DataType = IndComponentType.Other;
if (slotType == SlotTypes.OpenFilter)
{
Component[5].CompName = "Is long entry allowed";
Component[5].DataType = IndComponentType.AllowOpenLong;
Component[6] = new IndicatorComp();
Component[6].FirstBar = iFirstBar;
Component[6].Value = new double[Bars];
Component[6].CompName = "Is short entry allowed";
Component[6].DataType = IndComponentType.AllowOpenShort;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter the market at the Tenkan Sen":
Component[5].CompName = "Tenkan Sen entry price";
Component[5].DataType = IndComponentType.OpenPrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs];
}
break;
case "Enter the market at the Kijun Sen":
Component[5].CompName = "Kijun Sen entry price";
Component[5].DataType = IndComponentType.OpenPrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs];
}
break;
case "Exit the market at the Tenkan Sen":
Component[5].CompName = "Tenkan Sen exit price";
Component[5].DataType = IndComponentType.ClosePrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs];
}
break;
case "Exit the market at the Kijun Sen":
Component[5].CompName = "Kijun Sen exit price";
Component[5].DataType = IndComponentType.ClosePrice;
Component[5].ChartType = IndChartType.NoChart;
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs];
}
break;
case "The Tenkan Sen rises":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs] > adTenkanSen[iBar - iPrvs - 1] + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adTenkanSen[iBar - iPrvs] < adTenkanSen[iBar - iPrvs - 1] - Sigma() ? 1 : 0;
}
break;
case "The Kijun Sen rises":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs] > adKijunSen[iBar - iPrvs - 1] + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adKijunSen[iBar - iPrvs] < adKijunSen[iBar - iPrvs - 1] - Sigma() ? 1 : 0;
}
break;
case "The Tenkan Sen is higher than the Kijun Sen":
IndicatorIsHigherThanAnotherIndicatorLogic(iFirstBar, iPrvs, adTenkanSen, adKijunSen, ref Component[5], ref Component[6]);
break;
case "The Tenkan Sen crosses the Kijun Sen upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adTenkanSen, adKijunSen, ref Component[5], ref Component[6]);
break;
case "The bar opens above the Tenkan Sen":
BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adTenkanSen, ref Component[5], ref Component[6]);
break;
case "The bar opens above the Kijun Sen":
BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adKijunSen, ref Component[5], ref Component[6]);
break;
case "The Chikou Span is above the closing price":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adChikouSpan[iBar - iKijun - iPrvs] > Close[iBar - iKijun - iPrvs] + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adChikouSpan[iBar - iKijun - iPrvs] < Close[iBar - iKijun - iPrvs] - Sigma() ? 1 : 0;
}
break;
case "The position opens above the Kumo":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = Math.Max(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
Component[6].Value[iBar] = Math.Min(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
}
Component[5].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[5].DataType = IndComponentType.Other;
Component[5].UsePreviousBar = iPrvs;
Component[5].ShowInDynInfo = false;
Component[6].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[6].DataType = IndComponentType.Other;
Component[6].UsePreviousBar = iPrvs;
Component[6].ShowInDynInfo = false;
break;
case "The position opens inside or above the Kumo":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = Math.Min(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
Component[6].Value[iBar] = Math.Max(adSenkouSpanA[iBar], adSenkouSpanB[iBar]);
}
Component[5].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[5].DataType = IndComponentType.Other;
Component[5].UsePreviousBar = iPrvs;
Component[5].ShowInDynInfo = false;
Component[6].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[6].DataType = IndComponentType.Other;
Component[6].UsePreviousBar = iPrvs;
Component[6].ShowInDynInfo = false;
break;
case "The Tenkan Sen is above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs] > Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adTenkanSen[iBar - iPrvs] < Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Tenkan Sen is inside or above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adTenkanSen[iBar - iPrvs] > Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adTenkanSen[iBar - iPrvs] < Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Kijun Sen is above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs] > Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adKijunSen[iBar - iPrvs] < Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Kijun Sen is inside or above the Kumo":
for (int iBar = iFirstBar + iPrvs; iBar < Bars; iBar++)
{
Component[5].Value[iBar] = adKijunSen[iBar - iPrvs] > Math.Min(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) + Sigma() ? 1 : 0;
Component[6].Value[iBar] = adKijunSen[iBar - iPrvs] < Math.Max(adSenkouSpanA[iBar - iPrvs], adSenkouSpanB[iBar - iPrvs]) - Sigma() ? 1 : 0;
}
break;
case "The Senkou Span A is higher than the Senkou Span B":
IndicatorIsHigherThanAnotherIndicatorLogic(iFirstBar, iPrvs, adSenkouSpanA, adSenkouSpanB, ref Component[5], ref Component[6]);
break;
case "The Senkou Span A crosses the Senkou Span B upward":
IndicatorCrossesAnotherIndicatorUpwardLogic(iFirstBar, iPrvs, adSenkouSpanA, adSenkouSpanB, ref Component[5], ref Component[6]);
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iPeriod = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
int iFirstBar = iPeriod + iPrvs;
// Calculating Money Flow
double[] adMF = new double[Bars];
for (int iBar = 1; iBar < Bars; iBar++)
{
double dAVG = (High[iBar] + Low[iBar] + Close[iBar]) / 3;
double dAVG1 = (High[iBar - 1] + Low[iBar - 1] + Close[iBar - 1]) / 3;
if (dAVG > dAVG1)
adMF[iBar] = adMF[iBar - 1] + dAVG * Volume[iBar];
else if (dAVG < dAVG1)
adMF[iBar] = adMF[iBar - 1] - dAVG * Volume[iBar];
else
adMF[iBar] = adMF[iBar - 1];
}
// Calculating Money Flow Index
double[] adMFI = new double[Bars];
for (int iBar = iPeriod + 1; iBar < Bars; iBar++)
{
double dPMF = 0;
double dNMF = 0;
for (int index = 0; index < iPeriod; index++)
{
if (adMF[iBar - index] > adMF[iBar - index - 1])
dPMF += adMF[iBar - index] - adMF[iBar - index - 1];
if (adMF[iBar - index] < adMF[iBar - index - 1])
dNMF += adMF[iBar - index - 1] - adMF[iBar - index];
}
if (dNMF == 0)
adMFI[iBar] = 100.0;
else
adMFI[iBar] = 100.0 - (100.0 / (1.0 + (dPMF / dNMF)));
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Money Flow Index";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adMFI;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The MFI rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] { 50 };
break;
case "The MFI falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] { 50 };
break;
case "The MFI is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] { dLevel, 100 - dLevel };
break;
case "The MFI is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] { dLevel, 100 - dLevel };
break;
case "The MFI crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] { dLevel, 100 - dLevel };
break;
case "The MFI crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] { dLevel, 100 - dLevel };
break;
case "The MFI changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] { 50 };
break;
case "The MFI changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] { 50 };
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adMFI, dLevel, 100 - dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
bool bIsVisible = IndParam.ListParam[1].Text == "The fractal is visible";
double dShift = (double)IndParam.NumParam[0].Value * Point;
int iFirstBar = 8;
double[] adFrUp = new double[Bars];
double[] adFrDn = new double[Bars];
for (int iBar = 8; iBar < Bars - 1; iBar++)
{
if (High[iBar - 1] < High[iBar - 2] && High[iBar] < High[iBar - 2])
{
// Fractal type 1
if (High[iBar - 4] < High[iBar - 2] &&
High[iBar - 3] < High[iBar - 2])
{
adFrUp[iBar + 1] = High[iBar - 2];
}
// Fractal type 2
if (High[iBar - 5] < High[iBar - 2] &&
High[iBar - 4] < High[iBar - 2] &&
High[iBar - 3] == High[iBar - 2])
{
adFrUp[iBar + 1] = High[iBar - 2];
}
// Fractal type 3, 4
if (High[iBar - 6] < High[iBar - 2] &&
High[iBar - 5] < High[iBar - 2] &&
High[iBar - 4] == High[iBar - 2] &&
High[iBar - 3] <= High[iBar - 2])
{
adFrUp[iBar + 1] = High[iBar - 2];
}
// Fractal type 5
if (High[iBar - 7] < High[iBar - 2] &&
High[iBar - 6] < High[iBar - 2] &&
High[iBar - 5] == High[iBar - 2] &&
High[iBar - 4] < High[iBar - 2] &&
High[iBar - 3] == High[iBar - 2])
{
adFrUp[iBar + 1] = High[iBar - 2];
}
// Fractal type 6
if (High[iBar - 7] < High[iBar - 2] &&
High[iBar - 6] < High[iBar - 2] &&
High[iBar - 5] == High[iBar - 2] &&
High[iBar - 4] == High[iBar - 2] &&
High[iBar - 3] < High[iBar - 2])
{
adFrUp[iBar + 1] = High[iBar - 2];
}
// Fractal type 7
if (High[iBar - 8] < High[iBar - 2] &&
High[iBar - 7] < High[iBar - 2] &&
High[iBar - 6] == High[iBar - 2] &&
High[iBar - 5] < High[iBar - 2] &&
High[iBar - 4] == High[iBar - 2] &&
High[iBar - 3] < High[iBar - 2])
{
adFrUp[iBar + 1] = High[iBar - 2];
}
}
if (Low[iBar - 1] > Low[iBar - 2] && Low[iBar] > Low[iBar - 2])
{
// Fractal type 1
if (Low[iBar - 4] > Low[iBar - 2] &&
Low[iBar - 3] > Low[iBar - 2])
{
adFrDn[iBar + 1] = Low[iBar - 2];
}
// Fractal type 2
if (Low[iBar - 5] > Low[iBar - 2] &&
Low[iBar - 4] > Low[iBar - 2] &&
Low[iBar - 3] == Low[iBar - 2])
{
adFrDn[iBar + 1] = Low[iBar - 2];
}
// Fractal type 3, 4
if (Low[iBar - 6] > Low[iBar - 2] &&
Low[iBar - 5] > Low[iBar - 2] &&
Low[iBar - 4] == Low[iBar - 2] &&
Low[iBar - 3] >= Low[iBar - 2])
{
adFrDn[iBar + 1] = Low[iBar - 2];
}
// Fractal type 5
if (Low[iBar - 7] > Low[iBar - 2] &&
Low[iBar - 6] > Low[iBar - 2] &&
Low[iBar - 5] == Low[iBar - 2] &&
Low[iBar - 4] > Low[iBar - 2] &&
Low[iBar - 3] == Low[iBar - 2])
{
adFrDn[iBar + 1] = Low[iBar - 2];
}
// Fractal type 6
if (Low[iBar - 7] > Low[iBar - 2] &&
Low[iBar - 6] > Low[iBar - 2] &&
Low[iBar - 5] == Low[iBar - 2] &&
Low[iBar - 4] == Low[iBar - 2] &&
Low[iBar - 3] > Low[iBar - 2])
{
adFrDn[iBar + 1] = Low[iBar - 2];
}
// Fractal type 7
if (Low[iBar - 8] > Low[iBar - 2] &&
Low[iBar - 7] > Low[iBar - 2] &&
Low[iBar - 6] == Low[iBar - 2] &&
Low[iBar - 5] > Low[iBar - 2] &&
Low[iBar - 4] == Low[iBar - 2] &&
Low[iBar - 3] > Low[iBar - 2])
{
adFrDn[iBar + 1] = Low[iBar - 2];
}
}
}
// Is visible
if (bIsVisible)
{
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (adFrUp[iBar - 1] > 0 && adFrUp[iBar] == 0 && High[iBar - 1] < adFrUp[iBar - 1])
{
adFrUp[iBar] = adFrUp[iBar - 1];
}
if (adFrDn[iBar - 1] > 0 && adFrDn[iBar] == 0 && Low[iBar - 1] > adFrDn[iBar - 1])
{
adFrDn[iBar] = adFrDn[iBar - 1];
}
}
}
else
{
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (adFrUp[iBar] == 0)
{
adFrUp[iBar] = adFrUp[iBar - 1];
}
if (adFrDn[iBar] == 0)
{
adFrDn[iBar] = adFrDn[iBar - 1];
}
}
}
double[] adFrUpEntry = new double[Bars];
double[] adFrDnEntry = new double[Bars];
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "Up Fractal";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Level;
Component[0].ChartColor = Color.SpringGreen;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adFrUp;
Component[1] = new IndicatorComp();
Component[1].CompName = "Down Fractal";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.DarkRed;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adFrDn;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
if (slotType == SlotTypes.Open)
{
Component[2].CompName = "Long position entry price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Short position entry price";
Component[3].DataType = IndComponentType.OpenShortPrice;
}
else if (slotType == SlotTypes.Close)
{
Component[2].CompName = "Long position closing price";
Component[2].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Short position closing price";
Component[3].DataType = IndComponentType.CloseShortPrice;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter long at an Up Fractal":
case "Exit long at an Up Fractal":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (adFrUp[iBar] > Point)
{
Component[2].Value[iBar] = adFrUp[iBar] + dShift;
}
if (adFrDn[iBar] > Point)
{
Component[3].Value[iBar] = adFrDn[iBar] - dShift;
}
}
break;
case "Enter long at a Down Fractal":
case "Exit long at a Down Fractal":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (adFrDn[iBar] > Point)
{
Component[2].Value[iBar] = adFrDn[iBar] - dShift;
}
if (adFrUp[iBar] > Point)
{
Component[3].Value[iBar] = adFrUp[iBar] + dShift;
}
}
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
int iSmooth = (int)IndParam.NumParam[1].Value;
double dLevel = IndParam.NumParam[2].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
int iFirstBar = iPrvs + iPeriod + iSmooth + 2;
double[] adROC = new double[Bars];
double[] adBasePrice = Price(basePrice);
for (int iBar = iPeriod; iBar < Bars; iBar++)
adROC[iBar] = adBasePrice[iBar] / adBasePrice[iBar - iPeriod];
if (iSmooth > 0)
{
adROC = MovingAverage(iSmooth, 0, maMethod, adROC);
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "ROC";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Violet;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adROC;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The ROC rises":
indLogic = IndicatorLogic.The_indicator_rises;
SpecialValues = new double[1] { 1 };
break;
case "The ROC falls":
indLogic = IndicatorLogic.The_indicator_falls;
SpecialValues = new double[1] { 1 };
break;
case "The ROC is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[2] { dLevel, 2 - dLevel };
break;
case "The ROC is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[2] { dLevel, 2 - dLevel };
break;
case "The ROC crosses the Level line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[2] { dLevel, 2 - dLevel };
break;
case "The ROC crosses the Level line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[2] { dLevel, 2 - dLevel };
break;
case "The ROC changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
SpecialValues = new double[1] { 1 };
break;
case "The ROC changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
SpecialValues = new double[1] { 1 };
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adROC, dLevel, 2 - dLevel, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
int iFromHour = (int)IndParam.NumParam[0].Value;
int iFromMin = (int)IndParam.NumParam[1].Value;
int iUntilHour = (int)IndParam.NumParam[2].Value;
int iUntilMin = (int)IndParam.NumParam[3].Value;
TimeSpan tsFromTime = new TimeSpan(iFromHour, iFromMin, 0);
TimeSpan tsUntilTime = new TimeSpan(iUntilHour, iUntilMin, 0);
double dShift = IndParam.NumParam[4].Value * Point;
int iFirstBar = 2;
// Calculation
double[] adHighPrice = new double[Bars];
double[] adLowPrice = new double[Bars];
double dMinPrice = double.MaxValue;
double dMaxPrice = double.MinValue;
adHighPrice[0] = 0;
adLowPrice[0] = 0;
bool bPrevPeriod = false;
for (int iBar = 1; iBar < Bars; iBar++)
{
bool bPeriod = false;
if (tsFromTime < tsUntilTime)
bPeriod = Time[iBar].TimeOfDay >= tsFromTime && Time[iBar].TimeOfDay < tsUntilTime;
else if (tsFromTime > tsUntilTime)
bPeriod = Time[iBar].TimeOfDay >= tsFromTime || Time[iBar].TimeOfDay < tsUntilTime;
else
bPeriod = true;
if (bPeriod)
{
if (dMaxPrice < High[iBar]) dMaxPrice = High[iBar];
if (dMinPrice > Low[iBar]) dMinPrice = Low[iBar];
}
if (!bPeriod && bPrevPeriod)
{
adHighPrice[iBar] = dMaxPrice;
adLowPrice[iBar] = dMinPrice;
dMaxPrice = double.MinValue;
dMinPrice = double.MaxValue;
}
else
{
adHighPrice[iBar] = adHighPrice[iBar - 1];
adLowPrice[iBar] = adLowPrice[iBar - 1];
}
bPrevPeriod = bPeriod;
}
// Shifting the price
double[] adUpperBand = new double[Bars];
double[] adLowerBand = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adUpperBand[iBar] = adHighPrice[iBar] + dShift;
adLowerBand[iBar] = adLowPrice[iBar] - dShift;
}
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "Hourly High";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Level;
Component[0].ChartColor = Color.DarkGreen;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adHighPrice;
Component[1] = new IndicatorComp();
Component[1].CompName = "Hourly Low";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.DarkRed;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adLowPrice;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.Open)
{
Component[2].CompName = "Long position entry price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Short position entry price";
Component[3].DataType = IndComponentType.OpenShortPrice;
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[2].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is short entry allowed";
Component[3].DataType = IndComponentType.AllowOpenShort;
}
else if (slotType == SlotTypes.Close)
{
Component[2].CompName = "Long position closing price";
Component[2].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Short position closing price";
Component[3].DataType = IndComponentType.CloseShortPrice;
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[2].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out short position";
Component[3].DataType = IndComponentType.ForceCloseShort;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter long at the hourly high":
case "Exit long at the hourly high":
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "Enter long at the hourly low":
case "Exit long at the hourly low":
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
case "The bar closes below the hourly high":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Upper_Band);
break;
case "The bar closes above the hourly high":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Upper_Band);
break;
case "The bar closes below the hourly low":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Lower_Band);
break;
case "The bar closes above the hourly low":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Lower_Band);
break;
case "The position opens above the hourly high":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted hourly high";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[3].CompName = "Shifted hourly low";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "The position opens below the hourly high":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted hourly high";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[3].CompName = "Shifted hourly low";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "The position opens above the hourly low":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted hourly low";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[3].CompName = "Shifted hourly high";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
case "The position opens below the hourly low":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted hourly low";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[3].CompName = "Shifted hourly high";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
double[] adOBV = new double[Bars];
int iFirstBar = 5;
adOBV[0] = Volume[0];
for (int iBar = 1; iBar < Bars; iBar++)
{
if (Close[iBar] > Close[iBar - 1])
{
adOBV[iBar] = adOBV[iBar - 1] + Volume[iBar];
}
else if (Close[iBar] < Close[iBar - 1])
{
adOBV[iBar] = adOBV[iBar - 1] - Volume[iBar];
}
else
{
adOBV[iBar] = adOBV[iBar - 1];
}
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "On Balance Volume";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Green;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adOBV;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The On Balance Volume rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The On Balance Volume falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The On Balance Volume changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The On Balance Volume changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adOBV, 0, 0, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
double dShift = IndParam.NumParam[0].Value * Point;
int iDigids = (int)IndParam.NumParam[1].Value;
// Calculation
double[] adUpperRN = new double[Bars];
double[] adLowerRN = new double[Bars];
int iFirstBar = 1;
for (int iBar = 1; iBar < Bars; iBar++)
{
double dNearestRound;
int iCutDigids = Digits - iDigids;
if (iCutDigids >= 0)
{
dNearestRound = Math.Round(Open[iBar], iCutDigids);
}
else
{
dNearestRound = Math.Round(Open[iBar] * Math.Pow(10, iCutDigids)) / Math.Pow(10, iCutDigids);
}
if (dNearestRound < Open[iBar])
{
adUpperRN[iBar] = dNearestRound + (Point * Math.Pow(10, iDigids));
adLowerRN[iBar] = dNearestRound;
}
else
{
adUpperRN[iBar] = dNearestRound;
adLowerRN[iBar] = dNearestRound - (Point * Math.Pow(10, iDigids));
}
}
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "Higher round number";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Level;
Component[0].ChartColor = Color.SpringGreen;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adUpperRN;
Component[1] = new IndicatorComp();
Component[1].CompName = "Lower round number";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.DarkRed;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adLowerRN;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
if (slotType == SlotTypes.Open)
{
Component[2].CompName = "Long position entry price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Short position entry price";
Component[3].DataType = IndComponentType.OpenShortPrice;
}
else if (slotType == SlotTypes.Close)
{
Component[2].CompName = "Long position closing price";
Component[2].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Short position closing price";
Component[3].DataType = IndComponentType.CloseShortPrice;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter long at the higher round number":
case "Exit long at the higher round number":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[2].Value[iBar] = adUpperRN[iBar] + dShift;
Component[3].Value[iBar] = adLowerRN[iBar] - dShift;
}
break;
case "Enter long at the lower round number":
case "Exit long at the lower round number":
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
Component[2].Value[iBar] = adLowerRN[iBar] - dShift;
Component[3].Value[iBar] = adUpperRN[iBar] + dShift;
}
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
double dShift = IndParam.NumParam[0].Value * Point;
int iFirstBar = 1;
// Calculation
double[] adTopPrice = new double[Bars];
double[] adBottomPrice = new double[Bars];
adTopPrice[0] = 0;
adBottomPrice[0] = 0;
double dTop = double.MinValue;
double dBottom = double.MaxValue;
for (int iBar = 1; iBar < Bars; iBar++)
{
if (High[iBar - 1] > dTop)
dTop = High[iBar - 1];
if (Low[iBar - 1] < dBottom)
dBottom = Low[iBar - 1];
if (IsPeriodChanged(iBar))
{
adTopPrice[iBar] = dTop;
adBottomPrice[iBar] = dBottom;
dTop = double.MinValue;
dBottom = double.MaxValue;
}
else
{
adTopPrice[iBar] = adTopPrice[iBar - 1];
adBottomPrice[iBar] = adBottomPrice[iBar - 1];
}
}
double[] adUpperBand = new double[Bars];
double[] adLowerBand = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adUpperBand[iBar] = adTopPrice[iBar] + dShift;
adLowerBand[iBar] = adBottomPrice[iBar] - dShift;
}
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "Top price";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Level;
Component[0].ChartColor = Color.DarkGreen;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adTopPrice;
Component[1] = new IndicatorComp();
Component[1].CompName = "Bottom price";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.DarkRed;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBottomPrice;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.Open)
{
Component[2].CompName = "Long position entry price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Short position entry price";
Component[3].DataType = IndComponentType.OpenShortPrice;
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[2].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is short entry allowed";
Component[3].DataType = IndComponentType.AllowOpenShort;
}
else if (slotType == SlotTypes.Close)
{
Component[2].CompName = "Long position closing price";
Component[2].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Short position closing price";
Component[3].DataType = IndComponentType.CloseShortPrice;
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[2].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out short position";
Component[3].DataType = IndComponentType.ForceCloseShort;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter long at the top price":
case "Exit long at the top price":
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "Enter long at the bottom price":
case "Exit long at the bottom price":
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
case "The bar opens below the top price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Upper_Band);
break;
case "The bar opens above the top price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_above_the_Upper_Band);
break;
case "The bar opens below the bottom price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Lower_Band);
break;
case "The bar opens above the bottom price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_above_the_Lower_Band);
break;
case "The bar closes below the top price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Upper_Band);
break;
case "The bar closes above the top price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Upper_Band);
break;
case "The bar closes below the bottom price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Lower_Band);
break;
case "The bar closes above the bottom price":
BandIndicatorLogic(iFirstBar, 0, adUpperBand, adLowerBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Lower_Band);
break;
case "The position opens above the top price":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted top price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[3].CompName = "Shifted bottom price";
Component[3].DataType = IndComponentType.OpenShortPrice;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "The position opens below the top price":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted top price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[3].CompName = "Shifted bottom price";
Component[3].DataType = IndComponentType.OpenShortPrice;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "The position opens above the bottom price":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted bottom price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[3].CompName = "Shifted top price";
Component[3].DataType = IndComponentType.OpenShortPrice;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
case "The position opens below the bottom price":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted bottom price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[3].CompName = "Shifted top price";
Component[3].DataType = IndComponentType.OpenShortPrice;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
DayOfWeek dowFromDay = (DayOfWeek)IndParam.ListParam[1].Index;
DayOfWeek dowUntilDay = (DayOfWeek)IndParam.ListParam[2].Index;
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
if (dowFromDay < dowUntilDay)
adBars[iBar] = Time[iBar].DayOfWeek >= dowFromDay &&
Time[iBar].DayOfWeek < dowUntilDay ? 1 : 0;
else if (dowFromDay > dowUntilDay)
adBars[iBar] = Time[iBar].DayOfWeek >= dowFromDay ||
Time[iBar].DayOfWeek < dowUntilDay ? 1 : 0;
else
adBars[iBar] = 1;
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "Allow long entry";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
Component[1] = new IndicatorComp();
Component[1].CompName = "Allow short entry";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
// Calculation
int iFirstBar = 0;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adBars[iBar] = 1;
}
// Saving the components
Component = new IndicatorComp[2];
Component[0] = new IndicatorComp();
Component[0].CompName = "(No) Used bars";
Component[0].DataType = IndComponentType.AllowOpenLong;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
Component[1] = new IndicatorComp();
Component[1].CompName = "(No) Used bars";
Component[1].DataType = IndComponentType.AllowOpenShort;
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
MACD MACD1 = new MACD(slotType);
MACD1.IndParam.ListParam[1].Index = IndParam.ListParam[1].Index;
MACD1.IndParam.ListParam[2].Index = IndParam.ListParam[2].Index;
MACD1.IndParam.ListParam[3].Index = IndParam.ListParam[3].Index;
MACD1.IndParam.NumParam[0].Value = IndParam.NumParam[0].Value;
MACD1.IndParam.NumParam[1].Value = IndParam.NumParam[2].Value;
MACD1.IndParam.NumParam[2].Value = IndParam.NumParam[4].Value;
MACD1.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked;
MACD1.Calculate(slotType);
MACD MACD2 = new MACD(slotType);
MACD2.IndParam.ListParam[1].Index = IndParam.ListParam[1].Index;
MACD2.IndParam.ListParam[2].Index = IndParam.ListParam[2].Index;
MACD2.IndParam.ListParam[3].Index = IndParam.ListParam[3].Index;
MACD2.IndParam.NumParam[0].Value = IndParam.NumParam[1].Value;
MACD2.IndParam.NumParam[1].Value = IndParam.NumParam[3].Value;
MACD2.IndParam.NumParam[2].Value = IndParam.NumParam[5].Value;
MACD2.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked;
MACD2.Calculate(slotType);
// Calculation
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
int iPeriod1 = (int)IndParam.NumParam[0].Value;
int iPeriod2 = (int)IndParam.NumParam[1].Value;
int iFirstBar = iPeriod1 + iPeriod2 + 2;
double[] adIndicator1 = new double[Bars];
double[] adIndicator2 = new double[Bars];
if (IndParam.ListParam[4].Index == 0)
{
adIndicator1 = MACD1.Component[0].Value;
adIndicator2 = MACD2.Component[0].Value;
}
else if (IndParam.ListParam[4].Index == 1)
{
adIndicator1 = MACD1.Component[1].Value;
adIndicator2 = MACD2.Component[1].Value;
}
else
{
adIndicator1 = MACD1.Component[2].Value;
adIndicator2 = MACD2.Component[2].Value;
}
double[] adOscllator = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adOscllator[iBar] = adIndicator1[iBar] - adIndicator2[iBar];
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Oscillator";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adOscllator;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Oscillator of MACD rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The Oscillator of MACD falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The Oscillator of MACD is higher than the zero line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
break;
case "The Oscillator of MACD is lower than the zero line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
break;
case "The Oscillator of MACD crosses the zero line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
break;
case "The Oscillator of MACD crosses the zero line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
break;
case "The Oscillator of MACD changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The Oscillator of MACD changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adOscllator, 0, 0, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
MAMethod maSignalMAMethod = (MAMethod )IndParam.ListParam[2].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[3].Index;
int iPeriod1 = (int)IndParam.NumParam[0].Value;
int iPeriod2 = (int)IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod1 + iPeriod2 + 2;
double[] adIndicator1 = new double[Bars];
double[] adIndicator2 = new double[Bars];
double[] adOscllator = new double[Bars];
// ---------------------------------------------------------
RSI rsi1 = new RSI(slotType);
rsi1.IndParam.ListParam[1].Index = IndParam.ListParam[1].Index;
rsi1.IndParam.ListParam[2].Index = IndParam.ListParam[3].Index;
rsi1.IndParam.NumParam[0].Value = IndParam.NumParam[0].Value;
rsi1.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked;
rsi1.Calculate(slotType);
adIndicator1 = rsi1.Component[0].Value;
adIndicator2 = MovingAverage(iPeriod2, 0, maSignalMAMethod, adIndicator1);
// ----------------------------------------------------------
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adOscllator[iBar] = adIndicator1[iBar] - adIndicator2[iBar];
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Oscillator";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adOscllator;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The RSI MA Oscillator rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The RSI MA Oscillator falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The RSI MA Oscillator is higher than the zero line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
break;
case "The RSI MA Oscillator is lower than the zero line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
break;
case "The RSI MA Oscillator crosses the zero line upward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
break;
case "The RSI MA Oscillator crosses the zero line downward":
indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
break;
case "The RSI MA Oscillator changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The RSI MA Oscillator changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adOscllator, 0, 0, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iStepBack = (IndParam.ListParam[0].Text == "There is a NR4 formation" ? 3 : 6);
int iFirstBar = iStepBack + iPrvs;
double[] adNR = new double[Bars];
double[] adRange = new double[Bars];
for (int iBar = 0; iBar < Bars; iBar++)
{
adRange[iBar] = High[iBar] - Low[iBar];
adNR[iBar] = 0;
}
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
bool bNarrowRange = true;
for (int i = 1; i <= iStepBack; i++)
if (adRange[iBar - i - iPrvs] <= adRange[iBar - iPrvs])
{
bNarrowRange = false;
break;
}
if (bNarrowRange) adNR[iBar] = 1;
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Bar Range";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = new double[Bars];
for (int i = 0; i < Bars; i++)
Component[0].Value[i] = (double)Math.Round(adRange[i] / Point);
Component[1] = new IndicatorComp();
Component[1].CompName = "Allow long entry";
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adNR;
Component[2] = new IndicatorComp();
Component[2].CompName = "Allow short entry";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adNR;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int iEntryHour = (int)IndParam.NumParam[0].Value;
int iEntryMinute = (int)IndParam.NumParam[1].Value;
TimeSpan tsEntryHour = new TimeSpan(iEntryHour, iEntryMinute, 0);
// Calculation
int iFirstBar = 1;
double[] adBars = new double[Bars];
// Calculation of the logic
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adBars[iBar] = Time[iBar].TimeOfDay == tsEntryHour ? Open[iBar] : 0;
}
// Saving the components
Component = new IndicatorComp[1];
Component[0] = new IndicatorComp();
Component[0].CompName = "Entry hour";
Component[0].DataType = IndComponentType.OpenPrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adBars;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int iPeriod = (int)IndParam.NumParam[0].Value;
int iSmooth = (int)IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = iPeriod + 2;
double[] adBasePrice = Price(basePrice);
double[] adCumulSum = new double[Bars];
adCumulSum[iPeriod - 1] = 0;
for (int iBar = 0; iBar < iPeriod; iBar++)
{
adCumulSum[iPeriod - 1] += adBasePrice[iBar];
}
for (int iBar = iPeriod; iBar < Bars; iBar++)
{
adCumulSum[iBar] = adCumulSum[iBar - 1] - adBasePrice[iBar - iPeriod] + adBasePrice[iBar];
}
adCumulSum = MovingAverage(iSmooth, 0, maMethod, adCumulSum);
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Cumulative Sum";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adCumulSum;
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Cumulative Sum rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The Cumulative Sum falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The Cumulative Sum changes its direction upward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The Cumulative Sum changes its direction downward":
indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
break;
}
OscillatorLogic(iFirstBar, iPrvs, adCumulSum, 0, 0, ref Component[1], ref Component[2], indLogic);
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index;
BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index;
int nPeriod = (int)IndParam.NumParam[0].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = 2 * nPeriod + 2;
double[] ma1 = MovingAverage(nPeriod, 0, maMethod, Price(basePrice));
double[] ma2 = MovingAverage(nPeriod, 0, maMethod, ma1);
double[] ma3 = MovingAverage(nPeriod, 0, maMethod, ma2);
double[] adTrix = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
adTrix[iBar] = 100 * (ma3[iBar] - ma3[iBar - 1]) / ma3[iBar - 1];
double[] adSignal = MovingAverage(nPeriod, 0, maMethod, adTrix);
// adHistogram reprezents the Trix Index oscillator
double[] adHistogram = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
adHistogram[iBar] = adTrix[iBar] - adSignal[iBar];
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "Histogram";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adHistogram;
Component[1] = new IndicatorComp();
Component[1].CompName = "Signal";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Gold;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adSignal;
Component[2] = new IndicatorComp();
Component[2].CompName = "Trix Line";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Blue;
Component[2].FirstBar = iFirstBar;
Component[2].Value = adTrix;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = iFirstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
switch (IndParam.ListParam[0].Text)
{
case "The Trix Index line rises":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_rises);
break;
case "The Trix Index line falls":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_falls);
break;
case "The Trix Index line is higher than zero":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_higher_than_the_level_line);
break;
case "The Trix Index line is lower than zero":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_lower_than_the_level_line);
break;
case "The Trix Index line crosses the zero line upward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_upward);
break;
case "The Trix Index line crosses the zero line downward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_downward);
break;
case "The Trix Index line changes its direction upward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_changes_its_direction_upward);
break;
case "The Trix Index line changes its direction downward":
OscillatorLogic(iFirstBar, iPrvs, adTrix, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_changes_its_direction_downward);
break;
case "The Trix Index line crosses the Signal line upward":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_upward);
break;
case "The Trix Index line crosses the Signal line downward":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_crosses_the_level_line_downward);
break;
case "The Trix Index line is higher than the Signal line":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_higher_than_the_level_line);
break;
case "The Trix Index line is lower than the Signal line":
OscillatorLogic(iFirstBar, iPrvs, adHistogram, 0, 0, ref Component[3], ref Component[4], IndicatorLogic.The_indicator_is_lower_than_the_level_line);
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
double dShift = IndParam.NumParam[0].Value * Point;
// Calculation
double[] adHighPrice = new double[Bars];
double[] adLowPrice = new double[Bars];
int iFirstBar = 2;
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adHighPrice[iBar] = High[iBar - 1];
adLowPrice[iBar] = Low[iBar - 1];
}
double[] adUpperBand = new double[Bars];
double[] adLowerBand = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
adUpperBand[iBar] = adHighPrice[iBar] + dShift;
adLowerBand[iBar] = adLowPrice[iBar] - dShift;
}
// Saving the components
Component = new IndicatorComp[4];
Component[0] = new IndicatorComp();
Component[0].CompName = "Previous High";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Level;
Component[0].ChartColor = Color.DarkGreen;
Component[0].FirstBar = iFirstBar;
Component[0].Value = adHighPrice;
Component[1] = new IndicatorComp();
Component[1].CompName = "Previous Low";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Level;
Component[1].ChartColor = Color.DarkRed;
Component[1].FirstBar = iFirstBar;
Component[1].Value = adLowPrice;
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = iFirstBar;
Component[3].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.Open)
{
Component[2].CompName = "Long position entry price";
Component[2].DataType = IndComponentType.OpenLongPrice;
Component[3].CompName = "Short position entry price";
Component[3].DataType = IndComponentType.OpenShortPrice;
}
else if (slotType == SlotTypes.OpenFilter)
{
Component[2].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is short entry allowed";
Component[3].DataType = IndComponentType.AllowOpenShort;
}
else if (slotType == SlotTypes.Close)
{
Component[2].CompName = "Long position closing price";
Component[2].DataType = IndComponentType.CloseLongPrice;
Component[3].CompName = "Short position closing price";
Component[3].DataType = IndComponentType.CloseShortPrice;
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[2].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out short position";
Component[3].DataType = IndComponentType.ForceCloseShort;
}
switch (IndParam.ListParam[0].Text)
{
case "Enter long at the previous high":
case "Exit long at the previous high":
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "Enter long at the previous low":
case "Exit long at the previous low":
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
case "The bar opens below the previous high":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Upper_Band);
break;
case "The bar opens above the previous high":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_above_the_Upper_Band);
break;
case "The bar opens below the previous low":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Lower_Band);
break;
case "The bar opens above the previous low":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_above_the_Lower_Band);
break;
case "The bar closes below the previous high":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Upper_Band);
break;
case "The bar closes above the previous high":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Upper_Band);
break;
case "The bar closes below the previous low":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Lower_Band);
break;
case "The bar closes above the previous low":
BandIndicatorLogic(iFirstBar, 0, adLowerBand, adUpperBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Lower_Band);
break;
case "The position opens above the previous high":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted previous high";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[3].CompName = "Shifted previous low";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "The position opens below the previous high":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted previous high";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[3].CompName = "Shifted previous low";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].Value = adUpperBand;
Component[3].Value = adLowerBand;
break;
case "The position opens above the previous low":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted previous low";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyHigher;
Component[3].CompName = "Shifted previous high";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellLower;
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
case "The position opens below the previous low":
Component[0].DataType = IndComponentType.Other;
Component[1].DataType = IndComponentType.Other;
Component[2].CompName = "Shifted previous low";
Component[2].DataType = IndComponentType.Other;
Component[2].PosPriceDependence = PositionPriceDependence.PriceBuyLower;
Component[3].CompName = "Shifted previous high";
Component[3].DataType = IndComponentType.Other;
Component[3].PosPriceDependence = PositionPriceDependence.PriceSellHigher;
Component[2].Value = adLowerBand;
Component[3].Value = adUpperBand;
break;
default:
break;
}
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
int fridayClosingHour = (int)IndParam.NumParam[0].Value;
int fridayClosingMin = (int)IndParam.NumParam[1].Value;
// Calculation
DateTime time = ServerTime;
DateTime fridayTime = new DateTime(time.Year, time.Month, time.Day, fridayClosingHour, fridayClosingMin, 0);
int firstBar = 1;
double[] adClosePrice = new double[Bars];
// Calculation of the logic
for (int bar = firstBar; bar < Bars - 1; bar++)
{
if (Time[bar].DayOfWeek > DayOfWeek.Wednesday &&
Time[bar + 1].DayOfWeek < DayOfWeek.Wednesday)
adClosePrice[bar] = Close[bar];
else
adClosePrice[bar] = 0;
}
double[] adAllowOpenLong = new double[Bars];
double[] adAllowOpenShort = new double[Bars];
for (int bar = 1; bar < Bars; bar++)
{
adAllowOpenLong[bar] = 1;
adAllowOpenShort[bar] = 1;
}
// Check the last bar
if (time.DayOfWeek == DayOfWeek.Friday)
if (time >= fridayTime)
{
adClosePrice[Bars - 1] = Close[Bars - 1];
// Prevent entries after closing time
adAllowOpenLong[Bars - 1] = 0;
adAllowOpenShort[Bars - 1] = 0;
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Week Closing";
Component[0].DataType = IndComponentType.ClosePrice;
Component[0].ChartType = IndChartType.NoChart;
Component[0].ShowInDynInfo = false;
Component[0].FirstBar = firstBar;
Component[0].Value = adClosePrice;
Component[1] = new IndicatorComp();
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[1].ChartType = IndChartType.NoChart;
Component[1].ShowInDynInfo = false;
Component[1].FirstBar = 2;
Component[1].Value = adAllowOpenLong;
Component[2] = new IndicatorComp();
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
Component[2].ChartType = IndChartType.NoChart;
Component[2].ShowInDynInfo = false;
Component[2].FirstBar = 2;
Component[2].Value = adAllowOpenShort;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index;
int period = (int)IndParam.NumParam[0].Value;
double level = IndParam.NumParam[1].Value;
int prev = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int firstBar = 2 * period + 2;
double[] DIPos = new double[Bars];
double[] DINeg = new double[Bars];
for (int bar = 1; bar < Bars; bar++)
{
double trueRange = Math.Max(High[bar], Close[bar - 1]) - Math.Min(Low[bar], Close[bar - 1]);
if (trueRange < Point)
{
trueRange = Point;
}
double deltaHigh = High[bar] - High[bar - 1];
double deltaLow = Low[bar - 1] - Low[bar];
if (deltaHigh > 0 && deltaHigh > deltaLow)
{
DIPos[bar] = 100 * deltaHigh / trueRange;
}
else
{
DIPos[bar] = 0;
}
if (deltaLow > 0 && deltaLow > deltaHigh)
{
DINeg[bar] = 100 * deltaLow / trueRange;
}
else
{
DINeg[bar] = 0;
}
}
double[] ADIPos = MovingAverage(period, 0, maMethod, DIPos);
double[] ADINeg = MovingAverage(period, 0, maMethod, DINeg);
double[] DX = new double[Bars];
for (int bar = 0; bar < Bars; bar++)
{
if (ADIPos[bar] + ADINeg[bar] == 0)
{
DX[bar] = 0;
}
else
{
DX[bar] = 100 * Math.Abs((ADIPos[bar] - ADINeg[bar]) / (ADIPos[bar] + ADINeg[bar]));
}
}
double[] ADX = MovingAverage(period, 0, maMethod, DX);
// Saving the components
Component = new IndicatorComp[5];
Component[0] = new IndicatorComp();
Component[0].CompName = "ADX";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Line;
Component[0].ChartColor = Color.Blue;
Component[0].FirstBar = firstBar;
Component[0].Value = ADX;
Component[1] = new IndicatorComp();
Component[1].CompName = "ADI+";
Component[1].DataType = IndComponentType.IndicatorValue;
Component[1].ChartType = IndChartType.Line;
Component[1].ChartColor = Color.Green;
Component[1].FirstBar = firstBar;
Component[1].Value = ADIPos;
Component[2] = new IndicatorComp();
Component[2].CompName = "ADI-";
Component[2].DataType = IndComponentType.IndicatorValue;
Component[2].ChartType = IndChartType.Line;
Component[2].ChartColor = Color.Red;
Component[2].FirstBar = firstBar;
Component[2].Value = ADINeg;
Component[3] = new IndicatorComp();
Component[3].ChartType = IndChartType.NoChart;
Component[3].FirstBar = firstBar;
Component[3].Value = new double[Bars];
Component[4] = new IndicatorComp();
Component[4].ChartType = IndChartType.NoChart;
Component[4].FirstBar = firstBar;
Component[4].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[3].DataType = IndComponentType.AllowOpenLong;
Component[3].CompName = "Is long entry allowed";
Component[4].DataType = IndComponentType.AllowOpenShort;
Component[4].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[3].DataType = IndComponentType.ForceCloseLong;
Component[3].CompName = "Close out long position";
Component[4].DataType = IndComponentType.ForceCloseShort;
Component[4].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic logicRule;
switch (IndParam.ListParam[0].Text)
{
case "The ADX rises":
logicRule = IndicatorLogic.The_indicator_rises;
break;
case "The ADX falls":
logicRule = IndicatorLogic.The_indicator_falls;
break;
case "The ADX is higher than the Level line":
logicRule = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[1] {
level
};
break;
case "The ADX is lower than the Level line":
logicRule = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[1] {
level
};
break;
case "The ADX crosses the Level line upward":
logicRule = IndicatorLogic.The_indicator_crosses_the_level_line_upward;
SpecialValues = new double[1] {
level
};
break;
case "The ADX crosses the Level line downward":
logicRule = IndicatorLogic.The_indicator_crosses_the_level_line_downward;
SpecialValues = new double[1] {
level
};
break;
case "The ADX changes its direction upward":
logicRule = IndicatorLogic.The_indicator_changes_its_direction_upward;
break;
case "The ADX changes its direction downward":
logicRule = IndicatorLogic.The_indicator_changes_its_direction_downward;
break;
default:
logicRule = IndicatorLogic.It_does_not_act_as_a_filter;
break;
}
// ADX rises equal signals in both directions!
NoDirectionOscillatorLogic(firstBar, prev, ADX, level, ref Component[3], logicRule);
Component[4].Value = Component[3].Value;
return;
}
/// <summary>
/// Calculates the indicator's components
/// </summary>
public override void Calculate(SlotTypes slotType)
{
// Reading the parameters
int nBars = (int)IndParam.NumParam[0].Value;
double dLevel = IndParam.NumParam[1].Value;
int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0;
// Calculation
int iFirstBar = nBars + 1;
double[] adRange = new double[Bars];
for (int iBar = iFirstBar; iBar < Bars; iBar++)
{
double maxHigh = double.MinValue;
double minLow = double.MaxValue;
for (int i = 0; i < nBars; i++)
{
if (High[iBar - i] > maxHigh)
maxHigh = High[iBar - i];
if (Low[iBar - i] < minLow)
minLow = Low[iBar - i];
}
adRange[iBar] = maxHigh - minLow;
}
// Saving the components
Component = new IndicatorComp[3];
Component[0] = new IndicatorComp();
Component[0].CompName = "Bar Range";
Component[0].DataType = IndComponentType.IndicatorValue;
Component[0].ChartType = IndChartType.Histogram;
Component[0].FirstBar = iFirstBar;
Component[0].Value = new double[Bars];
for (int i = 0; i < Bars; i++)
Component[0].Value[i] = (double)Math.Round(adRange[i] / Point);
Component[1] = new IndicatorComp();
Component[1].ChartType = IndChartType.NoChart;
Component[1].FirstBar = iFirstBar;
Component[1].Value = new double[Bars];
Component[2] = new IndicatorComp();
Component[2].ChartType = IndChartType.NoChart;
Component[2].FirstBar = iFirstBar;
Component[2].Value = new double[Bars];
// Sets the Component's type
if (slotType == SlotTypes.OpenFilter)
{
Component[1].DataType = IndComponentType.AllowOpenLong;
Component[1].CompName = "Is long entry allowed";
Component[2].DataType = IndComponentType.AllowOpenShort;
Component[2].CompName = "Is short entry allowed";
}
else if (slotType == SlotTypes.CloseFilter)
{
Component[1].DataType = IndComponentType.ForceCloseLong;
Component[1].CompName = "Close out long position";
Component[2].DataType = IndComponentType.ForceCloseShort;
Component[2].CompName = "Close out short position";
}
// Calculation of the logic
IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter;
switch (IndParam.ListParam[0].Text)
{
case "The Bar Range rises":
indLogic = IndicatorLogic.The_indicator_rises;
break;
case "The Bar Range falls":
indLogic = IndicatorLogic.The_indicator_falls;
break;
case "The Bar Range is higher than the Level line":
indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line;
SpecialValues = new double[1] { dLevel };
break;
case "The Bar Range is lower than the Level line":
indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line;
SpecialValues = new double[1] { dLevel };
break;
default:
break;
}
NoDirectionOscillatorLogic(iFirstBar, iPrvs, adRange, dLevel * Point, ref Component[1], indLogic);
Component[2].Value = Component[1].Value;
return;
}
