protected Indicator()
{
indicatorName = string.Empty;
PossibleSlots = SlotTypes.NotDefined;
SeparatedChart = false;
SeparatedChartMinValue = double.MaxValue;
SeparatedChartMaxValue = double.MinValue;
IsDiscreteValues = false;
CustomIndicator = false;
LoaddedFromDll = false;
WarningMessage = string.Empty;
AllowClosingFilters = false;
SpecialValues = new double[] {};
IndParam = new IndicatorParam();
Component = new IndicatorComp[] {};
IsBacktester = true;
IsGeneratable = true;
ExitFilterShortDescription = "Not defined";
EntryFilterShortDescription = "Not defined";
ExitFilterLongDescription = "Not defined";
EntryFilterLongDescription = "Not defined";
ExitPointShortDescription = "Not defined";
ExitPointLongDescription = "Not defined";
EntryPointShortDescription = "Not defined";
EntryPointLongDescription = "Not defined";
}
/// <summary>
/// Returns signals for the logic rule "The Indicator crosses AnotherIndicator upward"
/// </summary>
protected void IndicatorCrossesAnotherIndicatorUpwardLogic(int firstBar, int prvs, double[] adIndValue,
double[] adAnotherIndValue,
ref IndicatorComp indCompLong,
ref IndicatorComp indCompShort)
{
double sigma = Sigma();
firstBar = Math.Max(firstBar, 2);
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - prvs;
int baseBar = currentBar - 1;
while (Math.Abs(adIndValue[baseBar] - adAnotherIndValue[baseBar]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma &&
adIndValue[baseBar] < adAnotherIndValue[baseBar] - sigma
? 1
: 0;
indCompShort.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma &&
adIndValue[baseBar] > adAnotherIndValue[baseBar] + sigma
? 1
: 0;
}
}
/// <summary>
/// The default constructor
/// </summary>
public Indicator()
{
indicatorName = string.Empty;
PossibleSlots = SlotTypes.NotDefined;
SeparatedChart = false;
SeparatedChartMinValue = double.MaxValue;
SeparatedChartMaxValue = double.MinValue;
IsDiscreteValues = false;
CustomIndicator = false;
LoaddedFromDll = false;
WarningMessage = string.Empty;
AllowClosingFilters = false;
SpecialValues = new double[] { };
IndParam = new IndicatorParam();
Component = new IndicatorComp[] { };
IsBacktester = false;
IsGeneratable = true;
ExitFilterShortDescription = "Not defined";
EntryFilterShortDescription = "Not defined";
ExitFilterLongDescription = "Not defined";
EntryFilterLongDescription = "Not defined";
ExitPointShortDescription = "Not defined";
ExitPointLongDescription = "Not defined";
EntryPointShortDescription = "Not defined";
EntryPointLongDescription = "Not defined";
}
/// <summary>
/// Returns signals for the logic rule "Indicator falls"
/// </summary>
protected void IndicatorFallsLogic(int firstBar, int prvs, double[] adIndValue, ref IndicatorComp indCompLong,
ref IndicatorComp indCompShort)
{
double sigma = Sigma();
firstBar = Math.Max(firstBar, 2);
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - prvs;
int baseBar = currentBar - 1;
bool isNoChange = true;
bool isLower = adIndValue[currentBar] < adIndValue[baseBar];
while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange &&
baseBar > firstBar)
{
isNoChange = (isLower == (adIndValue[baseBar + 1] < adIndValue[baseBar]));
baseBar--;
}
indCompLong.Value[bar] = adIndValue[currentBar] < adIndValue[baseBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] > adIndValue[baseBar] + sigma ? 1 : 0;
}
}
/// <summary>
/// Returns signals for the logic rule "The bar opens below the Indicator after opening above it"
/// </summary>
protected void BarOpensBelowIndicatorAfterOpeningAboveLogic(int firstBar, int prvs, double[] adIndValue,
ref IndicatorComp indCompLong,
ref IndicatorComp indCompShort)
{
double sigma = Sigma();
firstBar = Math.Max(firstBar, 2);
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adIndValue[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = Open[bar] < adIndValue[bar - prvs] - sigma &&
Open[baseBar] > adIndValue[baseBar - prvs] + sigma
? 1
: 0;
indCompShort.Value[bar] = Open[bar] > adIndValue[bar - prvs] + sigma &&
Open[baseBar] < adIndValue[baseBar - prvs] - sigma
? 1
: 0;
}
}
public Indicator()
{
IndParam = new IndicatorParam();
IndicatorName = string.Empty;
PossibleSlots = SlotTypes.NotDefined;
SlotType = SlotTypes.NotDefined;
SeparatedChart = false;
SeparatedChartMinValue = double.MaxValue;
SeparatedChartMaxValue = double.MinValue;
SpecialValues = new double[0];
IsDiscreteValues = false;
CustomIndicator = false;
IsBacktester = true;
IsGeneratable = true;
WarningMessage = string.Empty;
AllowClosingFilters = false;
IndicatorAuthor = "Forex Software Ltd";
IndicatorVersion = "1.0";
IndicatorDescription = "Bundled in FSB distribution.";
ExitFilterShortDescription = "Not defined";
EntryFilterShortDescription = "Not defined";
ExitFilterLongDescription = "Not defined";
EntryFilterLongDescription = "Not defined";
ExitPointShortDescription = "Not defined";
ExitPointLongDescription = "Not defined";
EntryPointShortDescription = "Not defined";
EntryPointLongDescription = "Not defined";
Component = new IndicatorComp[] {};
}
/// <summary>
/// Returns signals for the logic rule "The bar opens above the Indicator"
/// </summary>
protected void BarOpensAboveIndicatorLogic(int firstBar, int previous, double[] adIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] > adIndValue[bar - previous] + sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] < adIndValue[bar - previous] - sigma ? 1 : 0;
}
}
/// <summary>
/// Returns signals for the logic rule "The bar closes below the Indicator"
/// </summary>
protected void BarClosesBelowIndicatorLogic(int firstBar, int prvs, double[] adIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] < adIndValue[bar - prvs] - sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] > adIndValue[bar - prvs] + sigma ? 1 : 0;
}
}
/// <summary>
/// Returns signals for the logic rule "The Indicator is lower than the AnotherIndicator"
/// </summary>
protected void IndicatorIsLowerThanAnotherIndicatorLogic(int firstBar, int previous, double[] adIndValue,
double[] adAnotherIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
indCompLong.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma ? 1 : 0;
}
}
/// <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 logic of a band indicator.
/// </summary>
/// <param name="firstBar">The first bar number.</param>
/// <param name="prvs">To use the previous bar or not.</param>
/// <param name="adUpperBand">The Upper band values.</param>
/// <param name="adLowerBand">The Lower band values.</param>
/// <param name="indCompLong">Indicator component for Long position.</param>
/// <param name="indCompShort">Indicator component for Short position.</param>
/// <param name="indLogic">The chosen logic.</param>
protected void BandIndicatorLogic(int firstBar, int prvs, double[] adUpperBand, double[] adLowerBand,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort,
BandIndLogic indLogic)
{
double sigma = Sigma();
switch (indLogic)
{
case BandIndLogic.The_bar_opens_below_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_below_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_below_the_Upper_Band_after_opening_above_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma &&
Open[baseBar] > adUpperBand[baseBar - prvs] + sigma
? 1
: 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompShort.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma &&
Open[baseBar] < adLowerBand[baseBar - prvs] - sigma
? 1
: 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Upper_Band_after_opening_below_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma &&
Open[baseBar] < adUpperBand[baseBar - prvs] - sigma
? 1
: 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompShort.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma &&
Open[baseBar] > adLowerBand[baseBar - prvs] + sigma
? 1
: 0;
}
break;
case BandIndLogic.The_bar_opens_below_the_Lower_Band_after_opening_above_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = Open[bar] < adLowerBand[bar - prvs] - sigma &&
Open[baseBar] > adLowerBand[baseBar - prvs] + sigma
? 1
: 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompShort.Value[bar] = Open[bar] > adUpperBand[bar - prvs] + sigma &&
Open[baseBar] < adUpperBand[baseBar - prvs] - sigma
? 1
: 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Lower_Band_after_opening_below_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = Open[bar] > adLowerBand[bar - prvs] + sigma &&
Open[baseBar] < adLowerBand[baseBar - prvs] - sigma
? 1
: 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - prvs]) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompShort.Value[bar] = Open[bar] < adUpperBand[bar - prvs] - sigma &&
Open[baseBar] > adUpperBand[baseBar - prvs] + sigma
? 1
: 0;
}
break;
case BandIndLogic.The_bar_closes_below_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_above_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_below_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] < adLowerBand[bar - prvs] - sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] > adUpperBand[bar - prvs] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_above_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] > adLowerBand[bar - prvs] + sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] < adUpperBand[bar - prvs] - sigma ? 1 : 0;
}
break;
default:
return;
}
}
/// <summary>
/// Calculates the logic of a band indicator.
/// </summary>
/// <param name="firstBar">The first bar number.</param>
/// <param name="previous">To use the previous bar or not.</param>
/// <param name="adUpperBand">The Upper band values.</param>
/// <param name="adLowerBand">The Lower band values.</param>
/// <param name="indCompLong">Indicator component for Long position.</param>
/// <param name="indCompShort">Indicator component for Short position.</param>
/// <param name="indLogic">The chosen logic.</param>
/// <returns>True if everyting is ok.</returns>
protected bool BandIndicatorLogic(int firstBar, int previous, double[] adUpperBand, double[] adLowerBand,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort, BandIndLogic indLogic)
{
double sigma = Sigma();
switch (indLogic)
{
case BandIndLogic.The_bar_opens_below_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] < adUpperBand[bar - previous] - sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] > adLowerBand[bar - previous] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] > adUpperBand[bar - previous] + sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] < adLowerBand[bar - previous] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_below_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] < adLowerBand[bar - previous] - sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] > adUpperBand[bar - previous] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] > adLowerBand[bar - previous] + sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] < adUpperBand[bar - previous] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_below_the_Upper_Band_after_opening_above_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = Open[bar] < adUpperBand[bar - previous] - sigma && Open[baseBar] > adUpperBand[baseBar - previous] + sigma ? 1 : 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompShort.Value[bar] = Open[bar] > adLowerBand[bar - previous] + sigma && Open[baseBar] < adLowerBand[baseBar - previous] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Upper_Band_after_opening_below_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = Open[bar] > adUpperBand[bar - previous] + sigma && Open[baseBar] < adUpperBand[baseBar - previous] - sigma ? 1 : 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompShort.Value[bar] = Open[bar] < adLowerBand[bar - previous] - sigma && Open[baseBar] > adLowerBand[baseBar - previous] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_below_the_Lower_Band_after_opening_above_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = Open[bar] < adLowerBand[bar - previous] - sigma && Open[baseBar] > adLowerBand[baseBar - previous] + sigma ? 1 : 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompShort.Value[bar] = Open[bar] > adUpperBand[bar - previous] + sigma && Open[baseBar] < adUpperBand[baseBar - previous] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_opens_above_the_Lower_Band_after_opening_below_it:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adLowerBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = Open[bar] > adLowerBand[bar - previous] + sigma && Open[baseBar] < adLowerBand[baseBar - previous] - sigma ? 1 : 0;
baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adUpperBand[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompShort.Value[bar] = Open[bar] < adUpperBand[bar - previous] - sigma && Open[baseBar] > adUpperBand[baseBar - previous] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_below_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] < adUpperBand[bar - previous] - sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] > adLowerBand[bar - previous] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_above_the_Upper_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] > adUpperBand[bar - previous] + sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] < adLowerBand[bar - previous] - sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_below_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] < adLowerBand[bar - previous] - sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] > adUpperBand[bar - previous] + sigma ? 1 : 0;
}
break;
case BandIndLogic.The_bar_closes_above_the_Lower_Band:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] > adLowerBand[bar - previous] + sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] < adUpperBand[bar - previous] - sigma ? 1 : 0;
}
break;
default:
return false;
}
return true;
}
/// <summary>
/// Calculates the logic of an Oscillator.
/// </summary>
/// <param name="firstBar">The first bar number.</param>
/// <param name="prvs">To use the previous bar or not.</param>
/// <param name="adIndValue">The indicator values.</param>
/// <param name="levelLong">The Level value for a Long position.</param>
/// <param name="levelShort">The Level value for a Short position.</param>
/// <param name="indCompLong">Indicator component for Long position.</param>
/// <param name="indCompShort">Indicator component for Short position.</param>
/// <param name="indLogic">The chosen logic.</param>
/// <returns>True if everything is ok.</returns>
protected void OscillatorLogic(int firstBar, int prvs, double[] adIndValue, double levelLong, double levelShort,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort,
IndicatorLogic indLogic)
{
double sigma = Sigma();
switch (indLogic)
{
case IndicatorLogic.The_indicator_rises:
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - prvs;
int baseBar = currBar - 1;
bool isHigher = adIndValue[currBar] > adIndValue[baseBar];
if (!IsDiscreteValues) // Aroon oscillator uses IsDiscreteValues = true
{
bool isNoChange = true;
while (Math.Abs(adIndValue[currBar] - adIndValue[baseBar]) < sigma && isNoChange &&
baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
}
indCompLong.Value[bar] = adIndValue[baseBar] < adIndValue[currBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[baseBar] > adIndValue[currBar] + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_falls:
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - prvs;
int baseBar = currBar - 1;
bool isHigher = adIndValue[currBar] > adIndValue[baseBar];
if (!IsDiscreteValues) // Aroon oscillator uses IsDiscreteValues = true
{
bool isNoChange = true;
while (Math.Abs(adIndValue[currBar] - adIndValue[baseBar]) < sigma && isNoChange &&
baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
}
indCompLong.Value[bar] = adIndValue[baseBar] > adIndValue[currBar] + sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[baseBar] < adIndValue[currBar] - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_higher_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = adIndValue[bar - prvs] > levelLong + sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[bar - prvs] < levelShort - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_lower_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = adIndValue[bar - prvs] < levelLong - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[bar - prvs] > levelShort + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - prvs - 1;
while (Math.Abs(adIndValue[baseBar] - levelLong) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = (adIndValue[baseBar] < levelLong - sigma &&
adIndValue[bar - prvs] > levelLong + sigma)
? 1
: 0;
indCompShort.Value[bar] = (adIndValue[baseBar] > levelShort + sigma &&
adIndValue[bar - prvs] < levelShort - sigma)
? 1
: 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - prvs - 1;
while (Math.Abs(adIndValue[baseBar] - levelLong) < sigma && baseBar > firstBar)
{
baseBar--;
}
indCompLong.Value[bar] = (adIndValue[baseBar] > levelLong + sigma &&
adIndValue[bar - prvs] < levelLong - sigma)
? 1
: 0;
indCompShort.Value[bar] = (adIndValue[baseBar] < levelShort - sigma &&
adIndValue[bar - prvs] > levelShort + sigma)
? 1
: 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - prvs;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{
bar1--;
}
int iBar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[iBar2]) < sigma && iBar2 > firstBar)
{
iBar2--;
}
indCompLong.Value[bar] = (adIndValue[iBar2] > adIndValue[bar1] &&
adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1)
? 1
: 0;
indCompShort.Value[bar] = (adIndValue[iBar2] < adIndValue[bar1] &&
adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1)
? 1
: 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - prvs;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{
bar1--;
}
int iBar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[iBar2]) < sigma && iBar2 > firstBar)
{
iBar2--;
}
indCompLong.Value[bar] = (adIndValue[iBar2] < adIndValue[bar1] &&
adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1)
? 1
: 0;
indCompShort.Value[bar] = (adIndValue[iBar2] > adIndValue[bar1] &&
adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1)
? 1
: 0;
}
break;
default:
return;
}
}
/// <summary>
/// Calculates the logic of a No Direction Oscillator.
/// </summary>
/// <param name="firstBar">The first bar number.</param>
/// <param name="prvs">To use the previous bar or not.</param>
/// <param name="adIndValue">The indicator values.</param>
/// <param name="dLevel">The Level value.</param>
/// <param name="indComp">Indicator component where to save the results.</param>
/// <param name="indLogic">The chosen logic.</param>
/// <returns>True if everything is ok.</returns>
protected void NoDirectionOscillatorLogic(int firstBar, int prvs, double[] adIndValue, double dLevel,
ref IndicatorComp indComp, IndicatorLogic indLogic)
{
double sigma = Sigma();
switch (indLogic)
{
case IndicatorLogic.The_indicator_rises:
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - prvs;
int baseBar = currBar - 1;
bool isHigher = adIndValue[currBar] > adIndValue[baseBar];
bool isNoChange = true;
while (Math.Abs(adIndValue[currBar] - adIndValue[baseBar]) < sigma && isNoChange &&
baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
indComp.Value[bar] = adIndValue[baseBar] < adIndValue[currBar] - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_falls:
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - prvs;
int baseBar = currBar - 1;
bool isHigher = adIndValue[currBar] > adIndValue[baseBar];
bool isNoChange = true;
while (Math.Abs(adIndValue[currBar] - adIndValue[baseBar]) < sigma && isNoChange &&
baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
indComp.Value[bar] = adIndValue[baseBar] > adIndValue[currBar] + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_higher_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indComp.Value[bar] = adIndValue[bar - prvs] > dLevel + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_lower_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indComp.Value[bar] = adIndValue[bar - prvs] < dLevel - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - prvs - 1;
while (Math.Abs(adIndValue[baseBar] - dLevel) < sigma && baseBar > firstBar)
{
baseBar--;
}
indComp.Value[bar] = (adIndValue[baseBar] < dLevel - sigma &&
adIndValue[bar - prvs] > dLevel + sigma)
? 1
: 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - prvs - 1;
while (Math.Abs(adIndValue[baseBar] - dLevel) < sigma && baseBar > firstBar)
{
baseBar--;
}
indComp.Value[bar] = (adIndValue[baseBar] > dLevel + sigma &&
adIndValue[bar - prvs] < dLevel - sigma)
? 1
: 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - prvs;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{
bar1--;
}
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar)
{
bar2--;
}
indComp.Value[bar] = (adIndValue[bar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] &&
bar1 == bar0 - 1)
? 1
: 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - prvs;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{
bar1--;
}
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar)
{
bar2--;
}
indComp.Value[bar] = (adIndValue[bar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] &&
bar1 == bar0 - 1)
? 1
: 0;
}
break;
default:
return;
}
}
/// <summary>
/// Calculates the logic of an Oscillator.
/// </summary>
/// <param name="firstBar">The first bar number.</param>
/// <param name="previous">To use the previous bar or not.</param>
/// <param name="adIndValue">The indicator values.</param>
/// <param name="levelLong">The Level value for a Long position.</param>
/// <param name="levelShort">The Level value for a Short position.</param>
/// <param name="indCompLong">Indicator component for Long position.</param>
/// <param name="indCompShort">Indicator component for Short position.</param>
/// <param name="indLogic">The chosen logic.</param>
/// <returns>True if everything is ok.</returns>
protected bool OscillatorLogic(int firstBar, int previous, double[] indValue, double levelLong,
double levelShort, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort, IndicatorLogic indLogic)
{
double sigma = Sigma();
switch (indLogic)
{
case IndicatorLogic.The_indicator_rises:
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - previous;
int baseBar = currBar - 1;
bool isHigher = indValue[currBar] > indValue[baseBar];
if (!IsDiscreteValues) // Aroon oscillator uses isDescreteValues = true
{
bool isNoChange = true;
while (Math.Abs(indValue[currBar] - indValue[baseBar]) < sigma && isNoChange && baseBar > firstBar)
{
isNoChange = (isHigher == (indValue[baseBar + 1] > indValue[baseBar]));
baseBar--;
}
}
indCompLong.Value[bar] = indValue[baseBar] < indValue[currBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = indValue[baseBar] > indValue[currBar] + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_falls:
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - previous;
int baseBar = currBar - 1;
bool isHigher = indValue[currBar] > indValue[baseBar];
if (!IsDiscreteValues)
{
bool isNoChange = true;
while (Math.Abs(indValue[currBar] - indValue[baseBar]) < sigma && isNoChange && baseBar > firstBar)
{
isNoChange = (isHigher == (indValue[baseBar + 1] > indValue[baseBar]));
baseBar--;
}
}
indCompLong.Value[bar] = indValue[baseBar] > indValue[currBar] + sigma ? 1 : 0;
indCompShort.Value[bar] = indValue[baseBar] < indValue[currBar] - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_higher_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = indValue[bar - previous] > levelLong + sigma ? 1 : 0;
indCompShort.Value[bar] = indValue[bar - previous] < levelShort - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_lower_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = indValue[bar - previous] < levelLong - sigma ? 1 : 0;
indCompShort.Value[bar] = indValue[bar - previous] > levelShort + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - previous - 1;
while (Math.Abs(indValue[baseBar] - levelLong) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = (indValue[baseBar] < levelLong - sigma && indValue[bar - previous] > levelLong + sigma) ? 1 : 0;
indCompShort.Value[bar] = (indValue[baseBar] > levelShort + sigma && indValue[bar - previous] < levelShort - sigma) ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - previous - 1;
while (Math.Abs(indValue[baseBar] - levelLong) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = (indValue[baseBar] > levelLong + sigma && indValue[bar - previous] < levelLong - sigma) ? 1 : 0;
indCompShort.Value[bar] = (indValue[baseBar] < levelShort - sigma && indValue[bar - previous] > levelShort + sigma) ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - previous;
int bar1 = bar0 - 1;
while (Math.Abs(indValue[bar0] - indValue[bar1]) < sigma && bar1 > firstBar)
{ bar1--; }
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(indValue[bar1] - indValue[bar2]) < sigma && bar2 > firstBar)
{ bar2--; }
indCompLong.Value[bar] = (indValue[bar2] > indValue[bar1] && indValue[bar1] < indValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
indCompShort.Value[bar] = (indValue[bar2] < indValue[bar1] && indValue[bar1] > indValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - previous;
int bar1 = bar0 - 1;
while (Math.Abs(indValue[bar0] - indValue[bar1]) < sigma && bar1 > firstBar)
{ bar1--; }
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(indValue[bar1] - indValue[bar2]) < sigma && bar2 > firstBar)
{ bar2--; }
indCompLong.Value[bar] = (indValue[bar2] < indValue[bar1] && indValue[bar1] > indValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
indCompShort.Value[bar] = (indValue[bar2] > indValue[bar1] && indValue[bar1] < indValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
}
break;
default:
return false;
}
return true;
}
protected void IndicatorChangesItsDirectionDownward(int firstBar, int prvs, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - prvs;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{
bar1--;
}
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar)
{
bar2--;
}
indCompLong.Value[bar] = (adIndValue[bar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
indCompShort.Value[bar] = (adIndValue[bar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
}
}
/// <summary>
/// Returns signals for the logic rule "Indicator rises".
/// </summary>
protected void IndicatorRisesLogic(int firstBar, int previous, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
int baseBar = currentBar - 1;
bool isNoChange = true;
bool isHigher = adIndValue[currentBar] > adIndValue[baseBar];
while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
indCompLong.Value[bar] = adIndValue[currentBar] > adIndValue[baseBar] + sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] < adIndValue[baseBar] - sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Calculates the logic of a No Direction Oscillator.
/// </summary>
/// <param name="firstBar">The first bar number.</param>
/// <param name="previous">To use the previous bar or not.</param>
/// <param name="adIndValue">The indicator values.</param>
/// <param name="level">The Level value.</param>
/// <param name="indComp">Indicator component where to save the results.</param>
/// <param name="indLogic">The chosen logic.</param>
/// <returns>True if everything is ok.</returns>
protected bool NoDirectionOscillatorLogic(int firstBar, int previous, double[] adIndValue, double level, ref IndicatorComp indComp, IndicatorLogic indLogic)
{
double sigma = Sigma();
switch (indLogic)
{
case IndicatorLogic.The_indicator_rises:
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
int baseBar = currentBar - 1;
bool isHigher = adIndValue[currentBar] > adIndValue[baseBar];
bool isNoChange = true;
while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
indComp.Value[bar] = adIndValue[baseBar] < adIndValue[currentBar] - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_falls:
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
int baseBar = currentBar - 1;
bool isHigher = adIndValue[currentBar] > adIndValue[baseBar];
bool isNoChange = true;
while (Math.Abs(adIndValue[currentBar] - adIndValue[baseBar]) < sigma && isNoChange && baseBar > firstBar)
{
isNoChange = (isHigher == (adIndValue[baseBar + 1] > adIndValue[baseBar]));
baseBar--;
}
indComp.Value[bar] = adIndValue[baseBar] > adIndValue[currentBar] + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_higher_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indComp.Value[bar] = adIndValue[bar - previous] > level + sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_is_lower_than_the_level_line:
for (int bar = firstBar; bar < Bars; bar++)
{
indComp.Value[bar] = adIndValue[bar - previous] < level - sigma ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - previous - 1;
while (Math.Abs(adIndValue[baseBar] - level) < sigma && baseBar > firstBar)
{ baseBar--; }
indComp.Value[bar] = (adIndValue[baseBar] < level - sigma && adIndValue[bar - previous] > level + sigma) ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_crosses_the_level_line_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - previous - 1;
while (Math.Abs(adIndValue[baseBar] - level) < sigma && baseBar > firstBar)
{ baseBar--; }
indComp.Value[bar] = (adIndValue[baseBar] > level + sigma && adIndValue[bar - previous] < level - sigma) ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_upward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - previous;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{ bar1--; }
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar)
{ bar2--; }
indComp.Value[bar] = (adIndValue[bar2] > adIndValue[bar1] && adIndValue[bar1] < adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
}
break;
case IndicatorLogic.The_indicator_changes_its_direction_downward:
for (int bar = firstBar; bar < Bars; bar++)
{
int bar0 = bar - previous;
int bar1 = bar0 - 1;
while (Math.Abs(adIndValue[bar0] - adIndValue[bar1]) < sigma && bar1 > firstBar)
{ bar1--; }
int bar2 = bar1 - 1 > firstBar ? bar1 - 1 : firstBar;
while (Math.Abs(adIndValue[bar1] - adIndValue[bar2]) < sigma && bar2 > firstBar)
{ bar2--; }
indComp.Value[bar] = (adIndValue[bar2] < adIndValue[bar1] && adIndValue[bar1] > adIndValue[bar0] && bar1 == bar0 - 1) ? 1 : 0;
}
break;
default:
return false;
}
return true;
}
/// <summary>
/// Returns signals for the logic rule "The Indicator crosses AnotherIndicator upward"
/// </summary>
protected void IndicatorCrossesAnotherIndicatorUpwardLogic(int firstBar, int previous, double[] adIndValue, double[] adAnotherIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
int baseBar = currentBar - 1;
while (Math.Abs(adIndValue[baseBar] - adAnotherIndValue[baseBar]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma && adIndValue[baseBar] < adAnotherIndValue[baseBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma && adIndValue[baseBar] > adAnotherIndValue[baseBar] + sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Returns signals for the logic rule "The Indicator is lower than the AnotherIndicator"
/// </summary>
protected void IndicatorIsLowerThanAnotherIndicatorLogic(int firstBar, int previous, double[] adIndValue, double[] adAnotherIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int currentBar = bar - previous;
indCompLong.Value[bar] = adIndValue[currentBar] < adAnotherIndValue[currentBar] - sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currentBar] > adAnotherIndValue[currentBar] + sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Returns signals for the logic rule "The bar opens below the Indicator"
/// </summary>
protected void BarOpensBelowIndicatorLogic(int firstBar, int previous, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Open[bar] < adIndValue[bar - previous] - sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] > adIndValue[bar - previous] + sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Returns signals for the logic rule "The bar opens below the Indicator after opening above it"
/// </summary>
protected void BarOpensBelowIndicatorAfterOpeningAboveLogic(int firstBar, int previous, double[] adIndValue, ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
for (int bar = firstBar; bar < Bars; bar++)
{
int baseBar = bar - 1;
while (Math.Abs(Open[baseBar] - adIndValue[baseBar - previous]) < sigma && baseBar > firstBar)
{ baseBar--; }
indCompLong.Value[bar] = Open[bar] < adIndValue[bar - previous] - sigma && Open[baseBar] > adIndValue[baseBar - previous] + sigma ? 1 : 0;
indCompShort.Value[bar] = Open[bar] > adIndValue[bar - previous] + sigma && Open[baseBar] < adIndValue[baseBar - previous] - sigma ? 1 : 0;
}
return;
}
/// <summary>
/// Returns signals for the logic rule "The Indicator is higher than the AnotherIndicator"
/// </summary>
protected void IndicatorIsHigherThanAnotherIndicatorLogic(int firstBar, int prvs, double[] adIndValue,
double[] adAnotherIndValue,
ref IndicatorComp indCompLong,
ref IndicatorComp indCompShort)
{
double sigma = Sigma();
firstBar = Math.Max(firstBar, 2);
for (int bar = firstBar; bar < Bars; bar++)
{
int currBar = bar - prvs;
indCompLong.Value[bar] = adIndValue[currBar] > adAnotherIndValue[currBar] + sigma ? 1 : 0;
indCompShort.Value[bar] = adIndValue[currBar] < adAnotherIndValue[currBar] - sigma ? 1 : 0;
}
}
/// <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>
/// Returns signals for the logic rule "The bar closes below the Indicator"
/// </summary>
protected void BarClosesBelowIndicatorLogic(int firstBar, int prvs, double[] adIndValue,
ref IndicatorComp indCompLong, ref IndicatorComp indCompShort)
{
double sigma = Sigma();
firstBar = Math.Max(firstBar, 2);
for (int bar = firstBar; bar < Bars; bar++)
{
indCompLong.Value[bar] = Close[bar] < adIndValue[bar - prvs] - sigma ? 1 : 0;
indCompShort.Value[bar] = Close[bar] > adIndValue[bar - prvs] + sigma ? 1 : 0;
}
}