/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Calculation double[] adOpenPrice = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { if (Time[iBar - 1].Day != Time[iBar].Day) { adOpenPrice[iBar] = Open[iBar]; } } // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Opening price of the day"; Component[0].DataType = IndComponentType.OpenPrice; Component[0].ChartType = IndChartType.NoChart; Component[0].FirstBar = 2; Component[0].Value = adOpenPrice; return; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Calculation const int firstBar = 2; var insideBAr = new double[Bars]; for (int bar = 2; bar < Bars; bar++) { insideBAr[bar] = ((High[bar - 1] < High[bar - 2]) && (Low[bar - 1] > Low[bar - 2])) ? 1 : 0; } // Saving the components Component = new IndicatorComp[2]; Component[0] = new IndicatorComp { CompName = "Allow long entry", DataType = IndComponentType.AllowOpenLong, ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = insideBAr }; Component[1] = new IndicatorComp { CompName = "Allow short entry", DataType = IndComponentType.AllowOpenShort, ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = insideBAr }; }
/// <summary> /// Calculates the indicator's components. /// </summary> public override void Calculate(SlotTypes slotType) { // Reading the parameters int iPercent = (int)IndParam.NumParam[0].Value; // Calculation int iFirstBar = 1; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Stop to a transferred position"; Component[0].DataType = IndComponentType.Other; Component[0].ShowInDynInfo = false; Component[0].FirstBar = iFirstBar; Component[0].Value = new double[Bars]; // The program calculates the Account Percent Stop during the backtest. // It depends on the account value at the moment of the transaction. // // double dDeltaMoney = iPercent * MoneyBalance(iBar) / (100 * iLots); // double dDeltaStop = Math.Max(MoneyToPips(dDeltaMoney, iBar), 5) * Point; // double dStop = FormOrdPrice + dDeltaStop; return; }
private void CalculateForBacktester() { // Calculation var adClosePrice = new double[Bars]; for (int bar = 1; bar < Bars; bar++) { if (Time[bar - 1].Day != Time[bar].Day) { adClosePrice[bar - 1] = Close[bar - 1]; } } // Check the last bar TimeSpan tsBarClosing = Time[Bars - 1].TimeOfDay.Add(new TimeSpan(0, (int)Period, 0)); var 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 { CompName = "Closing price of the day", DataType = IndComponentType.ClosePrice, ChartType = IndChartType.NoChart, FirstBar = 2, Value = adClosePrice }; }
public Indicator() { IndParam = new IndicatorParam(); IndicatorName = string.Empty; PossibleSlots = SlotTypes.NotDefined; SlotType = SlotTypes.NotDefined; SeparatedChart = false; SeparatedChartMinValue = double.MaxValue; SeparatedChartMaxValue = double.MinValue; SpecialValues = new double[0]; IsDiscreteValues = false; CustomIndicator = false; IsBacktester = true; IsGeneratable = true; WarningMessage = string.Empty; AllowClosingFilters = false; IndicatorAuthor = "Forex Software Ltd"; IndicatorVersion = "1.0"; IndicatorDescription = "Bundled in FSB distribution."; ExitFilterShortDescription = "Not defined"; EntryFilterShortDescription = "Not defined"; ExitFilterLongDescription = "Not defined"; EntryFilterLongDescription = "Not defined"; ExitPointShortDescription = "Not defined"; ExitPointLongDescription = "Not defined"; EntryPointShortDescription = "Not defined"; EntryPointLongDescription = "Not defined"; Component = new IndicatorComp[] {}; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var entryHour = (int)IndParam.NumParam[0].Value; var entryMinute = (int)IndParam.NumParam[1].Value; var entryTime = new TimeSpan(entryHour, entryMinute, 0); // Calculation const int firstBar = 1; var signal = new double[Bars]; // Calculation of the logic for (int bar = firstBar; bar < Bars; bar++) { signal[bar] = Time[bar].TimeOfDay == entryTime ? Open[bar] : 0; } // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "Entry hour", DataType = IndComponentType.OpenPrice, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = signal }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; if (!IsBacktester) { // FST sends the N bars for exit to the expert. Expert watches the position and closes it. return; } var nExit = (int)IndParam.NumParam[0].Value; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "N Bars Exit (" + nExit.ToString(CultureInfo.InvariantCulture) + ")", DataType = IndComponentType.ForceClose, ChartType = IndChartType.NoChart, ShowInDynInfo = true, FirstBar = 1, Value = new double[Bars] }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Calculation var adOpenPrice = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { if (Time[iBar - 1].Day != Time[iBar].Day) { adOpenPrice[iBar] = Open[iBar]; } } // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "Opening price of the day", DataType = IndComponentType.OpenPrice, ChartType = IndChartType.NoChart, FirstBar = 2, Value = adOpenPrice }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var dowFromDay = (DayOfWeek)IndParam.ListParam[1].Index; var dowUntilDay = (DayOfWeek)IndParam.ListParam[2].Index; // Calculation const int firstBar = 1; var adBars = new double[Bars]; // Calculation of the logic for (int iBar = firstBar; 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 { CompName = "Allow long entry", DataType = IndComponentType.AllowOpenLong, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = adBars }; Component[1] = new IndicatorComp { CompName = "Allow short entry", DataType = IndComponentType.AllowOpenShort, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = adBars }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var fromHour = (int)IndParam.NumParam[0].Value; var fromMin = (int)IndParam.NumParam[1].Value; var untilHour = (int)IndParam.NumParam[2].Value; var untilMin = (int)IndParam.NumParam[3].Value; var fromTime = new TimeSpan(fromHour, fromMin, 0); var untilTime = new TimeSpan(untilHour, untilMin, 0); // Calculation int firstBar = 2; var signal = new double[Bars]; // Calculation of the logic for (int bar = firstBar; bar < Bars; bar++) { if (fromTime < untilTime) { signal[bar] = Time[bar].TimeOfDay >= fromTime && Time[bar].TimeOfDay < untilTime ? 1 : 0; } else if (fromTime > untilTime) { signal[bar] = Time[bar].TimeOfDay >= fromTime || Time[bar].TimeOfDay < untilTime ? 1 : 0; } else { signal[bar] = 1; } } // Saving the components Component = new IndicatorComp[2]; Component[0] = new IndicatorComp { CompName = "Is long entry allowed", DataType = IndComponentType.AllowOpenLong, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = signal }; Component[1] = new IndicatorComp { CompName = "Is short entry allowed", DataType = IndComponentType.AllowOpenShort, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = signal }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var maMethod = (MAMethod)IndParam.ListParam[1].Index; var period = (int)IndParam.NumParam[0].Value; var multipl = (int)IndParam.NumParam[1].Value; int prev = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int firstBar = period + 2; var 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); var 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 { CompName = "ATR Stop margin", DataType = IndComponentType.IndicatorValue, FirstBar = firstBar, ShowInDynInfo = false, Value = atrStop }; Component[1] = new IndicatorComp { CompName = "ATR Stop for the transferred position", DataType = IndComponentType.Other, ShowInDynInfo = false, FirstBar = firstBar, Value = new double[Bars] }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var exitHour = (int)IndParam.NumParam[0].Value; var tsExitHour = new TimeSpan(exitHour, 0, 0); // Calculation const int firstBar = 1; var adBars = new double[Bars]; // Calculation of the logic for (int bar = firstBar; bar < Bars; bar++) { if (Time[bar - 1].DayOfYear == Time[bar].DayOfYear && Time[bar - 1].TimeOfDay < tsExitHour && Time[bar].TimeOfDay >= tsExitHour) { adBars[bar - 1] = Close[bar - 1]; } else if (Time[bar - 1].DayOfYear != Time[bar].DayOfYear && Time[bar - 1].TimeOfDay < tsExitHour) { adBars[bar - 1] = Close[bar - 1]; } else { adBars[bar] = 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 { CompName = "Exit hour", DataType = IndComponentType.ClosePrice, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = adBars }; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Trailing Stop for a transferred position"; Component[0].DataType = IndComponentType.Other; Component[0].ShowInDynInfo = false; Component[0].FirstBar = 1; Component[0].Value = new double[Bars]; return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Closing price of the bar"; Component[0].DataType = (IndParam.SlotType == SlotTypes.Open) ? IndComponentType.OpenPrice : IndComponentType.ClosePrice; Component[0].ChartType = IndChartType.NoChart; Component[0].FirstBar = 2; Component[0].Value = Close; return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Opening price of the bar"; Component[0].DataType = IndComponentType.OpenPrice; Component[0].ChartType = IndChartType.NoChart; Component[0].FirstBar = 2; Component[0].Value = Open; return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Trailing Stop for the transferred position"; Component[0].DataType = IndComponentType.Other; Component[0].ShowInDynInfo = false; Component[0].FirstBar = 1; Component[0].Value = new double[Bars]; return; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters int iFromDay = (int)IndParam.NumParam[0].Value; int iUntilDay = (int)IndParam.NumParam[1].Value; // Calculation int iFirstBar = 1; double[] adBars = new double[Bars]; // Calculation of the logic for (int iBar = iFirstBar; iBar < Bars; iBar++) { if (iFromDay < iUntilDay) { adBars[iBar] = Time[iBar].Day >= iFromDay && Time[iBar].Day < iUntilDay ? 1 : 0; } else if (iFromDay > iUntilDay) { adBars[iBar] = Time[iBar].Day >= iFromDay || Time[iBar].Day < iUntilDay ? 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; }
/// <summary> /// The default constructor. /// </summary> public IndicatorSlot() { SlotNumber = 0; SlotType = SlotTypes.NotDefined; LogicalGroup = ""; IsDefined = false; SlotStatus = StrategySlotStatus.Open; IndicatorName = "Not defined"; IndParam = new IndicatorParam(); SeparatedChart = false; Component = new IndicatorComp[] {}; SpecValue = new double[] {}; MinValue = double.MaxValue; MaxValue = double.MinValue; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "Opening price of the bar", DataType = IndComponentType.OpenPrice, ChartType = IndChartType.NoChart, FirstBar = 2, Value = Open }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "Close Price", DataType = (IndParam.SlotType == SlotTypes.Open) ? IndComponentType.OpenPrice : IndComponentType.ClosePrice, ChartType = IndChartType.NoChart, FirstBar = 2, Value = Close }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "Trailing Stop for a transferred position", DataType = IndComponentType.Other, ShowInDynInfo = false, FirstBar = 1, Value = new double[Bars] }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters int hour = (int)IndParam.NumParam[0].Value; int minute = (int)IndParam.NumParam[1].Value; // Calculation const int firstBar = 2; double[] signal = new double[Bars]; // Calculation of the logic for (int bar = firstBar; bar < Bars; bar++) { DateTime closeTime = Time[bar].AddMinutes((int)Period); if (closeTime.Hour == hour && closeTime.Minute == minute) { signal[bar] = 1; } } // Saving the components Component = new IndicatorComp[2]; Component[0] = new IndicatorComp { CompName = "Close out long position", DataType = IndComponentType.ForceCloseLong, ChartType = IndChartType.NoChart, ShowInDynInfo = true, FirstBar = firstBar, Value = signal }; Component[1] = new IndicatorComp { CompName = "Close out short position", DataType = IndComponentType.ForceCloseShort, ChartType = IndChartType.NoChart, ShowInDynInfo = true, FirstBar = firstBar, Value = signal }; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Saving the components Component = new IndicatorComp[2]; Component[0] = new IndicatorComp { CompName = "Is long entry allowed", DataType = IndComponentType.AllowOpenLong, ChartType = IndChartType.NoChart, FirstBar = 0, Value = new double[Bars] }; Component[1] = new IndicatorComp { CompName = "Is short entry allowed", DataType = IndComponentType.AllowOpenShort, ChartType = IndChartType.NoChart, FirstBar = 0, Value = new double[Bars] }; // Calculation of the logic switch (IndParam.ListParam[0].Text) { case "Open long positions only": for (int i = 0; i < Bars; i++) { Component[0].Value[i] = 1; Component[1].Value[i] = 0; } break; case "Open short positions only": for (int i = 0; i < Bars; i++) { Component[0].Value[i] = 0; Component[1].Value[i] = 1; } break; } }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // 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].FirstBar = 0; Component[0].Value = new double[Bars]; Component[1] = new IndicatorComp(); Component[1].CompName = "Is short entry allowed"; Component[1].DataType = IndComponentType.AllowOpenShort; Component[1].ChartType = IndChartType.NoChart; Component[1].FirstBar = 0; Component[1].Value = new double[Bars]; // Calculation of the logic switch (IndParam.ListParam[0].Text) { case "Open long positions only": for (int i = 0; i < Bars; i++) { Component[0].Value[i] = 1; Component[1].Value[i] = 0; } break; case "Open short positions only": for (int i = 0; i < Bars; i++) { Component[0].Value[i] = 0; Component[1].Value[i] = 1; } break; default: break; } return; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Calculation const int firstBar = 1; var adBars = new double[Bars]; // Calculation of the logic for (int bar = 0; bar < Bars - 1; bar++) { if (Time[bar].DayOfWeek > DayOfWeek.Wednesday && Time[bar + 1].DayOfWeek < DayOfWeek.Wednesday) { adBars[bar] = Close[bar]; } else { adBars[bar] = 0; } } // Check the last bar TimeSpan tsBarClosing = Time[Bars - 1].TimeOfDay.Add(new TimeSpan(0, (int)Period, 0)); var 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 { CompName = "Week Closing", DataType = IndComponentType.ClosePrice, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = firstBar, Value = adBars }; }
private void CalculateForBacktester() { IndParam.ExecutionTime = ExecutionTime.AtBarClosing; // Calculation var adClosePrice = new double[Bars]; // Calculation of the logic for (int bar = 0; bar < Bars - 1; bar++) { if (Time[bar].DayOfWeek > DayOfWeek.Wednesday && Time[bar + 1].DayOfWeek < DayOfWeek.Wednesday) { adClosePrice[bar] = Close[bar]; } else { adClosePrice[bar] = 0; } } // Check the last bar TimeSpan tsBarClosing = Time[Bars - 1].TimeOfDay.Add(new TimeSpan(0, (int)Period, 0)); var tsDayClosing = new TimeSpan(24, 0, 0); if (Time[Bars - 1].DayOfWeek == DayOfWeek.Friday && tsBarClosing == tsDayClosing) { adClosePrice[Bars - 1] = Close[Bars - 1]; } // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp { CompName = "Week Closing", DataType = IndComponentType.ClosePrice, ChartType = IndChartType.NoChart, ShowInDynInfo = false, FirstBar = 2, Value = adClosePrice }; }
/// <summary> /// Calculates the indicator's components. /// </summary> public override void Calculate(SlotTypes slotType) { // Reading the parameters int percent = (int)IndParam.NumParam[0].Value; // Calculation int firstBar = 1; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Stop to a transferred position"; Component[0].DataType = IndComponentType.Other; Component[0].ShowInDynInfo = false; Component[0].FirstBar = firstBar; Component[0].Value = new double[Bars]; return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Calculation double[] adOpenPrice = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) if (Time[iBar - 1].Day != Time[iBar].Day) adOpenPrice[iBar] = Open[iBar]; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Opening price of the day"; Component[0].DataType = IndComponentType.OpenPrice; Component[0].ChartType = IndChartType.NoChart; Component[0].FirstBar = 2; Component[0].Value = adOpenPrice; return; }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var maMethod = (MAMethod)IndParam.ListParam[1].Index; var price = (BasePrice)IndParam.ListParam[2].Index; var period = (int)IndParam.NumParam[0].Value; var shift = (int)IndParam.NumParam[1].Value; int previous = IndParam.CheckParam[0].Checked ? 1 : 0; // TimeExecution if (period == 1 && shift == 0) { if (price == BasePrice.Open) { IndParam.ExecutionTime = ExecutionTime.AtBarOpening; } else if (price == BasePrice.Close) { IndParam.ExecutionTime = ExecutionTime.AtBarClosing; } } // Calculation double[] movingAverage = MovingAverage(period, shift, maMethod, Price(price)); int firstBar = period + shift + 1 + previous; // Saving the components if (SlotType == SlotTypes.Open || SlotType == SlotTypes.Close) { Component = new IndicatorComp[2]; Component[1] = new IndicatorComp { Value = new double[Bars] }; for (int bar = firstBar; bar < Bars; bar++) { // Covers the cases when the price can pass through the MA without a signal double value = movingAverage[bar - previous]; // Current value double value1 = movingAverage[bar - previous - 1]; // Previous value double tempVal = value; if ((value1 > High[bar - 1] && value < Open[bar]) || // The Open price jumps above the indicator (value1 <Low[bar - 1] && value> Open[bar]) || // The Open price jumps below the indicator (Close[bar - 1] < value && value < Open[bar]) || // The Open price is in a positive gap (Close[bar - 1] > value && value > Open[bar])) // The Open price is in a negative gap { tempVal = Open[bar]; } Component[1].Value[bar] = tempVal; // Entry or exit value } } else { Component = new IndicatorComp[3]; Component[1] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; Component[2] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; } Component[0] = new IndicatorComp { CompName = "MA Value", DataType = IndComponentType.IndicatorValue, ChartType = IndChartType.Line, ChartColor = Color.Red, FirstBar = firstBar, Value = movingAverage }; switch (SlotType) { case SlotTypes.Open: Component[1].CompName = "Position opening price"; Component[1].DataType = IndComponentType.OpenPrice; break; case 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"; break; case SlotTypes.Close: Component[1].CompName = "Position closing price"; Component[1].DataType = IndComponentType.ClosePrice; break; case 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"; break; } if (SlotType == SlotTypes.OpenFilter || SlotType == SlotTypes.CloseFilter) { switch (IndParam.ListParam[0].Text) { case "Moving Average rises": IndicatorRisesLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "Moving Average falls": IndicatorFallsLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "The bar opens above Moving Average": BarOpensAboveIndicatorLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "The bar opens below Moving Average": BarOpensBelowIndicatorLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "The bar opens above Moving Average after opening below it": BarOpensAboveIndicatorAfterOpeningBelowLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "The bar opens below Moving Average after opening above it": BarOpensBelowIndicatorAfterOpeningAboveLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "The position opens above Moving Average": Component[0].PosPriceDependence = PositionPriceDependence.BuyHigherSellLower; Component[0].UsePreviousBar = previous; Component[1].DataType = IndComponentType.Other; Component[1].ShowInDynInfo = false; Component[2].DataType = IndComponentType.Other; Component[2].ShowInDynInfo = false; break; case "The position opens below Moving Average": Component[0].PosPriceDependence = PositionPriceDependence.BuyLowerSelHigher; Component[0].UsePreviousBar = previous; Component[1].DataType = IndComponentType.Other; Component[1].ShowInDynInfo = false; Component[2].DataType = IndComponentType.Other; Component[2].ShowInDynInfo = false; break; case "The bar closes below Moving Average": BarClosesBelowIndicatorLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; case "The bar closes above Moving Average": BarClosesAboveIndicatorLogic(firstBar, previous, movingAverage, ref Component[1], ref Component[2]); break; } } }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters var basePrice = (BasePrice)IndParam.ListParam[1].Index; var period = (int)IndParam.NumParam[0].Value; double level = IndParam.NumParam[1].Value; int previous = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int firstBar = period + 2; double[] adBasePrice = Price(basePrice); var aroonUp = new double[Bars]; var aroonDown = new double[Bars]; var aroon = new double[Bars]; for (int bar = period; bar < Bars; bar++) { double highestHigh = double.MinValue; double lowestLow = double.MaxValue; for (int i = 0; i < period; i++) { int baseBar = bar - period + 1 + i; if (adBasePrice[baseBar] > highestHigh) { highestHigh = adBasePrice[baseBar]; aroonUp[bar] = 100.0 * i / (period - 1); } if (adBasePrice[baseBar] < lowestLow) { lowestLow = adBasePrice[baseBar]; aroonDown[bar] = 100.0 * i / (period - 1); } } } for (int bar = firstBar; bar < Bars; bar++) { aroon[bar] = aroonUp[bar] - aroonDown[bar]; } // Saving the components Component = new IndicatorComp[5]; Component[0] = new IndicatorComp { CompName = "Aroon Histogram", DataType = IndComponentType.IndicatorValue, ChartType = IndChartType.Histogram, FirstBar = firstBar, Value = aroon }; Component[1] = new IndicatorComp { CompName = "Aroon Up", DataType = IndComponentType.IndicatorValue, ChartType = IndChartType.Line, ChartColor = Color.Green, FirstBar = firstBar, Value = aroonUp }; Component[2] = new IndicatorComp { CompName = "Aroon Down", DataType = IndComponentType.IndicatorValue, ChartType = IndChartType.Line, ChartColor = Color.Red, FirstBar = firstBar, Value = aroonDown }; Component[3] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; Component[4] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, 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 var indLogic = IndicatorLogic.It_does_not_act_as_a_filter; switch (IndParam.ListParam[0].Text) { case "Aroon Histogram rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[] { 0 }; break; case "Aroon Histogram falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[] { 0 }; break; case "Aroon Histogram is higher than the Level line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; SpecialValues = new[] { level, -level }; break; case "Aroon Histogram is lower than the Level line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; SpecialValues = new[] { level, -level }; break; case "Aroon Histogram crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new[] { level, -level }; break; case "Aroon Histogram crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new[] { level, -level }; break; case "Aroon Histogram changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[] { 0 }; break; case "Aroon Histogram changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[] { 0 }; break; } OscillatorLogic(firstBar, previous, aroon, level, -level, ref Component[3], ref Component[4], indLogic); }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters double shift = IndParam.NumParam[0].Value * Point; int previous = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int firstBar = previous + 2; var pp = new double[Bars]; var r1 = new double[Bars]; var r2 = new double[Bars]; var r3 = new double[Bars]; var s1 = new double[Bars]; var s2 = new double[Bars]; var s3 = new double[Bars]; var high = new double[Bars]; var low = new double[Bars]; var close = new double[Bars]; if (IndParam.ListParam[1].Text == "One bar" || Period == DataPeriod.D1 || Period == DataPeriod.W1) { high = High; low = Low; close = Close; } else { previous = 0; high[0] = 0; low[0] = 0; close[0] = 0; double top = double.MinValue; double bottom = double.MaxValue; for (int bar = 1; bar < Bars; bar++) { if (High[bar - 1] > top) { top = High[bar - 1]; } if (Low[bar - 1] < bottom) { bottom = Low[bar - 1]; } if (Time[bar].Day != Time[bar - 1].Day) { high[bar] = top; low[bar] = bottom; close[bar] = Close[bar - 1]; top = double.MinValue; bottom = double.MaxValue; } else { high[bar] = high[bar - 1]; low[bar] = low[bar - 1]; close[bar] = close[bar - 1]; } } // first Bar for (int bar = 1; bar < Bars; bar++) { if (Time[bar].Day != Time[bar - 1].Day) { firstBar = bar; break; } } } for (int bar = firstBar; bar < Bars; bar++) { pp[bar] = (high[bar] + low[bar] + close[bar]) / 3; r1[bar] = 2 * pp[bar] - low[bar]; s1[bar] = 2 * pp[bar] - high[bar]; r2[bar] = pp[bar] + high[bar] - low[bar]; s2[bar] = pp[bar] - high[bar] + low[bar]; r3[bar] = high[bar] + 2 * (pp[bar] - low[bar]); s3[bar] = low[bar] - 2 * (high[bar] - pp[bar]); } Component = new IndicatorComp[9]; for (int iComp = 0; iComp < 7; iComp++) { Component[iComp] = new IndicatorComp { ChartType = IndChartType.Dot, ChartColor = Color.Violet, DataType = IndComponentType.IndicatorValue, FirstBar = firstBar }; } Component[3].ChartColor = Color.Blue; Component[0].Value = r3; Component[1].Value = r2; Component[2].Value = r1; Component[3].Value = pp; Component[4].Value = s1; Component[5].Value = s2; Component[6].Value = s3; Component[0].CompName = "Resistance 3"; Component[1].CompName = "Resistance 2"; Component[2].CompName = "Resistance 1"; Component[3].CompName = "Pivot Point"; Component[4].CompName = "Support 1"; Component[5].CompName = "Support 2"; Component[6].CompName = "Support 3"; Component[7] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; Component[8] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; if (SlotType == SlotTypes.Open) { Component[7].CompName = "Long position entry price"; Component[7].DataType = IndComponentType.OpenLongPrice; Component[8].CompName = "Short position entry price"; Component[8].DataType = IndComponentType.OpenShortPrice; } else if (SlotType == SlotTypes.Close) { Component[7].CompName = "Long position closing price"; Component[7].DataType = IndComponentType.CloseLongPrice; Component[8].CompName = "Short position closing price"; Component[8].DataType = IndComponentType.CloseShortPrice; } switch (IndParam.ListParam[0].Text) { case "Enter long at R3 (short at S3)": case "Exit long at R3 (short at S3)": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = r3[bar - previous] + shift; Component[8].Value[bar] = s3[bar - previous] - shift; } break; case "Enter long at R2 (short at S2)": case "Exit long at R2 (short at S2)": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = r2[bar - previous] + shift; Component[8].Value[bar] = s2[bar - previous] - shift; } break; case "Enter long at R1 (short at S1)": case "Exit long at R1 (short at S1)": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = r1[bar - previous] + shift; Component[8].Value[bar] = s1[bar - previous] - shift; } break; //--------------------------------------------------------------------- case "Enter the market at the Pivot Point": case "Exit the market at the Pivot Point": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = pp[bar - previous] + shift; Component[8].Value[bar] = pp[bar - previous] - shift; } break; //--------------------------------------------------------------------- case "Enter long at S1 (short at R1)": case "Exit long at S1 (short at R1)": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = s1[bar - previous] - shift; Component[8].Value[bar] = r1[bar - previous] + shift; } break; case "Enter long at S2 (short at R2)": case "Exit long at S2 (short at R2)": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = s2[bar - previous] - shift; Component[8].Value[bar] = r2[bar - previous] + shift; } break; case "Enter long at S3 (short at R3)": case "Exit long at S3 (short at R3)": for (int bar = firstBar; bar < Bars; bar++) { Component[7].Value[bar] = s3[bar - previous] - shift; Component[8].Value[bar] = r3[bar - previous] + shift; } break; } }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation const int firstBar = 3; var adAd = new double[Bars]; adAd[0] = (Close[0] - Low[0]) - (High[0] - Close[0]); if ((High[0] - Low[0]) > 0) { adAd[0] = adAd[0] / (High[0] - Low[0]) * Volume[0]; } else { adAd[0] = 0; } for (int iBar = 1; iBar < Bars; iBar++) { double dDelta = 0; double dRange = High[iBar] - Low[iBar]; if (dRange > 0) { dDelta = Volume[iBar] * (2 * Close[iBar] - High[iBar] - Low[iBar]) / dRange; } adAd[iBar] = adAd[iBar - 1] + dDelta; } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp { CompName = "Accumulation Distribution", DataType = IndComponentType.IndicatorValue, ChartType = IndChartType.Line, ChartColor = Color.Blue, FirstBar = firstBar, Value = adAd }; Component[1] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; Component[2] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, 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 var indLogic = IndicatorLogic.It_does_not_act_as_a_filter; switch (IndParam.ListParam[0].Text) { case "AD rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "AD falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "AD changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "AD changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; } OscillatorLogic(firstBar, iPrvs, adAd, 0, 0, ref Component[1], ref Component[2], indLogic); }
/// <summary> /// Returns signals for the logic rule "The bar opens below the Indicator after opening above it" /// </summary> protected void BarOpensBelowIndicatorAfterOpeningAboveLogic(int firstBar, int prvs, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adIndValue[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = Open[bar] < adIndValue[bar - prvs] - sigma && Open[baseBar] > adIndValue[baseBar - prvs] + sigma ? 1 : 0; indCompShort.Value[bar] = Open[bar] > adIndValue[bar - prvs] + sigma && Open[baseBar] < adIndValue[baseBar - prvs] - sigma ? 1 : 0; } }
public override void Calculate(IDataSet dataSet) { DataSet = dataSet; // Reading the parameters int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; const int firstBar = 3; var 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] / 1000; } else if (dAvg < dAvg1) { adMf[iBar] = adMf[iBar - 1] - dAvg * Volume[iBar] / 1000; } else { adMf[iBar] = adMf[iBar - 1]; } } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp { CompName = "Money Flow", DataType = IndComponentType.IndicatorValue, ChartType = IndChartType.Line, ChartColor = Color.Blue, FirstBar = firstBar, Value = adMf }; Component[1] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, Value = new double[Bars] }; Component[2] = new IndicatorComp { ChartType = IndChartType.NoChart, FirstBar = firstBar, 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 var indLogic = IndicatorLogic.It_does_not_act_as_a_filter; switch (IndParam.ListParam[0].Text) { case "Money Flow rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "Money Flow falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "Money Flow changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "Money Flow changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; } OscillatorLogic(firstBar, iPrvs, adMf, 0, 0, ref Component[1], ref Component[2], indLogic); }
protected void IndicatorChangesItsDirectionUpward(int firstBar, int prvs, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort) { double sigma = Sigma(); for (int bar = firstBar; bar < Bars; bar++) { int bar0 = bar - prvs; int bar1 = bar0 - 1; while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar) bar1--; int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar; while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar) bar2--; indCompLong.Value[bar] = (adIndValue[bar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; indCompShort.Value[bar] = (adIndValue[bar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; } }
/// <summary> /// Returns signals for the logic rule "The bar opens below the Indicator" /// </summary> protected void BarOpensBelowIndicatorLogic(int firstBar, int prvs, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Open[bar] < adIndValue[bar - prvs] - sigma ? 1 : 0; indCompShort.Value[bar] = Open[bar] > adIndValue[bar - prvs] + sigma ? 1 : 0; } }
/// <summary> /// Returns signals for the logic rule "The Indicator is lower than the AnotherIndicator" /// </summary> protected void IndicatorIsLowerThanAnotherIndicatorLogic(int firstBar, int prvs, double[] adIndValue, double[] adAnotherIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; indCompLong.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma ? 1 : 0; indCompShort.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma ? 1 : 0; } }
/// <summary> /// Returns signals for the logic rule "The Indicator crosses AnotherIndicator upward" /// </summary> protected void IndicatorCrossesAnotherIndicatorUpwardLogic(int firstBar, int prvs, double[] adIndValue, double[] adAnotherIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; 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; } }
/// <summary> /// Returns signals for the logic rule "Indicator rises". /// </summary> protected void IndicatorRisesLogic(int firstBar, int prvs, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; int baseBar = currentBar - 1; bool isNoChange = true; bool isHigher = adIndValue[currentBar] > adIndValue[baseBar]; while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar) { isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar])); baseBar--; } indCompLong.Value[bar] = adIndValue[currentBar] > adIndValue[baseBar] + sigma ? 1 : 0; indCompShort.Value[bar] = adIndValue[currentBar] < adIndValue[baseBar] - sigma ? 1 : 0; } }
/// <summary> /// Calculates the logic of a No Direction Oscillator. /// </summary> /// <param name="firstBar">The first bar number.</param> /// <param name="prvs">To use the previous bar or not.</param> /// <param name="adIndValue">The indicator values.</param> /// <param name="dLevel">The Level value.</param> /// <param name="indComp">Indicator component where to save the results.</param> /// <param name="indLogic">The chosen logic.</param> /// <returns>True if everything is ok.</returns> protected void NoDirectionOscillatorLogic(int firstBar, int prvs, double[] adIndValue, double dLevel, ref IndicatorComp indComp, IndicatorLogic indLogic) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); switch (indLogic) { case IndicatorLogic.The_indicator_rises: for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; int baseBar = currentBar - 1; bool isHigher = adIndValue[currentBar] > adIndValue[baseBar]; bool isNoChange = true; while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar) { isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar])); baseBar--; } indComp.Value[bar] = adIndValue[baseBar] < adIndValue[currentBar] - sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_falls: for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; int baseBar = currentBar - 1; bool isHigher = adIndValue[currentBar] > adIndValue[baseBar]; bool isNoChange = true; while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar) { isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar])); baseBar--; } indComp.Value[bar] = adIndValue[baseBar] > adIndValue[currentBar] + sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_is_higher_than_the_level_line: for (int bar = firstBar; bar < Bars; bar++) { indComp.Value[bar] = adIndValue[bar - prvs] > dLevel + sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_is_lower_than_the_level_line: for (int bar = firstBar; bar < Bars; bar++) { indComp.Value[bar] = adIndValue[bar - prvs] < dLevel - sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_crosses_the_level_line_upward: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - prvs - 1; while (Math.Abs(adIndValue[baseBar] - dLevel) < sigma && baseBar > firstBar) { baseBar--; } indComp.Value[bar] = (adIndValue[baseBar] < dLevel - sigma && adIndValue[bar - prvs] > dLevel + sigma) ? 1 : 0; } break; case IndicatorLogic.The_indicator_crosses_the_level_line_downward: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - prvs - 1; while (Math.Abs(adIndValue[baseBar] - dLevel) < sigma && baseBar > firstBar) { baseBar--; } indComp.Value[bar] = (adIndValue[baseBar] > dLevel + sigma && adIndValue[bar - prvs] < dLevel - sigma) ? 1 : 0; } break; case IndicatorLogic.The_indicator_changes_its_direction_upward: for (int bar = firstBar; bar < Bars; bar++) { int bar0 = bar - prvs; int bar1 = bar0 - 1; while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar) { bar1--; } int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar; while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar) { bar2--; } indComp.Value[bar] = (adIndValue[bar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; } break; case IndicatorLogic.The_indicator_changes_its_direction_downward: for (int bar = firstBar; bar < Bars; bar++) { int bar0 = bar - prvs; int bar1 = bar0 - 1; while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar) { bar1--; } int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar; while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar) { bar2--; } indComp.Value[bar] = (adIndValue[bar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; } break; default: return; } }
/// <summary> /// Calculates the logic of an Oscillator. /// </summary> /// <param name="firstBar">The first bar number.</param> /// <param name="prvs">To use the previous bar or not.</param> /// <param name="adIndValue">The indicator values.</param> /// <param name="levelLong">The Level value for a Long position.</param> /// <param name="levelShort">The Level value for a Short position.</param> /// <param name="indCompLong">Indicator component for Long position.</param> /// <param name="indCompShort">Indicator component for Short position.</param> /// <param name="indLogic">The chosen logic.</param> /// <returns>True if everything is ok.</returns> protected void OscillatorLogic(int firstBar, int prvs, double[] adIndValue, double levelLong, double levelShort, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort, IndicatorLogic indLogic) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); switch (indLogic) { case IndicatorLogic.The_indicator_rises: for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; int baseBar = currentBar - 1; bool isHigher = adIndValue[currentBar] > adIndValue[baseBar]; if (!IsDiscreteValues) // Aroon oscillator uses IsDiscreteValues = true { bool isNoChange = true; while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar) { isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar])); baseBar--; } } indCompLong.Value[bar] = adIndValue[baseBar] < adIndValue[currentBar] - sigma ? 1 : 0; indCompShort.Value[bar] = adIndValue[baseBar] > adIndValue[currentBar] + sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_falls: for (int bar = firstBar; bar < Bars; bar++) { int currentBar = bar - prvs; int baseBar = currentBar - 1; bool isHigher = adIndValue[currentBar] > adIndValue[baseBar]; if (!IsDiscreteValues) // Aroon oscillator uses IsDiscreteValues = true { bool isNoChange = true; while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar) { isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar])); baseBar--; } } indCompLong.Value[bar] = adIndValue[baseBar] > adIndValue[currentBar] + sigma ? 1 : 0; indCompShort.Value[bar] = adIndValue[baseBar] < adIndValue[currentBar] - sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_is_higher_than_the_level_line: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = adIndValue[bar - prvs] > levelLong + sigma ? 1 : 0; indCompShort.Value[bar] = adIndValue[bar - prvs] < levelShort - sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_is_lower_than_the_level_line: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = adIndValue[bar - prvs] < levelLong - sigma ? 1 : 0; indCompShort.Value[bar] = adIndValue[bar - prvs] > levelShort + sigma ? 1 : 0; } break; case IndicatorLogic.The_indicator_crosses_the_level_line_upward: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - prvs - 1; while (Math.Abs(adIndValue[baseBar] - levelLong) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = (adIndValue[baseBar] < levelLong - sigma && adIndValue[bar - prvs] > levelLong + sigma) ? 1 : 0; indCompShort.Value[bar] = (adIndValue[baseBar] > levelShort + sigma && adIndValue[bar - prvs] < levelShort - sigma) ? 1 : 0; } break; case IndicatorLogic.The_indicator_crosses_the_level_line_downward: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - prvs - 1; while (Math.Abs(adIndValue[baseBar] - levelLong) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = (adIndValue[baseBar] > levelLong + sigma && adIndValue[bar - prvs] < levelLong - sigma) ? 1 : 0; indCompShort.Value[bar] = (adIndValue[baseBar] < levelShort - sigma && adIndValue[bar - prvs] > levelShort + sigma) ? 1 : 0; } break; case IndicatorLogic.The_indicator_changes_its_direction_upward: for (int bar = firstBar; bar < Bars; bar++) { int bar0 = bar - prvs; int bar1 = bar0 - 1; while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar) { bar1--; } int iBar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar; while (Math.Abs(adIndValue[bar1] - adIndValue[iBar2]) < sigma && iBar2 > firstBar) { iBar2--; } indCompLong.Value[bar] = (adIndValue[iBar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; indCompShort.Value[bar] = (adIndValue[iBar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; } break; case IndicatorLogic.The_indicator_changes_its_direction_downward: for (int bar = firstBar; bar < Bars; bar++) { int bar0 = bar - prvs; int bar1 = bar0 - 1; while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar) { bar1--; } int iBar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar; while (Math.Abs(adIndValue[bar1] - adIndValue[iBar2]) < sigma && iBar2 > firstBar) { iBar2--; } indCompLong.Value[bar] = (adIndValue[iBar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; indCompShort.Value[bar] = (adIndValue[iBar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0; } break; default: return; } }
/// <summary> /// Calculates the logic of a band indicator. /// </summary> /// <param name="firstBar">The first bar number.</param> /// <param name="prvs">To use the previous bar or not.</param> /// <param name="adUpperBand">The Upper band values.</param> /// <param name="adLowerBand">The Lower band values.</param> /// <param name="indCompLong">Indicator component for Long position.</param> /// <param name="indCompShort">Indicator component for Short position.</param> /// <param name="indLogic">The chosen logic.</param> protected void BandIndicatorLogic(int firstBar, int prvs, double[] adUpperBand, double[] adLowerBand, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort, BandIndLogic indLogic) { double sigma = Sigma(); firstBar = Math.Max(firstBar, 2); switch (indLogic) { case BandIndLogic.The_bar_opens_below_the_Upper_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0; indCompShort.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_above_the_Upper_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0; indCompShort.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_below_the_Lower_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0; indCompShort.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_above_the_Lower_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0; indCompShort.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_below_the_Upper_Band_after_opening_above_it: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma && Open[baseBar] > adUpperBand[baseBar - prvs] + sigma ? 1 : 0; baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompShort.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma && Open[baseBar] < adLowerBand[baseBar - prvs] - sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_above_the_Upper_Band_after_opening_below_it: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma && Open[baseBar] < adUpperBand[baseBar - prvs] - sigma ? 1 : 0; baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompShort.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma && Open[baseBar] > adLowerBand[baseBar - prvs] + sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_below_the_Lower_Band_after_opening_above_it: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma && Open[baseBar] > adLowerBand[baseBar - prvs] + sigma ? 1 : 0; baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompShort.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma && Open[baseBar] < adUpperBand[baseBar - prvs] - sigma ? 1 : 0; } break; case BandIndLogic.The_bar_opens_above_the_Lower_Band_after_opening_below_it: for (int bar = firstBar; bar < Bars; bar++) { int baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompLong.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma && Open[baseBar] < adLowerBand[baseBar - prvs] - sigma ? 1 : 0; baseBar = bar - 1; while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar) { baseBar--; } indCompShort.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma && Open[baseBar] > adUpperBand[baseBar - prvs] + sigma ? 1 : 0; } break; case BandIndLogic.The_bar_closes_below_the_Upper_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Close[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0; indCompShort.Value[bar] = Close[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0; } break; case BandIndLogic.The_bar_closes_above_the_Upper_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Close[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0; indCompShort.Value[bar] = Close[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0; } break; case BandIndLogic.The_bar_closes_below_the_Lower_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Close[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0; indCompShort.Value[bar] = Close[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0; } break; case BandIndLogic.The_bar_closes_above_the_Lower_Band: for (int bar = firstBar; bar < Bars; bar++) { indCompLong.Value[bar] = Close[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0; indCompShort.Value[bar] = Close[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0; } break; default: 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[] adMFI = new double[Bars]; int iFirstBar = 5; for (int iBar = 0; iBar < Bars; iBar++) { if (Volume[iBar] > 0) adMFI[iBar] = 10000 * (High[iBar] - Low[iBar]) / Volume[iBar]; else adMFI[iBar] = 10000 * (High[iBar] - Low[iBar]); } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "Market Facilitation Index"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Histogram; 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 Market Facilitation Index rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The Market Facilitation Index falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The Market Facilitation Index changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The Market Facilitation Index changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } NoDirectionOscillatorLogic(iFirstBar, iPrvs, adMFI, 0, ref Component[1], indLogic); Component[2].Value = Component[1].Value; return; }