/// <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) { // Reading the parameters double minGap = Point * IndParam.NumParam[0].Value; // Calculating int firstBar = 1; double[] longSignals = new double[Bars]; double[] shortSignals = new double[Bars]; if (IndParam.ListParam[0].Text == "Positive gap") { for (int bar = firstBar; bar < Bars; bar++) { if (Open[bar] > Close[bar - 1] + minGap) { longSignals[bar] = 1; } if (Open[bar] < Close[bar - 1] - minGap) { shortSignals[bar] = 1; } } } if (IndParam.ListParam[0].Text == "Negative gap") { for (int bar = firstBar; bar < Bars; bar++) { if (Open[bar] < Close[bar - 1] - minGap) { longSignals[bar] = 1; } if (Open[bar] > Close[bar - 1] + minGap) { shortSignals[bar] = 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].FirstBar = firstBar; Component[0].Value = longSignals; Component[1] = new IndicatorComp(); Component[1].CompName = "Allow short entry"; Component[1].DataType = IndComponentType.AllowOpenShort; Component[1].ChartType = IndChartType.NoChart; Component[1].FirstBar = firstBar; Component[1].Value = shortSignals; 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) { // Calculation int iPeriod = (int)IndParam.NumParam[1].Value; double p1 = (double)IndParam.NumParam[0].Value; p1 = p1 / 100; int iFirstBar = 1; double[] up1 = new double[Bars]; double[] down1 = new double[Bars]; double point = (Digits == 5 || Digits == 3) ? 10 * Point : Point; for (int iBar = 6; iBar < Bars; iBar++) { if (Math.Abs(Close[iBar - iPeriod] - Open[iBar - iPeriod]) >= (High[iBar - iPeriod] - Low[iBar - iPeriod]) * p1) { if (Close[iBar - iPeriod] > Open[iBar - iPeriod]) { up1[iBar] = 1; } else { down1[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].FirstBar = iFirstBar; Component[0].Value = up1; 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 = down1; 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 int firstBar = 4; double[] longSignals = new double[Bars]; double[] shortSignals = new double[Bars]; for (int bar = firstBar; bar < Bars; bar++) { // Long trade if (Close[bar - 3] < Open[bar - 3] && // Candle 1 is black Low[bar - 2] < Low[bar - 3] && // Candle 2 has lower low than candle 1 Close[bar - 1] > Open[bar - 1] && // Candle 3 is white Low[bar - 1] > Low[bar - 2] && // Candle 3 has higher low than candle 2 Close[bar - 1] > Open[bar - 3]) // Candle 3 closes above candle 1 open { longSignals[bar] = 1; } // Short trade if (Close[bar - 3] > Open[bar - 3] && // Candle 1 is white High[bar - 2] > High[bar - 3] && // Candle 2 has higher high than candle 1 Close[bar - 1] < Open[bar - 1] && // Candle 3 is black High[bar - 1] < High[bar - 2] && // Candle 3 has lower high than candle 2 Close[bar - 1] < Open[bar - 3]) // Candle 3 closes below candle 1 open { shortSignals[bar] = 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].FirstBar = firstBar; Component[0].Value = longSignals; Component[1] = new IndicatorComp(); Component[1].CompName = "Allow short entry"; Component[1].DataType = IndComponentType.AllowOpenShort; Component[1].ChartType = IndChartType.NoChart; Component[1].FirstBar = firstBar; Component[1].Value = shortSignals; 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) { int nExit = (int)IndParam.NumParam[0].Value; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "N Bars Exit (" + nExit.ToString() + ")"; Component[0].DataType = IndComponentType.ForceClose; Component[0].ChartType = IndChartType.NoChart; Component[0].ShowInDynInfo = true; Component[0].FirstBar = 1; Component[0].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 int iPERCENT = (int)IndParam.NumParam[0].Value; // Calculation int iFirstBar = 1; double[] doji = new double[Bars]; double point = (Digits == 5 || Digits == 3) ? 10 * Point : Point; for (int iBar = 1; iBar < Bars; iBar++) { if (Math.Abs(Close[iBar - 1] - Open[iBar - 1]) < iPERCENT * 0.01 * (High[iBar - 1] - Low[iBar - 1])) { doji[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].FirstBar = iFirstBar; Component[0].Value = doji; 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 = doji; return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Reading the parameters int iFromDay = (int)IndParam.ListParam[1].Index; int iFromHour = (int)IndParam.NumParam[0].Value; int iFromMin = (int)IndParam.NumParam[1].Value; int iUntilDay = (int)IndParam.ListParam[2].Index; int iUntilHour = (int)IndParam.NumParam[2].Value; int iUntilMin = (int)IndParam.NumParam[3].Value; TimeSpan tsFromTime = new TimeSpan(iFromDay, iFromHour, iFromMin, 0); TimeSpan tsUntilTime = new TimeSpan(iUntilDay, iUntilHour, iUntilMin, 0); // Calculation int iFirstBar = 1; double[] adBars = new double[Bars]; // Calculation of the logic for (int iBar = iFirstBar; iBar < Bars; iBar++) { TimeSpan tsBar = new TimeSpan((int)Date[iBar].DayOfWeek, Date[iBar].Hour, Date[iBar].Minute, 0); adBars[iBar] = tsBar >= tsFromTime && tsBar < tsUntilTime ? 1 : 0; } // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "Force close position"; Component[0].DataType = IndComponentType.ForceClose; Component[0].ChartType = IndChartType.NoChart; Component[0].ShowInDynInfo = false; Component[0].FirstBar = iFirstBar; Component[0].Value = adBars; return; }
/// <summary> /// Returns a copy /// </summary> public IndicatorComp Clone() { IndicatorComp icomp = new IndicatorComp(); icomp.compName = compName; icomp.dataType = dataType; icomp.chartType = chartType; icomp.chartColor = chartColor; icomp.firstBar = firstBar; icomp.prvs = prvs; icomp.isDynInfo = isDynInfo; icomp.posPriceDependence = posPriceDependence; if (adValue != null) { icomp.adValue = new double[adValue.Length]; adValue.CopyTo(icomp.adValue, 0); } return(icomp); }
/// <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> /// The default constructor /// </summary> protected Indicator() { ExitFilterShortDescription = "Not defined"; EntryFilterShortDescription = "Not defined"; ExitFilterLongDescription = "Not defined"; EntryFilterLongDescription = "Not defined"; ExitPointShortDescription = "Not defined"; ExitPointLongDescription = "Not defined"; EntryPointShortDescription = "Not defined"; EntryPointLongDescription = "Not defined"; IndicatorName = string.Empty; PossibleSlots = SlotTypes.NotDefined; SeparatedChart = false; SeparatedChartMinValue = double.MaxValue; SeparatedChartMaxValue = double.MinValue; IsDescreteValues = false; CustomIndicator = false; WarningMessage = string.Empty; AllowClosingFilters = false; SpecialValues = new double[] {}; IndParam = new IndicatorParam(); Component = new 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 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) { // 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 MAMethod maMethod1 = (MAMethod)IndParam.ListParam[1].Index; MAMethod maMethod2 = (MAMethod)IndParam.ListParam[2].Index; BasePrice price = (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 + 1; double[] adPrice = Price(price); double[] adMA = MovingAverage(iPeriod1, 0, maMethod1, adPrice); double[] adMAPr = new double[Bars]; for (int iBar = 0; iBar < Bars; iBar++) { adMAPr[iBar] = adPrice[iBar] - adMA[iBar]; } double[] adDO = MovingAverage(iPeriod2, 0, maMethod2, adMAPr); // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "Detrended Oscillator"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.LightSeaGreen; Component[0].FirstBar = iFirstBar; Component[0].Value = adDO; 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 Detrended Oscillator rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The Detrended Oscillator falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The Detrended Oscillator is higher than the zero line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; break; case "The Detrended Oscillator is lower than the zero line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; break; case "The Detrended Oscillator crosses the zero line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; break; case "The Detrended Oscillator crosses the zero line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; break; case "The Detrended Oscillator changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The Detrended Oscillator changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adDO, 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 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 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[] adDeMax = new double[Bars]; double[] adDeMin = new double[Bars]; double[] adDeMarker = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { adDeMax[iBar] = High[iBar] > High[iBar - 1] ? High[iBar] - High[iBar - 1] : 0; adDeMin[iBar] = Low[iBar] < Low[iBar - 1] ? Low[iBar - 1] - Low[iBar] : 0; } double[] adDeMaxMA = MovingAverage(iPeriod, 0, maMethod, adDeMax); double[] adDeMinMA = MovingAverage(iPeriod, 0, maMethod, adDeMin); for (int iBar = iFirstBar; iBar < Bars; iBar++) { if (adDeMaxMA[iBar] + adDeMinMA[iBar] == 0) { adDeMarker[iBar] = 0; } else { adDeMarker[iBar] = adDeMaxMA[iBar] / (adDeMaxMA[iBar] + adDeMinMA[iBar]); } } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "DeMarker"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.RoyalBlue; Component[0].FirstBar = iFirstBar; Component[0].Value = adDeMarker; 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 DeMarker rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { 0.5 }; break; case "The DeMarker falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { 0.5 }; break; case "The DeMarker is higher than the Level line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker is lower than the Level line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { 0.5 }; break; case "The DeMarker changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { 0.5 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adDeMarker, dLevel, 1 - 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 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 double[] adBasePrice = Price(basePrice); double[] adMA = new double[Bars]; int iFirstBar = iPeriod + iSmooth + 1 + iPrvs; // Calculating Chande Momentum Oscillator double[] adCMO1 = new double[Bars]; double[] adCMO2 = new double[Bars]; double[] adCMO1Sum = new double[Bars]; double[] adCMO2Sum = new double[Bars]; double[] adCMO = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { adCMO1[iBar] = 0; adCMO2[iBar] = 0; if (adBasePrice[iBar] > adBasePrice[iBar - 1]) { adCMO1[iBar] = adBasePrice[iBar] - adBasePrice[iBar - 1]; } if (adBasePrice[iBar] < adBasePrice[iBar - 1]) { adCMO2[iBar] = adBasePrice[iBar - 1] - adBasePrice[iBar]; } } for (int iBar = 0; iBar < iPeriod; iBar++) { adCMO1Sum[iPeriod - 1] += adCMO1[iBar]; adCMO2Sum[iPeriod - 1] += adCMO2[iBar]; } for (int iBar = iPeriod; iBar < Bars; iBar++) { adCMO1Sum[iBar] = adCMO1Sum[iBar - 1] + adCMO1[iBar] - adCMO1[iBar - iPeriod]; adCMO2Sum[iBar] = adCMO2Sum[iBar - 1] + adCMO2[iBar] - adCMO2[iBar - iPeriod]; if (adCMO1Sum[iBar] + adCMO2Sum[iBar] == 0) { adCMO[iBar] = 100; } else { adCMO[iBar] = 100 * (adCMO1Sum[iBar] - adCMO2Sum[iBar]) / (adCMO1Sum[iBar] + adCMO2Sum[iBar]); } } double SC = 2.0 / (iSmooth + 1); for (int iBar = 0; iBar < iPeriod; iBar++) { adMA[iBar] = adBasePrice[iBar]; } for (int iBar = iPeriod; iBar < Bars; iBar++) { double dAbsCMO = Math.Abs(adCMO[iBar]) / 100; adMA[iBar] = SC * dAbsCMO * adBasePrice[iBar] + (1 - SC * dAbsCMO) * adMA[iBar - 1]; } // 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 = 2; 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]) || // It jumps below the current bar (dValue1 <Low[iBar - 1] && dValue> Open[iBar]) || // It jumps above the current bar (Close[iBar - 1] < dValue && dValue < Open[iBar]) || // Positive gap (Close[iBar - 1] > dValue && dValue > Open[iBar])) // Negative gap { dTempVal = Open[iBar]; } Component[1].Value[iBar] = dTempVal; } } 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 Vidya Moving Average rises": IndicatorRisesLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The Vidya Moving Average falls": IndicatorFallsLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens above the Vidya Moving Average": BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens below the Vidya Moving Average": BarOpensBelowIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens above the Vidya Moving Average after opening below it": BarOpensAboveIndicatorAfterOpeningBelowLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens below the Vidya Moving Average after opening above it": BarOpensBelowIndicatorAfterOpeningAboveLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The position opens above the Vidya 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 Vidya 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 Vidya Moving Average": BarClosesBelowIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar closes above the Vidya 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 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 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) { 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 iYear = (int)IndParam.NumParam[0].Value; int iMonth = (int)IndParam.NumParam[1].Value; DateTime dtKeyDate = new DateTime(iYear, iMonth, 1); // Calculation int iFirstBar = 0; double[] adBars = new double[Bars]; // Calculation of the logic. switch (IndParam.ListParam[0].Text) { case "Do not open positions after": for (int iBar = iFirstBar; iBar < Bars; iBar++) if (Time[iBar] < dtKeyDate) adBars[iBar] = 1; break; case "Do not open positions before": for (int iBar = iFirstBar; iBar < Bars; iBar++) { if (Time[iBar] >= dtKeyDate) { iFirstBar = iBar; break; } } iFirstBar = (int)Math.Min(iFirstBar, Bars - Configs.MIN_BARS); for (int iBar = iFirstBar; iBar < Bars; iBar++) { adBars[iBar] = 1; } break; default: break; } // 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> /// 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 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 double[] adBasePrice = Price(basePrice); double[] adMA = new double[Bars]; int iFirstBar = iPeriod + iSmooth + 1 + iPrvs; // Calculating Chande Momentum Oscillator double[] adCMO1 = new double[Bars]; double[] adCMO2 = new double[Bars]; double[] adCMO1Sum = new double[Bars]; double[] adCMO2Sum = new double[Bars]; double[] adCMO = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { adCMO1[iBar] = 0; adCMO2[iBar] = 0; if (adBasePrice[iBar] > adBasePrice[iBar - 1]) adCMO1[iBar] = adBasePrice[iBar] - adBasePrice[iBar - 1]; if (adBasePrice[iBar] < adBasePrice[iBar - 1]) adCMO2[iBar] = adBasePrice[iBar - 1] - adBasePrice[iBar]; } for (int iBar = 0; iBar < iPeriod; iBar++) { adCMO1Sum[iPeriod - 1] += adCMO1[iBar]; adCMO2Sum[iPeriod - 1] += adCMO2[iBar]; } for (int iBar = iPeriod; iBar < Bars; iBar++) { adCMO1Sum[iBar] = adCMO1Sum[iBar - 1] + adCMO1[iBar] - adCMO1[iBar - iPeriod]; adCMO2Sum[iBar] = adCMO2Sum[iBar - 1] + adCMO2[iBar] - adCMO2[iBar - iPeriod]; if (adCMO1Sum[iBar] + adCMO2Sum[iBar] == 0) adCMO[iBar] = 100; else adCMO[iBar] = 100 * (adCMO1Sum[iBar] - adCMO2Sum[iBar]) / (adCMO1Sum[iBar] + adCMO2Sum[iBar]); } double SC = 2.0 / (iSmooth + 1); for (int iBar = 0; iBar < iPeriod; iBar++) adMA[iBar] = adBasePrice[iBar]; for (int iBar = iPeriod; iBar < Bars; iBar++) { double dAbsCMO = Math.Abs(adCMO[iBar]) / 100; adMA[iBar] = SC * dAbsCMO * adBasePrice[iBar] + (1 - SC * dAbsCMO) * adMA[iBar - 1]; } // 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 = 2; 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]) || // It jumps below the current bar (dValue1 < Low[iBar - 1] && dValue > Open[iBar]) || // It jumps above the current bar (Close[iBar - 1] < dValue && dValue < Open[iBar]) || // Positive gap (Close[iBar - 1] > dValue && dValue > Open[iBar])) // Negative gap dTempVal = Open[iBar]; Component[1].Value[iBar] = dTempVal; } } 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 Vidya Moving Average rises": IndicatorRisesLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The Vidya Moving Average falls": IndicatorFallsLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens above the Vidya Moving Average": BarOpensAboveIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens below the Vidya Moving Average": BarOpensBelowIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens above the Vidya Moving Average after opening below it": BarOpensAboveIndicatorAfterOpeningBelowLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar opens below the Vidya Moving Average after opening above it": BarOpensBelowIndicatorAfterOpeningAboveLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The position opens above the Vidya 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 Vidya 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 Vidya Moving Average": BarClosesBelowIndicatorLogic(iFirstBar, iPrvs, adMA, ref Component[1], ref Component[2]); break; case "The bar closes above the Vidya 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; MAMethod slMethod = (MAMethod )IndParam.ListParam[3].Index; BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index; int nSlow = (int)IndParam.NumParam[0].Value; int nFast = (int)IndParam.NumParam[1].Value; int nSignal = (int)IndParam.NumParam[2].Value; double dLevel = IndParam.NumParam[3].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int iFirstBar = nSlow + nFast + 2; double[] adMASlow = MovingAverage(nSlow, 0, maMethod, Price(basePrice)); double[] adMAFast = MovingAverage(nFast, 0, maMethod, Price(basePrice)); double[] adMACD = new double[Bars]; for (int iBar = nSlow - 1; iBar < Bars; iBar++) adMACD[iBar] = adMAFast[iBar] - adMASlow[iBar]; double[] maSignalLine = MovingAverage(nSignal, 0, slMethod, adMACD); // adHistogram reprezents the MACD oscillator double[] adHistogram = new double[Bars]; for (int iBar = nSlow + nSignal - 1; iBar < Bars; iBar++) adHistogram[iBar] = adMACD[iBar] - maSignalLine[iBar]; // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "OsMA"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Histogram; Component[0].FirstBar = iFirstBar; Component[0].Value = adHistogram; 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 OsMA rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The OsMA falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The OsMA 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 OsMA 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 OsMA crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, - dLevel }; break; case "The OsMA crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, - dLevel }; break; case "The OsMA changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The OsMA changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adHistogram, 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; 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 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 int iPeriod = (int)IndParam.NumParam[0].Value; int iShift = (int)IndParam.NumParam[1].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation double[] adUpBand = new double[Bars]; double[] adDnBand = new double[Bars]; int iFirstBar = iPeriod + iShift + iPrvs + 2; for (int iBar = iFirstBar; iBar < Bars - iShift; iBar++) { double dMax = double.MinValue; double dMin = double.MaxValue; for (int i = 0; i < iPeriod; i++) { if (High[iBar - i] > dMax) { dMax = High[iBar - i]; } if (Low[iBar - i] < dMin) { dMin = Low[iBar - i]; } } adUpBand[iBar + iShift] = dMax; adDnBand[iBar + iShift] = dMin; } // Saving the components Component = new IndicatorComp[4]; 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 = "Lower Band"; Component[1].DataType = IndComponentType.IndicatorValue; Component[1].ChartType = IndChartType.Line; Component[1].ChartColor = Color.Blue; Component[1].FirstBar = iFirstBar; Component[1].Value = adDnBand; 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].DataType = IndComponentType.OpenLongPrice; Component[2].CompName = "Long position entry price"; Component[3].DataType = IndComponentType.OpenShortPrice; Component[3].CompName = "Short position entry price"; } else 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.Close) { Component[2].DataType = IndComponentType.CloseLongPrice; Component[2].CompName = "Long position closing price"; Component[3].DataType = IndComponentType.CloseShortPrice; Component[3].CompName = "Short position closing price"; } 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"; } if (slotType == SlotTypes.Open || slotType == SlotTypes.Close) { if (iPeriod > 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[2].Value[iBar] = dTempValUp; Component[3].Value[iBar] = dTempValDown; } else { Component[2].Value[iBar] = dTempValDown; Component[3].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[2].Value[iBar] = adUpBand[iBar - iPrvs]; Component[3].Value[iBar] = adDnBand[iBar - iPrvs]; } else { Component[2].Value[iBar] = adDnBand[iBar - iPrvs]; Component[3].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[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Upper_Band); break; case "The bar opens above the Upper Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_above_the_Upper_Band); break; case "The bar opens below the Lower Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_opens_below_the_Lower_Band); break; case "The bar opens above the Lower Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], 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[2], ref Component[3], 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[2], ref Component[3], 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[2], ref Component[3], 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[2], ref Component[3], 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[1].PosPriceDependence = PositionPriceDependence.PriceSellLower; Component[0].UsePreviousBar = iPrvs; Component[1].UsePreviousBar = iPrvs; Component[2].DataType = IndComponentType.Other; Component[3].DataType = IndComponentType.Other; Component[2].ShowInDynInfo = false; Component[3].ShowInDynInfo = false; break; case "The position opens below the Upper Band": Component[0].PosPriceDependence = PositionPriceDependence.PriceBuyLower; Component[1].PosPriceDependence = PositionPriceDependence.PriceSellHigher; Component[0].UsePreviousBar = iPrvs; Component[1].UsePreviousBar = iPrvs; Component[2].DataType = IndComponentType.Other; Component[3].DataType = IndComponentType.Other; Component[2].ShowInDynInfo = false; Component[3].ShowInDynInfo = false; break; case "The position opens above the Lower Band": Component[0].PosPriceDependence = PositionPriceDependence.PriceSellLower; Component[1].PosPriceDependence = PositionPriceDependence.PriceBuyHigher; Component[0].UsePreviousBar = iPrvs; Component[1].UsePreviousBar = iPrvs; Component[2].DataType = IndComponentType.Other; Component[3].DataType = IndComponentType.Other; Component[2].ShowInDynInfo = false; Component[3].ShowInDynInfo = false; break; case "The position opens below the Lower Band": Component[0].PosPriceDependence = PositionPriceDependence.PriceSellHigher; Component[1].PosPriceDependence = PositionPriceDependence.PriceBuyLower; Component[0].UsePreviousBar = iPrvs; Component[1].UsePreviousBar = iPrvs; Component[2].DataType = IndComponentType.Other; Component[3].DataType = IndComponentType.Other; Component[2].ShowInDynInfo = false; Component[3].ShowInDynInfo = false; break; case "The bar closes below the Upper Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Upper_Band); break; case "The bar closes above the Upper Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_above_the_Upper_Band); break; case "The bar closes below the Lower Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], BandIndLogic.The_bar_closes_below_the_Lower_Band); break; case "The bar closes above the Lower Band": BandIndicatorLogic(iFirstBar, iPrvs, adUpBand, adDnBand, ref Component[2], ref Component[3], 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 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[2].Index; rsi1.IndParam.NumParam[0].Value = IndParam.NumParam[0].Value; rsi1.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked; rsi1.Calculate(slotType); RSI rsi2 = new RSI(slotType); rsi2.IndParam.ListParam[1].Index = IndParam.ListParam[1].Index; rsi2.IndParam.ListParam[2].Index = IndParam.ListParam[2].Index; rsi2.IndParam.NumParam[0].Value = IndParam.NumParam[1].Value; rsi2.IndParam.CheckParam[0].Checked = IndParam.CheckParam[0].Checked; rsi2.Calculate(slotType); adIndicator1 = rsi1.Component[0].Value; adIndicator2 = rsi2.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 = "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 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; } OscillatorLogic(iFirstBar, iPrvs, adOscllator, 0, 0, ref Component[1], ref Component[2], indLogic); return; }
/// <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 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[] adDeMax = new double[Bars]; double[] adDeMin = new double[Bars]; double[] adDeMarker = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { adDeMax[iBar] = High[iBar] > High[iBar - 1] ? High[iBar] - High[iBar - 1] : 0; adDeMin[iBar] = Low[iBar] < Low[iBar - 1] ? Low[iBar - 1] - Low[iBar] : 0; } double[] adDeMaxMA = MovingAverage(iPeriod, 0, maMethod, adDeMax); double[] adDeMinMA = MovingAverage(iPeriod, 0, maMethod, adDeMin); for (int iBar = iFirstBar; iBar < Bars; iBar++) { if (adDeMaxMA[iBar] + adDeMinMA[iBar] == 0) adDeMarker[iBar] = 0; else adDeMarker[iBar] = adDeMaxMA[iBar] / (adDeMaxMA[iBar] + adDeMinMA[iBar]); } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "DeMarker"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.RoyalBlue; Component[0].FirstBar = iFirstBar; Component[0].Value = adDeMarker; 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 DeMarker rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { 0.5 }; break; case "The DeMarker falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { 0.5 }; break; case "The DeMarker is higher than the Level line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker is lower than the Level line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, 1 - dLevel }; break; case "The DeMarker changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { 0.5 }; break; case "The DeMarker changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { 0.5 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adDeMarker, dLevel, 1 - dLevel, ref Component[1], ref Component[2], indLogic); 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; int period = (int)IndParam.NumParam[0].Value; double level = Point * 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); // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "Average True Range"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.Blue; Component[0].FirstBar = firstBar; Component[0].Value = ATR; 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 ATR rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The ATR falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The ATR is higher than the Level line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; SpecialValues = new double[1] { level }; break; case "The ATR is lower than the Level line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; SpecialValues = new double[1] { level }; break; case "The ATR crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[1] { level }; break; case "The ATR crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[1] { level }; break; case "The ATR changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The ATR changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } // ATR rises equal signals in both directions! NoDirectionOscillatorLogic(firstBar, prev, ATR, level, 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; BasePrice basePrice = (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 int iFirstBar = iPeriod + 2; double[] adBasePrice = Price(basePrice); double[] adPos = new double[Bars]; double[] adNeg = new double[Bars]; double[] adRSI = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { if (adBasePrice[iBar] > adBasePrice[iBar - 1]) adPos[iBar] = adBasePrice[iBar] - adBasePrice[iBar - 1]; if (adBasePrice[iBar] < adBasePrice[iBar - 1]) adNeg[iBar] = adBasePrice[iBar - 1] - adBasePrice[iBar]; } double[] adPosMA = MovingAverage(iPeriod, 0, maMethod, adPos); double[] adNegMA = MovingAverage(iPeriod, 0, maMethod, adNeg); for (int iBar = iFirstBar; iBar < Bars; iBar++) { if (adNegMA[iBar] == 0) adRSI[iBar] = 100; else adRSI[iBar] = 100 - (100 / (1 + adPosMA[iBar] / adNegMA[iBar])); } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "RSI"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.RoyalBlue; Component[0].FirstBar = iFirstBar; Component[0].Value = adRSI; 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 rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { 50 }; break; case "The RSI falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { 50 }; break; case "The RSI 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 RSI 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 RSI crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, 100 - dLevel }; break; case "The RSI crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, 100 - dLevel }; break; case "The RSI changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { 50 }; break; case "The RSI changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { 50 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adRSI, 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 MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index; BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index; int nSlow = (int)IndParam.NumParam[0].Value; int nFast = (int)IndParam.NumParam[1].Value; double dLevel = IndParam.NumParam[3].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int iFirstBar = nSlow + 2; double[] adMASlow = MovingAverage(nSlow, 0, maMethod, Price(basePrice)); double[] adMAFast = MovingAverage(nFast, 0, maMethod, Price(basePrice)); double[] adAO = new double[Bars]; for (int iBar = nSlow - 1; iBar < Bars; iBar++) { adAO[iBar] = adMAFast[iBar] - adMASlow[iBar]; } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "AO"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Histogram; Component[0].FirstBar = iFirstBar; Component[0].Value = adAO; 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 indicatorLogic = IndicatorLogic.It_does_not_act_as_a_filter; switch (IndParam.ListParam[0].Text) { case "The AO rises": indicatorLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { 0 }; break; case "The AO falls": indicatorLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { 0 }; break; case "The AO is higher than the Level line": indicatorLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The AO is lower than the Level line": indicatorLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The AO crosses the Level line upward": indicatorLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The AO crosses the Level line downward": indicatorLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The AO changes its direction upward": indicatorLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { 0 }; break; case "The AO changes its direction downward": indicatorLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { 0 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adAO, dLevel, -dLevel, ref Component[1], ref Component[2], indicatorLogic); 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; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int iFirstBar = iPeriod + 2; double[] adBOP = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { if (High[iBar] - Low[iBar] > Point) adBOP[iBar] = (Close[iBar] - Open[iBar]) / (High[iBar] - Low[iBar]); else adBOP[iBar] = 0; } adBOP = MovingAverage(iPeriod, 0, maMethod, adBOP); // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "Balance of Power"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Histogram; Component[0].FirstBar = iFirstBar; Component[0].Value = adBOP; 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 Balance of Power rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The Balance of Power falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The Balance of Power is higher than the zero line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; break; case "The Balance of Power is lower than the zero line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; break; case "The Balance of Power crosses the zero line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; break; case "The Balance of Power crosses the zero line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; break; case "The Balance of Power changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The Balance of Power changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adBOP, 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 BasePrice basePrice = (BasePrice)IndParam.ListParam[1].Index; MAMethod fastMAMethod = (MAMethod )IndParam.ListParam[3].Index; MAMethod slowMAMethod = (MAMethod )IndParam.ListParam[4].Index; int iNFastMA = (int)IndParam.NumParam[0].Value; int iNSlowMA = (int)IndParam.NumParam[1].Value; int iSFastMA = (int)IndParam.NumParam[2].Value; int iSSlowMA = (int)IndParam.NumParam[3].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; string[] saColors = new string[] { "Blue", "Black", "Red", "Green", "Yellow", "Orange" }; string sFastColor = saColors[(int)IndParam.NumParam[4].Value]; string sSlowColor = saColors[(int)IndParam.NumParam[5].Value]; // Convert to Higher Time Frame --------------------------------------------- DataPeriods htfPeriod = DataPeriods.week; double[] hfOpen = new double[Bars]; double[] hfClose = new double[Bars]; double[] hfHigh = new double[Bars]; double[] hfLow = new double[Bars]; double[] hfVolume = new double[Bars]; double[] hfPrice = new double[Bars]; int[] hIndex = new int[Bars]; int iFrame; int hBars; switch (IndParam.ListParam[2].Index) { case 1: htfPeriod = DataPeriods.min5; break; case 2: htfPeriod = DataPeriods.min15; break; case 3: htfPeriod = DataPeriods.min30; break; case 4: htfPeriod = DataPeriods.hour1; break; case 5: htfPeriod = DataPeriods.hour4; break; case 6: htfPeriod = DataPeriods.day; break; case 7: htfPeriod = DataPeriods.week; break; } int err1 = HigherTimeFrame(Period, htfPeriod, out hIndex, out hBars, out iFrame, out hfHigh, out hfLow, out hfOpen, out hfClose, out hfVolume); int err2 = HigherBasePrice(basePrice, hBars, hfHigh, hfLow, hfOpen, hfClose, out hfPrice); if (err1 == 1) { return; } //----------------------------------------------------------------------- // Calculation int iFirstBar = (int)Math.Max(iNFastMA + iSFastMA, iNSlowMA + iSSlowMA) + 2; double[] adMAFast = MovingAverage(iNFastMA, iSFastMA, fastMAMethod, hfPrice); double[] adMASlow = MovingAverage(iNSlowMA, iSSlowMA, slowMAMethod, hfPrice); double[] adMAOscillator = new double[Bars]; for (int iBar = iFirstBar; iBar < Bars; iBar++) { adMAOscillator[iBar] = adMAFast[iBar] - adMASlow[iBar]; } // Convert to Current Time Frame ---------------------------------------------- /// start WTF modfication 2 version 4 // do in 3 blocks for adMAFast, adMASlow, to draw on chart, and adMAOscillator for signals // copy of wider time frame array of values double[] hadMAFast = new double[Bars]; adMAFast.CopyTo(hadMAFast, 0); int err3 = CurrentTimeFrame(hIndex, hBars, ref adMAFast); // if any error, return out of calculation and indicator fails silently if (err3 == 1) { return; } // copy of wider time frame array of values double[] hadMASlow = new double[Bars]; adMASlow.CopyTo(hadMASlow, 0); err3 = CurrentTimeFrame(hIndex, hBars, ref adMASlow); // if any error, return out of calculation and indicator fails silently if (err3 == 1) { return; } // copy of wider time frame array of values double[] hadMAOscillator = new double[Bars]; adMAOscillator.CopyTo(hadMAOscillator, 0); err3 = CurrentTimeFrame(hIndex, hBars, ref adMAOscillator); // if any error, return out of calculation and indicator fails silently if (err3 == 1) { return; } /// end WTF modfication 2 version 4 //----------------------------------------------------------------------------- // Saving the components Component = new IndicatorComp[4]; Component[0] = new IndicatorComp(); Component[0].CompName = "Fast Moving Average"; Component[0].ChartColor = Color.FromName(sFastColor); Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].FirstBar = iFirstBar; Component[0].Value = adMAFast; Component[1] = new IndicatorComp(); Component[1].CompName = "Slow Moving Average"; Component[1].ChartColor = Color.FromName(sSlowColor); Component[1].DataType = IndComponentType.IndicatorValue; Component[1].ChartType = IndChartType.Line; Component[1].FirstBar = iFirstBar; Component[1].Value = adMASlow; 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.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"; } // Calculation of the logic IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter; switch (IndParam.ListParam[0].Text) { case "The Fast MA crosses the Slow MA upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; break; case "The Fast MA crosses the Slow MA downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; break; case "The Fast MA is higher than the Slow MA": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; break; case "The Fast MA is lower than the Slow MA": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; break; case "Draw only, no entry or exit signals": Component[2].CompName = "Visual Only"; Component[2].DataType = IndComponentType.NotDefined; Component[3].CompName = "Visual Only"; Component[3].DataType = IndComponentType.NotDefined; break; default: break; } /// start WTF modfication 3 version 4 // back up Bars value, reset to hBars, for performance improvement in indicator logic function int mtfBars = Data.Bars; Data.Bars = hBars; // replace very small values with 0 for performance improvement; don't know why but works for (int ctr = 0; ctr < hadMAOscillator.Length; ctr++) { hadMAOscillator[ctr] = (hadMAOscillator[ctr] < .000000001 && hadMAOscillator[ctr] > -.000000001) ? 0 : hadMAOscillator[ctr]; } OscillatorLogic(iFirstBar, iPrvs, hadMAOscillator, 0, 0, ref Component[2], ref Component[3], indLogic); // resest Bars to real value Data.Bars = mtfBars; // expand component array from wtf to current time frame double[] wtfCompValue = Component[2].Value; int err4 = CurrentTimeFrame(hIndex, hBars, ref wtfCompValue); if (err4 == 1) { return; } Component[2].Value = wtfCompValue; wtfCompValue = Component[3].Value; int err5 = CurrentTimeFrame(hIndex, hBars, ref wtfCompValue); if (err5 == 1) { return; } Component[3].Value = wtfCompValue; /// end WTF modfication 3 version 4 return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { double dAFMin = IndParam.NumParam[0].Value; double dAFInc = IndParam.NumParam[1].Value; double dAFMax = IndParam.NumParam[2].Value; // Reading the parameters int intDirNew; double dAF; double dPExtr; double dPSARNew = 0; int[] aiDir = new int[Bars]; double[] adPSAR = new double[Bars]; //---- Calculating the initial values adPSAR[0] = 0; dAF = dAFMin; intDirNew = 0; if (Close[1] > Open[0]) { aiDir[0] = 1; aiDir[1] = 1; dPExtr = Math.Max(High[0], High[1]); adPSAR[1] = Math.Min(Low[0], Low[1]); } else { aiDir[0] = -1; aiDir[1] = -1; dPExtr = Math.Min(Low[0], Low[1]); adPSAR[1] = Math.Max(High[0], High[1]); } for (int iBar = 2; iBar < Bars; iBar++) { //---- PSAR for the current period if (intDirNew != 0) { // The direction was changed during the last period aiDir[iBar] = intDirNew; intDirNew = 0; adPSAR[iBar] = dPSARNew + dAF * (dPExtr - dPSARNew); } else { aiDir[iBar] = aiDir[iBar - 1]; adPSAR[iBar] = adPSAR[iBar - 1] + dAF * (dPExtr - adPSAR[iBar - 1]); } // PSAR has to be out of the previous two bars limits if (aiDir[iBar] > 0 && adPSAR[iBar] > Math.Min(Low[iBar - 1], Low[iBar - 2])) adPSAR[iBar] = Math.Min(Low[iBar - 1], Low[iBar - 2]); else if (aiDir[iBar] < 0 && adPSAR[iBar] < Math.Max(High[iBar - 1], High[iBar - 2])) adPSAR[iBar] = Math.Max(High[iBar - 1], High[iBar - 2]); //---- PSAR for the next period // Calculation of the new values of flPExtr and flAF // if there is a new extreme price in the PSAR direction if (aiDir[iBar] > 0 && High[iBar] > dPExtr) { dPExtr = High[iBar]; dAF = Math.Min(dAF + dAFInc, dAFMax); } if (aiDir[iBar] < 0 && Low[iBar] < dPExtr) { dPExtr = Low[iBar]; dAF = Math.Min(dAF + dAFInc, dAFMax); } // Whether the price reaches PSAR if (Low[iBar] <= adPSAR[iBar] && adPSAR[iBar] <= High[iBar]) { intDirNew = -aiDir[iBar]; dPSARNew = dPExtr; dAF = dAFMin; if (intDirNew > 0) dPExtr = High[iBar]; else dPExtr = Low[iBar]; } } int iFirstBar = 8; // Saving the components Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "PSAR value"; if (slotType == SlotTypes.Close) Component[0].DataType = IndComponentType.ClosePrice; else Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Dot; Component[0].ChartColor = Color.Violet; Component[0].FirstBar = iFirstBar; Component[0].PosPriceDependence = PositionPriceDependence.BuyHigherSellLower; Component[0].Value = adPSAR; 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 iPeriod = (int)IndParam.NumParam[0].Value; int iShift = (int)IndParam.NumParam[1].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Convert to Higher Time Frame --------------------------------------------- DataPeriods htfPeriod = DataPeriods.week; double[] hfOpen = new double[Bars]; double[] hfClose = new double[Bars]; double[] hfHigh = new double[Bars]; double[] hfLow = new double[Bars]; double[] hfVolume = new double[Bars]; double[] hfPrice = new double[Bars]; int[] hIndex = new int[Bars]; int iFrame; int hBars; switch (IndParam.ListParam[4].Index) { case 0: htfPeriod = DataPeriods.hour1; break; case 1: htfPeriod = DataPeriods.min5; break; case 2: htfPeriod = DataPeriods.min15; break; case 3: htfPeriod = DataPeriods.min30; break; case 4: htfPeriod = DataPeriods.hour1; break; case 5: htfPeriod = DataPeriods.hour4; break; case 6: htfPeriod = DataPeriods.day; break; case 7: htfPeriod = DataPeriods.week; break; } int err1 = HigherTimeFrame(Period, htfPeriod, out hIndex, out hBars, out iFrame, out hfHigh, out hfLow, out hfOpen, out hfClose, out hfVolume); int err2 = HigherBasePrice(basePrice, hBars, hfHigh, hfLow, hfOpen, hfClose, out hfPrice); //------------------------------------------------------------------------ // TimeExecution if (basePrice == BasePrice.Open && iPeriod == 1 && iShift == 0) { IndParam.ExecutionTime = ExecutionTime.AtBarOpening; } // Calculation double[] adMA = MovingAverage(iPeriod, iShift, maMethod, hfPrice); // v3 -- manually shift so Position entry type logics use previous WTF value, fix bug of not using previous value if (IndParam.ListParam[0].Text == "The position opens above the Moving Average" || IndParam.ListParam[0].Text == "The position opens below the Moving Average") { adMA = MovingAverage(iPeriod, iShift + 1, maMethod, hfPrice); } else { adMA = MovingAverage(iPeriod, iShift, maMethod, hfPrice); } int iFirstBar = iPeriod + iShift + 1 + iPrvs; // Convert to Current Time Frame ---------------------------------------------- iPrvs = iPrvs * iFrame; iFirstBar = iFirstBar * iFrame; int err3 = (iFirstBar > 0.25 * Bars) ? 1 : 0; int err4 = CurrentTimeFrame(hIndex, hBars, ref adMA); // if any WTF conversion errors, return here to fail silently if (err1 == 1 || err2 == 1 || err3 == 1 || err4 == 1) { Component = new IndicatorComp[1]; Component[0] = new IndicatorComp(); Component[0].CompName = "MA Value"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].FirstBar = (int)Bars / 2; Component[0].UsePreviousBar = 0; Component[0].Value = new double[Bars]; return; } //----------------------------------------------------------------------------- // Saving the components if (slotType == SlotTypes.Open || slotType == SlotTypes.Close) { Component = new IndicatorComp[2]; Component[1] = new IndicatorComp(); Component[1].FirstBar = iFirstBar; Component[1].Value = new double[Bars]; int hBar = 0; for (int iBar = 3 * iFrame; iBar < Bars; iBar++) { // Covers the cases when the price can pass through the MA without a signal /// start WTF modfication 3 beta 1 while (hIndex[hBar] <= iBar && hBar < hBars) { hBar++; } double dValue = adMA[hIndex[hBar - 2]]; // MA value from previous HTF bar double dValue1 = adMA[hIndex[hBar - 3]]; // MA value from HTF 2 bars previous /// end WTF modfication 3 beta 1 double dTempVal = dValue; if ((dValue1 > High[iBar - 1] && dValue < Low[iBar]) || // It jumps below the current bar (dValue1 <Low[iBar - 1] && dValue> High[iBar]) || // It jumps above the current bar (Close[iBar - 1] < dValue && dValue < Open[iBar]) || // Positive gap (Close[iBar - 1] > dValue && dValue > Open[iBar])) // Negative gap { dTempVal = Open[iBar]; } Component[1].Value[iBar] = dTempVal; } } 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.FromName(IndParam.ListParam[3].ItemList[IndParam.ListParam[3].Index]); 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[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[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; case "Draw only, no entry or exit": Component[1].CompName = "Visual Only"; Component[1].DataType = IndComponentType.NotDefined; Component[2].CompName = "Visual Only"; Component[2].DataType = IndComponentType.NotDefined; 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[2].Index; int n = (int)IndParam.NumParam[0].Value; double dLevel = IndParam.NumParam[1].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Convert to Higher Time Frame --------------------------------------------- DataPeriods htfPeriod = DataPeriods.week; double[] hfOpen = new double[Bars]; double[] hfClose = new double[Bars]; double[] hfHigh = new double[Bars]; double[] hfLow = new double[Bars]; double[] hfVolume = new double[Bars]; double[] hfPrice = new double[Bars]; int[] hIndex = new int[Bars]; int iFrame; int hBars; switch (IndParam.ListParam[4].Index) { case 1: htfPeriod = DataPeriods.min5; break; case 2: htfPeriod = DataPeriods.min15; break; case 3: htfPeriod = DataPeriods.min30; break; case 4: htfPeriod = DataPeriods.hour1; break; case 5: htfPeriod = DataPeriods.hour4; break; case 6: htfPeriod = DataPeriods.day; break; case 7: htfPeriod = DataPeriods.week; break; } int err1 = HigherTimeFrame(Period, htfPeriod, out hIndex, out hBars, out iFrame, out hfHigh, out hfLow, out hfOpen, out hfClose, out hfVolume); int err2 = HigherBasePrice(basePrice, hBars, hfHigh, hfLow, hfOpen, hfClose, out hfPrice); if (err1 == 1) { return; } // Calculation int iFirstBar = n + 1; double[] adRegr = new double[Bars]; double[] adRSquared = new double[Bars]; double rsquared; for (int period = iFirstBar; period < Bars; period++) { double x = 0; double xx = 0; double xy = 0; double y = 0; double b = 0; double a = 0; double sumY2 = 0; for (int i = 0; i < n; i++) { int ii = i + 1; double source = hfPrice[period - (n - i)]; // source = xVal x = x + ii; // x = xSum xx = xx + (ii * ii); // xx = sumX2 xy = xy + (ii * source); // xy = sumXY y = y + source; // y = ySum sumY2 += (source * source); } // adapting eSignal code from Tech S&C article Dec 2007 p. 74 // article gets r-squared, matching lines from FXCM code to article's code // see Regression .lua or .cs for orignal regression code // (nLRlen * sumXY) - (xSum * ySum) b = (n * xy) - (x * y); double line1 = b; // (nLRlen * sumX2 - (xSum*xSum)) double line2 = n * xx - (x * x); if (Math.Abs(line2) < 1e-10) { b = 0; } else { b = b / (line2); a = y - (b * x); a = a / n; } // nLRlen * sumY2 - (ySum * ySum) double line3 = n * sumY2 - (y * y); rsquared = Math.Pow(line1 / Math.Sqrt(line2 * line3), 2); adRSquared[period] = rsquared; } // Convert to Current Time Frame ---------------------------------------------- /// start WTF modfication 2 version 4 // copy of wider time frame array of values double[] hadRSquared = new double[Bars]; adRSquared.CopyTo(hadRSquared, 0); int err3 = CurrentTimeFrame(hIndex, hBars, ref adRSquared); // if any error, return out of calculation and indicator fails silently if (err3 == 1) { return; } /// end WTF modfication 2 version 4 //----------------------------------------------------------------------------- // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "R Squared"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Histogram; Component[0].FirstBar = iFirstBar; Component[0].Value = adRSquared; 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 R Squared Line rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The R Squared Line falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The R Squared Line is higher than the Level line": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; SpecialValues = new double[1] { dLevel }; break; case "The R Squared Line is lower than the Level line": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; SpecialValues = new double[1] { dLevel }; break; case "The R Squared Line crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[1] { dLevel }; break; case "The R Squared Line crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[1] { dLevel }; break; case "The R Squared Line changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The R Squared Line changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } /// start WTF modfication 3 version 4 // back up Bars value, reset to hBars, for performance improvement in indicator logic function int mtfBars = Data.Bars; Data.Bars = hBars; // replace very small values with 0 for performance improvement; don't know why but works for (int ctr = 0; ctr < hadRSquared.Length; ctr++) { hadRSquared[ctr] = (hadRSquared[ctr] < .000000001 && hadRSquared[ctr] > -.000000001) ? 0 : hadRSquared[ctr]; } NoDirectionOscillatorLogic(iFirstBar, iPrvs, hadRSquared, dLevel, ref Component[1], indLogic); // resest Bars to real value Data.Bars = mtfBars; // expand component array from wtf to current time frame double[] wtfCompValue = Component[1].Value; int err4 = CurrentTimeFrame(hIndex, hBars, ref wtfCompValue); if (err4 == 1) { return; } Component[1].Value = Component[2].Value = wtfCompValue; /// end WTF modfication 3 version 4 return; }
/// <summary> /// Calculates the indicator's components /// </summary> public override void Calculate(SlotTypes slotType) { // Reading the parameters BasePrice basePrice = (BasePrice)IndParam.ListParam[1].Index; MAMethod fastMAMethod = (MAMethod )IndParam.ListParam[3].Index; MAMethod slowMAMethod = (MAMethod )IndParam.ListParam[4].Index; int iNFastMA = (int)IndParam.NumParam[0].Value; int iNSlowMA = (int)IndParam.NumParam[1].Value; int iSFastMA = (int)IndParam.NumParam[2].Value; int iSSlowMA = (int)IndParam.NumParam[3].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; int iFirstBar = (int)Math.Max(iNFastMA + iSFastMA, iNSlowMA + iSSlowMA) + 2; double[] adMAFast = MovingAverage(iNFastMA, iSFastMA, fastMAMethod, Price(basePrice)); double[] adMASlow = MovingAverage(iNSlowMA, iSSlowMA, slowMAMethod, Price(basePrice)); double[] adMAOscillator = new double[Bars]; for (int iBar = iFirstBar; iBar < Bars; iBar++) { adMAOscillator[iBar] = adMAFast[iBar] - adMASlow[iBar]; } // Saving the components Component = new IndicatorComp[4]; Component[0] = new IndicatorComp(); Component[0].CompName = "Fast Moving Average"; Component[0].ChartColor = Color.Goldenrod; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].FirstBar = iFirstBar; Component[0].Value = adMAFast; Component[1] = new IndicatorComp(); Component[1].CompName = "Slow Moving Average"; Component[1].ChartColor = Color.IndianRed; Component[1].DataType = IndComponentType.IndicatorValue; Component[1].ChartType = IndChartType.Line; Component[1].FirstBar = iFirstBar; Component[1].Value = adMASlow; 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.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"; } // Calculation of the logic IndicatorLogic indLogic = IndicatorLogic.It_does_not_act_as_a_filter; switch (IndParam.ListParam[0].Text) { case "The Fast MA crosses the Slow MA upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; break; case "The Fast MA crosses the Slow MA downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; break; case "The Fast MA is higher than the Slow MA": indLogic = IndicatorLogic.The_indicator_is_higher_than_the_level_line; break; case "The Fast MA is lower than the Slow MA": indLogic = IndicatorLogic.The_indicator_is_lower_than_the_level_line; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adMAOscillator, 0, 0, ref Component[2], ref Component[3], 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[] 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 MAMethod maMethod = (MAMethod )IndParam.ListParam[1].Index; BasePrice basePrice = (BasePrice)IndParam.ListParam[2].Index; int iMAPeriod = (int)IndParam.NumParam[0].Value; int iLRLength = (int)IndParam.NumParam[1].Value; double dLevel = IndParam.NumParam[2].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; double[] dX = new double[Bars]; double[] dY = new double[Bars]; double dSigX; double dSigY; double dSigXY; double dSigXX; double[] adLRSlope = new double[Bars]; int iFirstBar = iMAPeriod + iLRLength + 2; double[] adMAPrice = MovingAverage(iMAPeriod, 0, maMethod, Price(basePrice)); for (int iBar = iFirstBar; iBar < Bars; iBar++) { dSigX = 0; dSigY = 0; dSigXX = 0; dSigXY = 0; for (int index = 0; index < iLRLength; index++) { dSigX = dSigX + index; dSigY = dSigY + adMAPrice[iBar - index]; dSigXY = dSigXY + index * adMAPrice[iBar - index]; dSigXX = dSigXX + index * index; } adLRSlope[iBar] = -(iLRLength * dSigXY - dSigX * dSigY) / (iLRLength * dSigXX - dSigX * dSigX); } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "LR Slope"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Histogram; Component[0].FirstBar = iFirstBar; Component[0].Value = adLRSlope; 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 LR Slope rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { 0 }; break; case "The LR Slope falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { 0 }; break; case "The LR Slope 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 LR Slope 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 LR Slope crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The LR Slope crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The LR Slope changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { 0 }; break; case "The LR Slope changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { 0 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adLRSlope, 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 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 BasePrice basePrice = (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 int iFirstBar = iPeriod + 2; double[] adBasePrice = Price(basePrice); double[] adCMO1 = new double[Bars]; double[] adCMO2 = new double[Bars]; double[] adCMO1Sum = new double[Bars]; double[] adCMO2Sum = new double[Bars]; double[] adCMO = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { adCMO1[iBar] = 0; adCMO2[iBar] = 0; if (adBasePrice[iBar] > adBasePrice[iBar - 1]) adCMO1[iBar] = adBasePrice[iBar] - adBasePrice[iBar - 1]; if (adBasePrice[iBar] < adBasePrice[iBar - 1]) adCMO2[iBar] = adBasePrice[iBar - 1] - adBasePrice[iBar]; } for (int iBar = 0; iBar < iPeriod; iBar++) { adCMO1Sum[iPeriod - 1] += adCMO1[iBar]; adCMO2Sum[iPeriod - 1] += adCMO2[iBar]; } for (int iBar = iPeriod; iBar < Bars; iBar++) { adCMO1Sum[iBar] = adCMO1Sum[iBar - 1] + adCMO1[iBar] - adCMO1[iBar - iPeriod]; adCMO2Sum[iBar] = adCMO2Sum[iBar - 1] + adCMO2[iBar] - adCMO2[iBar - iPeriod]; if (adCMO1Sum[iBar] + adCMO2Sum[iBar] == 0) adCMO[iBar] = 100; else adCMO[iBar] = 100 * (adCMO1Sum[iBar] - adCMO2Sum[iBar]) / (adCMO1Sum[iBar] + adCMO2Sum[iBar]); } // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "CMO"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.RoyalBlue; Component[0].FirstBar = iFirstBar; Component[0].Value = adCMO; 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 CMO rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { 0 }; break; case "The CMO falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { 0 }; break; case "The CMO 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 CMO 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 CMO crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The CMO crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, -dLevel }; break; case "The CMO changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { 0 }; break; case "The CMO changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { 0 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adCMO, 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; int iPeriod = (int)IndParam.NumParam[0].Value; int iDivisor = (int)IndParam.NumParam[1].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int iFirstBar = iPeriod + 2; double[] adAEOM = new double[Bars]; for (int iBar = 1; iBar < Bars; iBar++) { adAEOM[iBar] = iDivisor * (High[iBar] - Low[iBar]) * ((High[iBar] + Low[iBar]) / 2 - (High[iBar - 1] - Low[iBar - 1]) / 2) / Math.Max(Volume[iBar], 1); } adAEOM = MovingAverage(iPeriod, 0, maMethod, adAEOM); // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "Ease of Movement"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.LightSeaGreen; Component[0].FirstBar = iFirstBar; Component[0].Value = adAEOM; 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 Ease of Movement rises": indLogic = IndicatorLogic.The_indicator_rises; break; case "The Ease of Movement falls": indLogic = IndicatorLogic.The_indicator_falls; break; case "The Ease of Movement changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; break; case "The Ease of Movement changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adAEOM, 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 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) { // 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 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 MAMethod maMethod = (MAMethod)IndParam.ListParam[1].Index; int iPeriod = (int)IndParam.NumParam[0].Value; int iSmoothing = (int)IndParam.NumParam[1].Value; int dLevel = (int)IndParam.NumParam[2].Value; int iPrvs = IndParam.CheckParam[0].Checked ? 1 : 0; // Calculation int iFirstBar = iPeriod + iSmoothing + iPrvs + 2; double[] adR = 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]; } } adR[iBar] = -100 * (dMax - Close[iBar]) / (dMax - dMin); } double[] adRSmoothed = MovingAverage(iSmoothing, 0, maMethod, adR); // Saving the components Component = new IndicatorComp[3]; Component[0] = new IndicatorComp(); Component[0].CompName = "%R"; Component[0].DataType = IndComponentType.IndicatorValue; Component[0].ChartType = IndChartType.Line; Component[0].ChartColor = Color.Teal; Component[0].FirstBar = iFirstBar; Component[0].Value = adRSmoothed; 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 %R rises": indLogic = IndicatorLogic.The_indicator_rises; SpecialValues = new double[1] { -50 }; break; case "The %R falls": indLogic = IndicatorLogic.The_indicator_falls; SpecialValues = new double[1] { -50 }; break; case "The %R 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 %R 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 %R crosses the Level line upward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_upward; SpecialValues = new double[2] { dLevel, -100 - dLevel }; break; case "The %R crosses the Level line downward": indLogic = IndicatorLogic.The_indicator_crosses_the_level_line_downward; SpecialValues = new double[2] { dLevel, -100 - dLevel }; break; case "The %R changes its direction upward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_upward; SpecialValues = new double[1] { -50 }; break; case "The %R changes its direction downward": indLogic = IndicatorLogic.The_indicator_changes_its_direction_downward; SpecialValues = new double[1] { -50 }; break; default: break; } OscillatorLogic(iFirstBar, iPrvs, adRSmoothed, dLevel, -100 - dLevel, ref Component[1], ref Component[2], indLogic); return; }