/// <summary>
/// Implements volume bucketing ala Marcos
/// </summary>
/// <returns></returns>
public ZZVolumeBucketing ZZVolumeBucketing(Data.IDataSeries input, int jmaLen, int volumeBarSize)
{
if (cacheZZVolumeBucketing != null)
{
for (int idx = 0; idx < cacheZZVolumeBucketing.Length; idx++)
{
if (cacheZZVolumeBucketing[idx].JmaLen == jmaLen && cacheZZVolumeBucketing[idx].VolumeBarSize == volumeBarSize && cacheZZVolumeBucketing[idx].EqualsInput(input))
{
return(cacheZZVolumeBucketing[idx]);
}
}
}
lock (checkZZVolumeBucketing)
{
checkZZVolumeBucketing.JmaLen = jmaLen;
jmaLen = checkZZVolumeBucketing.JmaLen;
checkZZVolumeBucketing.VolumeBarSize = volumeBarSize;
volumeBarSize = checkZZVolumeBucketing.VolumeBarSize;
if (cacheZZVolumeBucketing != null)
{
for (int idx = 0; idx < cacheZZVolumeBucketing.Length; idx++)
{
if (cacheZZVolumeBucketing[idx].JmaLen == jmaLen && cacheZZVolumeBucketing[idx].VolumeBarSize == volumeBarSize && cacheZZVolumeBucketing[idx].EqualsInput(input))
{
return(cacheZZVolumeBucketing[idx]);
}
}
}
ZZVolumeBucketing indicator = new ZZVolumeBucketing();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.JmaLen = jmaLen;
indicator.VolumeBarSize = volumeBarSize;
Indicators.Add(indicator);
indicator.SetUp();
ZZVolumeBucketing[] tmp = new ZZVolumeBucketing[cacheZZVolumeBucketing == null ? 1 : cacheZZVolumeBucketing.Length + 1];
if (cacheZZVolumeBucketing != null)
{
cacheZZVolumeBucketing.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheZZVolumeBucketing = tmp;
return(indicator);
}
}
/// <summary>
/// Enter the description of your new custom indicator here
/// </summary>
/// <returns></returns>
public TrueLevels TrueLevels(Data.IDataSeries input, int levelPrecision, int trendPower)
{
if (cacheTrueLevels != null)
{
for (int idx = 0; idx < cacheTrueLevels.Length; idx++)
{
if (cacheTrueLevels[idx].LevelPrecision == levelPrecision && cacheTrueLevels[idx].TrendPower == trendPower && cacheTrueLevels[idx].EqualsInput(input))
{
return(cacheTrueLevels[idx]);
}
}
}
lock (checkTrueLevels)
{
checkTrueLevels.LevelPrecision = levelPrecision;
levelPrecision = checkTrueLevels.LevelPrecision;
checkTrueLevels.TrendPower = trendPower;
trendPower = checkTrueLevels.TrendPower;
if (cacheTrueLevels != null)
{
for (int idx = 0; idx < cacheTrueLevels.Length; idx++)
{
if (cacheTrueLevels[idx].LevelPrecision == levelPrecision && cacheTrueLevels[idx].TrendPower == trendPower && cacheTrueLevels[idx].EqualsInput(input))
{
return(cacheTrueLevels[idx]);
}
}
}
TrueLevels indicator = new TrueLevels();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.LevelPrecision = levelPrecision;
indicator.TrendPower = trendPower;
Indicators.Add(indicator);
indicator.SetUp();
TrueLevels[] tmp = new TrueLevels[cacheTrueLevels == null ? 1 : cacheTrueLevels.Length + 1];
if (cacheTrueLevels != null)
{
cacheTrueLevels.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheTrueLevels = tmp;
return(indicator);
}
}
/// <summary>
/// plot an indicator on one level
/// </summary>
/// <returns></returns>
public plotOneLevel plotOneLevel(Data.IDataSeries input, string alertSound, double level)
{
if (cacheplotOneLevel != null)
{
for (int idx = 0; idx < cacheplotOneLevel.Length; idx++)
{
if (cacheplotOneLevel[idx].AlertSound == alertSound && Math.Abs(cacheplotOneLevel[idx].Level - level) <= double.Epsilon && cacheplotOneLevel[idx].EqualsInput(input))
{
return(cacheplotOneLevel[idx]);
}
}
}
lock (checkplotOneLevel)
{
checkplotOneLevel.AlertSound = alertSound;
alertSound = checkplotOneLevel.AlertSound;
checkplotOneLevel.Level = level;
level = checkplotOneLevel.Level;
if (cacheplotOneLevel != null)
{
for (int idx = 0; idx < cacheplotOneLevel.Length; idx++)
{
if (cacheplotOneLevel[idx].AlertSound == alertSound && Math.Abs(cacheplotOneLevel[idx].Level - level) <= double.Epsilon && cacheplotOneLevel[idx].EqualsInput(input))
{
return(cacheplotOneLevel[idx]);
}
}
}
plotOneLevel indicator = new plotOneLevel();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.AlertSound = alertSound;
indicator.Level = level;
Indicators.Add(indicator);
indicator.SetUp();
plotOneLevel[] tmp = new plotOneLevel[cacheplotOneLevel == null ? 1 : cacheplotOneLevel.Length + 1];
if (cacheplotOneLevel != null)
{
cacheplotOneLevel.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheplotOneLevel = tmp;
return(indicator);
}
}
/// <summary>
/// The MAMA (MESA Adaptive Moving Average) was developed by John Ehlers. It adapts to price movement in a new and unique way. The adaptation is based on the Hilbert Transform Discriminator. The adavantage of this method features fast attack average and a slow decay average. The MAMA + the FAMA (Following Adaptive Moving Average) lines only cross at major market reversals.
/// </summary>
/// <returns></returns>
public MAMA MAMA(Data.IDataSeries input, double fastLimit, double slowLimit)
{
if (cacheMAMA != null)
{
for (int idx = 0; idx < cacheMAMA.Length; idx++)
{
if (Math.Abs(cacheMAMA[idx].FastLimit - fastLimit) <= double.Epsilon && Math.Abs(cacheMAMA[idx].SlowLimit - slowLimit) <= double.Epsilon && cacheMAMA[idx].EqualsInput(input))
{
return(cacheMAMA[idx]);
}
}
}
lock (checkMAMA)
{
checkMAMA.FastLimit = fastLimit;
fastLimit = checkMAMA.FastLimit;
checkMAMA.SlowLimit = slowLimit;
slowLimit = checkMAMA.SlowLimit;
if (cacheMAMA != null)
{
for (int idx = 0; idx < cacheMAMA.Length; idx++)
{
if (Math.Abs(cacheMAMA[idx].FastLimit - fastLimit) <= double.Epsilon && Math.Abs(cacheMAMA[idx].SlowLimit - slowLimit) <= double.Epsilon && cacheMAMA[idx].EqualsInput(input))
{
return(cacheMAMA[idx]);
}
}
}
MAMA indicator = new MAMA();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.FastLimit = fastLimit;
indicator.SlowLimit = slowLimit;
Indicators.Add(indicator);
indicator.SetUp();
MAMA[] tmp = new MAMA[cacheMAMA == null ? 1 : cacheMAMA.Length + 1];
if (cacheMAMA != null)
{
cacheMAMA.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheMAMA = tmp;
return(indicator);
}
}
/// <summary>
/// Plots the ratio value of the pair.
/// </summary>
/// <returns></returns>
public PairsRatio PairsRatio(Data.IDataSeries input, string firstInstrument, string secondInstrument)
{
if (cachePairsRatio != null)
{
for (int idx = 0; idx < cachePairsRatio.Length; idx++)
{
if (cachePairsRatio[idx].FirstInstrument == firstInstrument && cachePairsRatio[idx].SecondInstrument == secondInstrument && cachePairsRatio[idx].EqualsInput(input))
{
return(cachePairsRatio[idx]);
}
}
}
lock (checkPairsRatio)
{
checkPairsRatio.FirstInstrument = firstInstrument;
firstInstrument = checkPairsRatio.FirstInstrument;
checkPairsRatio.SecondInstrument = secondInstrument;
secondInstrument = checkPairsRatio.SecondInstrument;
if (cachePairsRatio != null)
{
for (int idx = 0; idx < cachePairsRatio.Length; idx++)
{
if (cachePairsRatio[idx].FirstInstrument == firstInstrument && cachePairsRatio[idx].SecondInstrument == secondInstrument && cachePairsRatio[idx].EqualsInput(input))
{
return(cachePairsRatio[idx]);
}
}
}
PairsRatio indicator = new PairsRatio();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.FirstInstrument = firstInstrument;
indicator.SecondInstrument = secondInstrument;
Indicators.Add(indicator);
indicator.SetUp();
PairsRatio[] tmp = new PairsRatio[cachePairsRatio == null ? 1 : cachePairsRatio.Length + 1];
if (cachePairsRatio != null)
{
cachePairsRatio.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cachePairsRatio = tmp;
return(indicator);
}
}
/// <summary>
/// GomCD Heikin Ashi
/// </summary>
/// <returns></returns>
public GomCDHA GomCDHA(Data.IDataSeries input, int maxCompBars, int minCompBars)
{
if (cacheGomCDHA != null)
{
for (int idx = 0; idx < cacheGomCDHA.Length; idx++)
{
if (cacheGomCDHA[idx].MaxCompBars == maxCompBars && cacheGomCDHA[idx].MinCompBars == minCompBars && cacheGomCDHA[idx].EqualsInput(input))
{
return(cacheGomCDHA[idx]);
}
}
}
lock (checkGomCDHA)
{
checkGomCDHA.MaxCompBars = maxCompBars;
maxCompBars = checkGomCDHA.MaxCompBars;
checkGomCDHA.MinCompBars = minCompBars;
minCompBars = checkGomCDHA.MinCompBars;
if (cacheGomCDHA != null)
{
for (int idx = 0; idx < cacheGomCDHA.Length; idx++)
{
if (cacheGomCDHA[idx].MaxCompBars == maxCompBars && cacheGomCDHA[idx].MinCompBars == minCompBars && cacheGomCDHA[idx].EqualsInput(input))
{
return(cacheGomCDHA[idx]);
}
}
}
GomCDHA indicator = new GomCDHA();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.MaxCompBars = maxCompBars;
indicator.MinCompBars = minCompBars;
Indicators.Add(indicator);
indicator.SetUp();
GomCDHA[] tmp = new GomCDHA[cacheGomCDHA == null ? 1 : cacheGomCDHA.Length + 1];
if (cacheGomCDHA != null)
{
cacheGomCDHA.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheGomCDHA = tmp;
return(indicator);
}
}
/// <summary>
/// Displays the tick count of a bar.
/// </summary>
/// <returns></returns>
public TickCounter TickCounter(Data.IDataSeries input, bool countDown, bool showPercent)
{
if (cacheTickCounter != null)
{
for (int idx = 0; idx < cacheTickCounter.Length; idx++)
{
if (cacheTickCounter[idx].CountDown == countDown && cacheTickCounter[idx].ShowPercent == showPercent && cacheTickCounter[idx].EqualsInput(input))
{
return(cacheTickCounter[idx]);
}
}
}
lock (checkTickCounter)
{
checkTickCounter.CountDown = countDown;
countDown = checkTickCounter.CountDown;
checkTickCounter.ShowPercent = showPercent;
showPercent = checkTickCounter.ShowPercent;
if (cacheTickCounter != null)
{
for (int idx = 0; idx < cacheTickCounter.Length; idx++)
{
if (cacheTickCounter[idx].CountDown == countDown && cacheTickCounter[idx].ShowPercent == showPercent && cacheTickCounter[idx].EqualsInput(input))
{
return(cacheTickCounter[idx]);
}
}
}
TickCounter indicator = new TickCounter();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.CountDown = countDown;
indicator.ShowPercent = showPercent;
Indicators.Add(indicator);
indicator.SetUp();
TickCounter[] tmp = new TickCounter[cacheTickCounter == null ? 1 : cacheTickCounter.Length + 1];
if (cacheTickCounter != null)
{
cacheTickCounter.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheTickCounter = tmp;
return(indicator);
}
}
/// <summary>
/// Bollinger Bands are plotted at standard deviation levels above and below a moving average. Since standard deviation is a measure of volatility, the bands are self-adjusting: widening during volatile markets and contracting during calmer periods.
/// </summary>
/// <returns></returns>
public AhrensBB AhrensBB(Data.IDataSeries input, double numStdDev, int period)
{
if (cacheAhrensBB != null)
{
for (int idx = 0; idx < cacheAhrensBB.Length; idx++)
{
if (Math.Abs(cacheAhrensBB[idx].NumStdDev - numStdDev) <= double.Epsilon && cacheAhrensBB[idx].Period == period && cacheAhrensBB[idx].EqualsInput(input))
{
return(cacheAhrensBB[idx]);
}
}
}
lock (checkAhrensBB)
{
checkAhrensBB.NumStdDev = numStdDev;
numStdDev = checkAhrensBB.NumStdDev;
checkAhrensBB.Period = period;
period = checkAhrensBB.Period;
if (cacheAhrensBB != null)
{
for (int idx = 0; idx < cacheAhrensBB.Length; idx++)
{
if (Math.Abs(cacheAhrensBB[idx].NumStdDev - numStdDev) <= double.Epsilon && cacheAhrensBB[idx].Period == period && cacheAhrensBB[idx].EqualsInput(input))
{
return(cacheAhrensBB[idx]);
}
}
}
AhrensBB indicator = new AhrensBB();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.NumStdDev = numStdDev;
indicator.Period = period;
Indicators.Add(indicator);
indicator.SetUp();
AhrensBB[] tmp = new AhrensBB[cacheAhrensBB == null ? 1 : cacheAhrensBB.Length + 1];
if (cacheAhrensBB != null)
{
cacheAhrensBB.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheAhrensBB = tmp;
return(indicator);
}
}
/// <summary>
/// Variable moving average
/// </summary>
/// <returns></returns>
public MAV MAV(Data.IDataSeries input, int mAPeriod, int typeInt)
{
if (cacheMAV != null)
{
for (int idx = 0; idx < cacheMAV.Length; idx++)
{
if (cacheMAV[idx].MAPeriod == mAPeriod && cacheMAV[idx].TypeInt == typeInt && cacheMAV[idx].EqualsInput(input))
{
return(cacheMAV[idx]);
}
}
}
lock (checkMAV)
{
checkMAV.MAPeriod = mAPeriod;
mAPeriod = checkMAV.MAPeriod;
checkMAV.TypeInt = typeInt;
typeInt = checkMAV.TypeInt;
if (cacheMAV != null)
{
for (int idx = 0; idx < cacheMAV.Length; idx++)
{
if (cacheMAV[idx].MAPeriod == mAPeriod && cacheMAV[idx].TypeInt == typeInt && cacheMAV[idx].EqualsInput(input))
{
return(cacheMAV[idx]);
}
}
}
MAV indicator = new MAV();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.MAPeriod = mAPeriod;
indicator.TypeInt = typeInt;
Indicators.Add(indicator);
indicator.SetUp();
MAV[] tmp = new MAV[cacheMAV == null ? 1 : cacheMAV.Length + 1];
if (cacheMAV != null)
{
cacheMAV.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheMAV = tmp;
return(indicator);
}
}
/// <summary>
/// the Holt trend-adjusted EMA [email protected]
/// </summary>
/// <returns></returns>
public HoltEMA HoltEMA(Data.IDataSeries input, double alpha, double gamma)
{
if (cacheHoltEMA != null)
{
for (int idx = 0; idx < cacheHoltEMA.Length; idx++)
{
if (Math.Abs(cacheHoltEMA[idx].Alpha - alpha) <= double.Epsilon && Math.Abs(cacheHoltEMA[idx].Gamma - gamma) <= double.Epsilon && cacheHoltEMA[idx].EqualsInput(input))
{
return(cacheHoltEMA[idx]);
}
}
}
lock (checkHoltEMA)
{
checkHoltEMA.Alpha = alpha;
alpha = checkHoltEMA.Alpha;
checkHoltEMA.Gamma = gamma;
gamma = checkHoltEMA.Gamma;
if (cacheHoltEMA != null)
{
for (int idx = 0; idx < cacheHoltEMA.Length; idx++)
{
if (Math.Abs(cacheHoltEMA[idx].Alpha - alpha) <= double.Epsilon && Math.Abs(cacheHoltEMA[idx].Gamma - gamma) <= double.Epsilon && cacheHoltEMA[idx].EqualsInput(input))
{
return(cacheHoltEMA[idx]);
}
}
}
HoltEMA indicator = new HoltEMA();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Alpha = alpha;
indicator.Gamma = gamma;
Indicators.Add(indicator);
indicator.SetUp();
HoltEMA[] tmp = new HoltEMA[cacheHoltEMA == null ? 1 : cacheHoltEMA.Length + 1];
if (cacheHoltEMA != null)
{
cacheHoltEMA.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheHoltEMA = tmp;
return(indicator);
}
}
/// <summary>
/// JMA Double Stochastic
/// </summary>
/// <returns></returns>
public Jurik_JMA_DoubleStoch Jurik_JMA_DoubleStoch(Data.IDataSeries input, double jma_len, int stoch_len)
{
if (cacheJurik_JMA_DoubleStoch != null)
{
for (int idx = 0; idx < cacheJurik_JMA_DoubleStoch.Length; idx++)
{
if (Math.Abs(cacheJurik_JMA_DoubleStoch[idx].Jma_len - jma_len) <= double.Epsilon && cacheJurik_JMA_DoubleStoch[idx].Stoch_len == stoch_len && cacheJurik_JMA_DoubleStoch[idx].EqualsInput(input))
{
return(cacheJurik_JMA_DoubleStoch[idx]);
}
}
}
lock (checkJurik_JMA_DoubleStoch)
{
checkJurik_JMA_DoubleStoch.Jma_len = jma_len;
jma_len = checkJurik_JMA_DoubleStoch.Jma_len;
checkJurik_JMA_DoubleStoch.Stoch_len = stoch_len;
stoch_len = checkJurik_JMA_DoubleStoch.Stoch_len;
if (cacheJurik_JMA_DoubleStoch != null)
{
for (int idx = 0; idx < cacheJurik_JMA_DoubleStoch.Length; idx++)
{
if (Math.Abs(cacheJurik_JMA_DoubleStoch[idx].Jma_len - jma_len) <= double.Epsilon && cacheJurik_JMA_DoubleStoch[idx].Stoch_len == stoch_len && cacheJurik_JMA_DoubleStoch[idx].EqualsInput(input))
{
return(cacheJurik_JMA_DoubleStoch[idx]);
}
}
}
Jurik_JMA_DoubleStoch indicator = new Jurik_JMA_DoubleStoch();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Jma_len = jma_len;
indicator.Stoch_len = stoch_len;
Indicators.Add(indicator);
indicator.SetUp();
Jurik_JMA_DoubleStoch[] tmp = new Jurik_JMA_DoubleStoch[cacheJurik_JMA_DoubleStoch == null ? 1 : cacheJurik_JMA_DoubleStoch.Length + 1];
if (cacheJurik_JMA_DoubleStoch != null)
{
cacheJurik_JMA_DoubleStoch.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheJurik_JMA_DoubleStoch = tmp;
return(indicator);
}
}
/// <summary>
/// Trigger Lines.
/// </summary>
/// <returns></returns>
public TriggerLines TriggerLines(Data.IDataSeries input, int period, int trigAvg)
{
if (cacheTriggerLines != null)
{
for (int idx = 0; idx < cacheTriggerLines.Length; idx++)
{
if (cacheTriggerLines[idx].Period == period && cacheTriggerLines[idx].TrigAvg == trigAvg && cacheTriggerLines[idx].EqualsInput(input))
{
return(cacheTriggerLines[idx]);
}
}
}
lock (checkTriggerLines)
{
checkTriggerLines.Period = period;
period = checkTriggerLines.Period;
checkTriggerLines.TrigAvg = trigAvg;
trigAvg = checkTriggerLines.TrigAvg;
if (cacheTriggerLines != null)
{
for (int idx = 0; idx < cacheTriggerLines.Length; idx++)
{
if (cacheTriggerLines[idx].Period == period && cacheTriggerLines[idx].TrigAvg == trigAvg && cacheTriggerLines[idx].EqualsInput(input))
{
return(cacheTriggerLines[idx]);
}
}
}
TriggerLines indicator = new TriggerLines();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Period = period;
indicator.TrigAvg = trigAvg;
Indicators.Add(indicator);
indicator.SetUp();
TriggerLines[] tmp = new TriggerLines[cacheTriggerLines == null ? 1 : cacheTriggerLines.Length + 1];
if (cacheTriggerLines != null)
{
cacheTriggerLines.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheTriggerLines = tmp;
return(indicator);
}
}
/// <summary>
/// The indicator regroups single bars to display them as Multi Period Boxes
/// </summary>
/// <returns></returns>
public anaMultiPeriodBoxes anaMultiPeriodBoxes(Data.IDataSeries input, int opacity, int period)
{
if (cacheanaMultiPeriodBoxes != null)
{
for (int idx = 0; idx < cacheanaMultiPeriodBoxes.Length; idx++)
{
if (cacheanaMultiPeriodBoxes[idx].Opacity == opacity && cacheanaMultiPeriodBoxes[idx].Period == period && cacheanaMultiPeriodBoxes[idx].EqualsInput(input))
{
return(cacheanaMultiPeriodBoxes[idx]);
}
}
}
lock (checkanaMultiPeriodBoxes)
{
checkanaMultiPeriodBoxes.Opacity = opacity;
opacity = checkanaMultiPeriodBoxes.Opacity;
checkanaMultiPeriodBoxes.Period = period;
period = checkanaMultiPeriodBoxes.Period;
if (cacheanaMultiPeriodBoxes != null)
{
for (int idx = 0; idx < cacheanaMultiPeriodBoxes.Length; idx++)
{
if (cacheanaMultiPeriodBoxes[idx].Opacity == opacity && cacheanaMultiPeriodBoxes[idx].Period == period && cacheanaMultiPeriodBoxes[idx].EqualsInput(input))
{
return(cacheanaMultiPeriodBoxes[idx]);
}
}
}
anaMultiPeriodBoxes indicator = new anaMultiPeriodBoxes();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Opacity = opacity;
indicator.Period = period;
Indicators.Add(indicator);
indicator.SetUp();
anaMultiPeriodBoxes[] tmp = new anaMultiPeriodBoxes[cacheanaMultiPeriodBoxes == null ? 1 : cacheanaMultiPeriodBoxes.Length + 1];
if (cacheanaMultiPeriodBoxes != null)
{
cacheanaMultiPeriodBoxes.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheanaMultiPeriodBoxes = tmp;
return(indicator);
}
}
/// <summary>
/// VPIN indicator
/// </summary>
/// <returns></returns>
public ZZVPINcdf ZZVPINcdf(Data.IDataSeries input, int sampleSize, int volBucketSize)
{
if (cacheZZVPINcdf != null)
{
for (int idx = 0; idx < cacheZZVPINcdf.Length; idx++)
{
if (cacheZZVPINcdf[idx].SampleSize == sampleSize && cacheZZVPINcdf[idx].VolBucketSize == volBucketSize && cacheZZVPINcdf[idx].EqualsInput(input))
{
return(cacheZZVPINcdf[idx]);
}
}
}
lock (checkZZVPINcdf)
{
checkZZVPINcdf.SampleSize = sampleSize;
sampleSize = checkZZVPINcdf.SampleSize;
checkZZVPINcdf.VolBucketSize = volBucketSize;
volBucketSize = checkZZVPINcdf.VolBucketSize;
if (cacheZZVPINcdf != null)
{
for (int idx = 0; idx < cacheZZVPINcdf.Length; idx++)
{
if (cacheZZVPINcdf[idx].SampleSize == sampleSize && cacheZZVPINcdf[idx].VolBucketSize == volBucketSize && cacheZZVPINcdf[idx].EqualsInput(input))
{
return(cacheZZVPINcdf[idx]);
}
}
}
ZZVPINcdf indicator = new ZZVPINcdf();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.SampleSize = sampleSize;
indicator.VolBucketSize = volBucketSize;
Indicators.Add(indicator);
indicator.SetUp();
ZZVPINcdf[] tmp = new ZZVPINcdf[cacheZZVPINcdf == null ? 1 : cacheZZVPINcdf.Length + 1];
if (cacheZZVPINcdf != null)
{
cacheZZVPINcdf.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheZZVPINcdf = tmp;
return(indicator);
}
}
/// <summary>
/// Quantifying slope od EMA
/// </summary>
/// <returns></returns>
public ZZSlopeQuant ZZSlopeQuant(Data.IDataSeries input, int eMAPeriod, int lookbackBars)
{
if (cacheZZSlopeQuant != null)
{
for (int idx = 0; idx < cacheZZSlopeQuant.Length; idx++)
{
if (cacheZZSlopeQuant[idx].EMAPeriod == eMAPeriod && cacheZZSlopeQuant[idx].LookbackBars == lookbackBars && cacheZZSlopeQuant[idx].EqualsInput(input))
{
return(cacheZZSlopeQuant[idx]);
}
}
}
lock (checkZZSlopeQuant)
{
checkZZSlopeQuant.EMAPeriod = eMAPeriod;
eMAPeriod = checkZZSlopeQuant.EMAPeriod;
checkZZSlopeQuant.LookbackBars = lookbackBars;
lookbackBars = checkZZSlopeQuant.LookbackBars;
if (cacheZZSlopeQuant != null)
{
for (int idx = 0; idx < cacheZZSlopeQuant.Length; idx++)
{
if (cacheZZSlopeQuant[idx].EMAPeriod == eMAPeriod && cacheZZSlopeQuant[idx].LookbackBars == lookbackBars && cacheZZSlopeQuant[idx].EqualsInput(input))
{
return(cacheZZSlopeQuant[idx]);
}
}
}
ZZSlopeQuant indicator = new ZZSlopeQuant();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.EMAPeriod = eMAPeriod;
indicator.LookbackBars = lookbackBars;
Indicators.Add(indicator);
indicator.SetUp();
ZZSlopeQuant[] tmp = new ZZSlopeQuant[cacheZZSlopeQuant == null ? 1 : cacheZZSlopeQuant.Length + 1];
if (cacheZZSlopeQuant != null)
{
cacheZZSlopeQuant.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheZZSlopeQuant = tmp;
return(indicator);
}
}
/// <summary>
/// Enter the description of your new custom indicator here
/// </summary>
/// <returns></returns>
public EMAofATR EMAofATR(Data.IDataSeries input, double multiplier, int period)
{
if (cacheEMAofATR != null)
{
for (int idx = 0; idx < cacheEMAofATR.Length; idx++)
{
if (Math.Abs(cacheEMAofATR[idx].Multiplier - multiplier) <= double.Epsilon && cacheEMAofATR[idx].Period == period && cacheEMAofATR[idx].EqualsInput(input))
{
return(cacheEMAofATR[idx]);
}
}
}
lock (checkEMAofATR)
{
checkEMAofATR.Multiplier = multiplier;
multiplier = checkEMAofATR.Multiplier;
checkEMAofATR.Period = period;
period = checkEMAofATR.Period;
if (cacheEMAofATR != null)
{
for (int idx = 0; idx < cacheEMAofATR.Length; idx++)
{
if (Math.Abs(cacheEMAofATR[idx].Multiplier - multiplier) <= double.Epsilon && cacheEMAofATR[idx].Period == period && cacheEMAofATR[idx].EqualsInput(input))
{
return(cacheEMAofATR[idx]);
}
}
}
EMAofATR indicator = new EMAofATR();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Multiplier = multiplier;
indicator.Period = period;
Indicators.Add(indicator);
indicator.SetUp();
EMAofATR[] tmp = new EMAofATR[cacheEMAofATR == null ? 1 : cacheEMAofATR.Length + 1];
if (cacheEMAofATR != null)
{
cacheEMAofATR.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheEMAofATR = tmp;
return(indicator);
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public DStochZeroLag DStochZeroLag(Data.IDataSeries input, int dSTlen, int priceactionFilter)
{
if (cacheDStochZeroLag != null)
{
for (int idx = 0; idx < cacheDStochZeroLag.Length; idx++)
{
if (cacheDStochZeroLag[idx].DSTlen == dSTlen && cacheDStochZeroLag[idx].PriceactionFilter == priceactionFilter && cacheDStochZeroLag[idx].EqualsInput(input))
{
return(cacheDStochZeroLag[idx]);
}
}
}
lock (checkDStochZeroLag)
{
checkDStochZeroLag.DSTlen = dSTlen;
dSTlen = checkDStochZeroLag.DSTlen;
checkDStochZeroLag.PriceactionFilter = priceactionFilter;
priceactionFilter = checkDStochZeroLag.PriceactionFilter;
if (cacheDStochZeroLag != null)
{
for (int idx = 0; idx < cacheDStochZeroLag.Length; idx++)
{
if (cacheDStochZeroLag[idx].DSTlen == dSTlen && cacheDStochZeroLag[idx].PriceactionFilter == priceactionFilter && cacheDStochZeroLag[idx].EqualsInput(input))
{
return(cacheDStochZeroLag[idx]);
}
}
}
DStochZeroLag indicator = new DStochZeroLag();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.DSTlen = dSTlen;
indicator.PriceactionFilter = priceactionFilter;
Indicators.Add(indicator);
indicator.SetUp();
DStochZeroLag[] tmp = new DStochZeroLag[cacheDStochZeroLag == null ? 1 : cacheDStochZeroLag.Length + 1];
if (cacheDStochZeroLag != null)
{
cacheDStochZeroLag.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheDStochZeroLag = tmp;
return(indicator);
}
}
/// <summary>
/// laguerre rsi
/// </summary>
/// <returns></returns>
public Z20101212LaguerreRSI Z20101212LaguerreRSI(Data.IDataSeries input, double gamma, int length)
{
if (cacheZ20101212LaguerreRSI != null)
{
for (int idx = 0; idx < cacheZ20101212LaguerreRSI.Length; idx++)
{
if (Math.Abs(cacheZ20101212LaguerreRSI[idx].Gamma - gamma) <= double.Epsilon && cacheZ20101212LaguerreRSI[idx].Length == length && cacheZ20101212LaguerreRSI[idx].EqualsInput(input))
{
return(cacheZ20101212LaguerreRSI[idx]);
}
}
}
lock (checkZ20101212LaguerreRSI)
{
checkZ20101212LaguerreRSI.Gamma = gamma;
gamma = checkZ20101212LaguerreRSI.Gamma;
checkZ20101212LaguerreRSI.Length = length;
length = checkZ20101212LaguerreRSI.Length;
if (cacheZ20101212LaguerreRSI != null)
{
for (int idx = 0; idx < cacheZ20101212LaguerreRSI.Length; idx++)
{
if (Math.Abs(cacheZ20101212LaguerreRSI[idx].Gamma - gamma) <= double.Epsilon && cacheZ20101212LaguerreRSI[idx].Length == length && cacheZ20101212LaguerreRSI[idx].EqualsInput(input))
{
return(cacheZ20101212LaguerreRSI[idx]);
}
}
}
Z20101212LaguerreRSI indicator = new Z20101212LaguerreRSI();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Gamma = gamma;
indicator.Length = length;
Indicators.Add(indicator);
indicator.SetUp();
Z20101212LaguerreRSI[] tmp = new Z20101212LaguerreRSI[cacheZ20101212LaguerreRSI == null ? 1 : cacheZ20101212LaguerreRSI.Length + 1];
if (cacheZ20101212LaguerreRSI != null)
{
cacheZ20101212LaguerreRSI.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheZ20101212LaguerreRSI = tmp;
return(indicator);
}
}
/// <summary>
/// The TSF (Time Series Forecast) calculates probable future values for the price by fitting a linear regression line over a given number of price bars and following that line forward into the future. A linear regression line is a straight line which is as close to all of the given price points as possible. Also see the Linear Regression indicator.
/// </summary>
/// <returns></returns>
public TSF TSF(Data.IDataSeries input, int forecast, int period)
{
if (cacheTSF != null)
{
for (int idx = 0; idx < cacheTSF.Length; idx++)
{
if (cacheTSF[idx].Forecast == forecast && cacheTSF[idx].Period == period && cacheTSF[idx].EqualsInput(input))
{
return(cacheTSF[idx]);
}
}
}
lock (checkTSF)
{
checkTSF.Forecast = forecast;
forecast = checkTSF.Forecast;
checkTSF.Period = period;
period = checkTSF.Period;
if (cacheTSF != null)
{
for (int idx = 0; idx < cacheTSF.Length; idx++)
{
if (cacheTSF[idx].Forecast == forecast && cacheTSF[idx].Period == period && cacheTSF[idx].EqualsInput(input))
{
return(cacheTSF[idx]);
}
}
}
TSF indicator = new TSF();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Forecast = forecast;
indicator.Period = period;
Indicators.Add(indicator);
indicator.SetUp();
TSF[] tmp = new TSF[cacheTSF == null ? 1 : cacheTSF.Length + 1];
if (cacheTSF != null)
{
cacheTSF.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheTSF = tmp;
return(indicator);
}
}
/// <summary>
/// The SMA (Simple Moving Average) is an indicator that shows the average value of a security's price over a period of time.
/// </summary>
/// <returns></returns>
public SMAAqueGen SMAAqueGen(Data.IDataSeries input, int dayOfSMAValot, int sMAPeriod)
{
if (cacheSMAAqueGen != null)
{
for (int idx = 0; idx < cacheSMAAqueGen.Length; idx++)
{
if (cacheSMAAqueGen[idx].DayOfSMAValot == dayOfSMAValot && cacheSMAAqueGen[idx].SMAPeriod == sMAPeriod && cacheSMAAqueGen[idx].EqualsInput(input))
{
return(cacheSMAAqueGen[idx]);
}
}
}
lock (checkSMAAqueGen)
{
checkSMAAqueGen.DayOfSMAValot = dayOfSMAValot;
dayOfSMAValot = checkSMAAqueGen.DayOfSMAValot;
checkSMAAqueGen.SMAPeriod = sMAPeriod;
sMAPeriod = checkSMAAqueGen.SMAPeriod;
if (cacheSMAAqueGen != null)
{
for (int idx = 0; idx < cacheSMAAqueGen.Length; idx++)
{
if (cacheSMAAqueGen[idx].DayOfSMAValot == dayOfSMAValot && cacheSMAAqueGen[idx].SMAPeriod == sMAPeriod && cacheSMAAqueGen[idx].EqualsInput(input))
{
return(cacheSMAAqueGen[idx]);
}
}
}
SMAAqueGen indicator = new SMAAqueGen();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.DayOfSMAValot = dayOfSMAValot;
indicator.SMAPeriod = sMAPeriod;
Indicators.Add(indicator);
indicator.SetUp();
SMAAqueGen[] tmp = new SMAAqueGen[cacheSMAAqueGen == null ? 1 : cacheSMAAqueGen.Length + 1];
if (cacheSMAAqueGen != null)
{
cacheSMAAqueGen.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheSMAAqueGen = tmp;
return(indicator);
}
}
/// <summary>
/// Guppy Stuff
/// </summary>
/// <returns></returns>
public zRainbowEMA zRainbowEMA(Data.IDataSeries input, bool startsOn, bool useThreeBands)
{
if (cachezRainbowEMA != null)
{
for (int idx = 0; idx < cachezRainbowEMA.Length; idx++)
{
if (cachezRainbowEMA[idx].StartsOn == startsOn && cachezRainbowEMA[idx].UseThreeBands == useThreeBands && cachezRainbowEMA[idx].EqualsInput(input))
{
return(cachezRainbowEMA[idx]);
}
}
}
lock (checkzRainbowEMA)
{
checkzRainbowEMA.StartsOn = startsOn;
startsOn = checkzRainbowEMA.StartsOn;
checkzRainbowEMA.UseThreeBands = useThreeBands;
useThreeBands = checkzRainbowEMA.UseThreeBands;
if (cachezRainbowEMA != null)
{
for (int idx = 0; idx < cachezRainbowEMA.Length; idx++)
{
if (cachezRainbowEMA[idx].StartsOn == startsOn && cachezRainbowEMA[idx].UseThreeBands == useThreeBands && cachezRainbowEMA[idx].EqualsInput(input))
{
return(cachezRainbowEMA[idx]);
}
}
}
zRainbowEMA indicator = new zRainbowEMA();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.StartsOn = startsOn;
indicator.UseThreeBands = useThreeBands;
Indicators.Add(indicator);
indicator.SetUp();
zRainbowEMA[] tmp = new zRainbowEMA[cachezRainbowEMA == null ? 1 : cachezRainbowEMA.Length + 1];
if (cachezRainbowEMA != null)
{
cachezRainbowEMA.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cachezRainbowEMA = tmp;
return(indicator);
}
}
/// <summary>
/// The PFE (Polarized Fractal Efficiency) is an indicator that uses fractal geometry to determine how efficiently the price is moving.
/// </summary>
/// <returns></returns>
public PFE PFE(Data.IDataSeries input, int period, int smooth)
{
if (cachePFE != null)
{
for (int idx = 0; idx < cachePFE.Length; idx++)
{
if (cachePFE[idx].Period == period && cachePFE[idx].Smooth == smooth && cachePFE[idx].EqualsInput(input))
{
return(cachePFE[idx]);
}
}
}
lock (checkPFE)
{
checkPFE.Period = period;
period = checkPFE.Period;
checkPFE.Smooth = smooth;
smooth = checkPFE.Smooth;
if (cachePFE != null)
{
for (int idx = 0; idx < cachePFE.Length; idx++)
{
if (cachePFE[idx].Period == period && cachePFE[idx].Smooth == smooth && cachePFE[idx].EqualsInput(input))
{
return(cachePFE[idx]);
}
}
}
PFE indicator = new PFE();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Period = period;
indicator.Smooth = smooth;
Indicators.Add(indicator);
indicator.SetUp();
PFE[] tmp = new PFE[cachePFE == null ? 1 : cachePFE.Length + 1];
if (cachePFE != null)
{
cachePFE.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cachePFE = tmp;
return(indicator);
}
}
private void CreateMarkingZones(SolidColorBrush ZoneBrush, Pen ZonePen, VisualShape ManipulatedShape)
{
foreach (var MarkingZone in ManipulatedShape.CurrentMarkingZones)
{
var IconZone = (new GeometryDrawing(ZoneBrush, ZonePen, new RectangleGeometry(MarkingZone.Item2))).RenderToDrawingVisual();
IconZone.Opacity = FrmOpacityEdit;
Indicators.Add(IconZone);
FrmMarkingZones.Add(IconZone, MarkingZone.Item1);
}
}
/// <summary>
/// Subtract the Dexp from the Momo and see what's shakin
/// </summary>
/// <returns></returns>
public zDexpMomoSub zDexpMomoSub(Data.IDataSeries input, double alpha, int momo)
{
if (cachezDexpMomoSub != null)
{
for (int idx = 0; idx < cachezDexpMomoSub.Length; idx++)
{
if (Math.Abs(cachezDexpMomoSub[idx].Alpha - alpha) <= double.Epsilon && cachezDexpMomoSub[idx].Momo == momo && cachezDexpMomoSub[idx].EqualsInput(input))
{
return(cachezDexpMomoSub[idx]);
}
}
}
lock (checkzDexpMomoSub)
{
checkzDexpMomoSub.Alpha = alpha;
alpha = checkzDexpMomoSub.Alpha;
checkzDexpMomoSub.Momo = momo;
momo = checkzDexpMomoSub.Momo;
if (cachezDexpMomoSub != null)
{
for (int idx = 0; idx < cachezDexpMomoSub.Length; idx++)
{
if (Math.Abs(cachezDexpMomoSub[idx].Alpha - alpha) <= double.Epsilon && cachezDexpMomoSub[idx].Momo == momo && cachezDexpMomoSub[idx].EqualsInput(input))
{
return(cachezDexpMomoSub[idx]);
}
}
}
zDexpMomoSub indicator = new zDexpMomoSub();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Alpha = alpha;
indicator.Momo = momo;
Indicators.Add(indicator);
indicator.SetUp();
zDexpMomoSub[] tmp = new zDexpMomoSub[cachezDexpMomoSub == null ? 1 : cachezDexpMomoSub.Length + 1];
if (cachezDexpMomoSub != null)
{
cachezDexpMomoSub.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cachezDexpMomoSub = tmp;
return(indicator);
}
}
/// <summary>
/// my rsi
/// </summary>
/// <returns></returns>
public zRSI zRSI(Data.IDataSeries input, double alphaTLine, double alphaUD)
{
if (cachezRSI != null)
{
for (int idx = 0; idx < cachezRSI.Length; idx++)
{
if (Math.Abs(cachezRSI[idx].AlphaTLine - alphaTLine) <= double.Epsilon && Math.Abs(cachezRSI[idx].AlphaUD - alphaUD) <= double.Epsilon && cachezRSI[idx].EqualsInput(input))
{
return(cachezRSI[idx]);
}
}
}
lock (checkzRSI)
{
checkzRSI.AlphaTLine = alphaTLine;
alphaTLine = checkzRSI.AlphaTLine;
checkzRSI.AlphaUD = alphaUD;
alphaUD = checkzRSI.AlphaUD;
if (cachezRSI != null)
{
for (int idx = 0; idx < cachezRSI.Length; idx++)
{
if (Math.Abs(cachezRSI[idx].AlphaTLine - alphaTLine) <= double.Epsilon && Math.Abs(cachezRSI[idx].AlphaUD - alphaUD) <= double.Epsilon && cachezRSI[idx].EqualsInput(input))
{
return(cachezRSI[idx]);
}
}
}
zRSI indicator = new zRSI();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.AlphaTLine = alphaTLine;
indicator.AlphaUD = alphaUD;
Indicators.Add(indicator);
indicator.SetUp();
zRSI[] tmp = new zRSI[cachezRSI == null ? 1 : cachezRSI.Length + 1];
if (cachezRSI != null)
{
cachezRSI.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cachezRSI = tmp;
return(indicator);
}
}
/// <summary>
/// Enter the description of your new custom indicator here
/// </summary>
/// <returns></returns>
public TrendBreaks TrendBreaks(Data.IDataSeries input, int maxLookBack, int minLookBack)
{
if (cacheTrendBreaks != null)
{
for (int idx = 0; idx < cacheTrendBreaks.Length; idx++)
{
if (cacheTrendBreaks[idx].MaxLookBack == maxLookBack && cacheTrendBreaks[idx].MinLookBack == minLookBack && cacheTrendBreaks[idx].EqualsInput(input))
{
return(cacheTrendBreaks[idx]);
}
}
}
lock (checkTrendBreaks)
{
checkTrendBreaks.MaxLookBack = maxLookBack;
maxLookBack = checkTrendBreaks.MaxLookBack;
checkTrendBreaks.MinLookBack = minLookBack;
minLookBack = checkTrendBreaks.MinLookBack;
if (cacheTrendBreaks != null)
{
for (int idx = 0; idx < cacheTrendBreaks.Length; idx++)
{
if (cacheTrendBreaks[idx].MaxLookBack == maxLookBack && cacheTrendBreaks[idx].MinLookBack == minLookBack && cacheTrendBreaks[idx].EqualsInput(input))
{
return(cacheTrendBreaks[idx]);
}
}
}
TrendBreaks indicator = new TrendBreaks();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.MaxLookBack = maxLookBack;
indicator.MinLookBack = minLookBack;
Indicators.Add(indicator);
indicator.SetUp();
TrendBreaks[] tmp = new TrendBreaks[cacheTrendBreaks == null ? 1 : cacheTrendBreaks.Length + 1];
if (cacheTrendBreaks != null)
{
cacheTrendBreaks.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheTrendBreaks = tmp;
return(indicator);
}
}
/// <summary>
/// Shows how perdictable the instrument trend
/// </summary>
/// <returns></returns>
public TrendPredictability TrendPredictability(Data.IDataSeries input, int maxConsecutiveBars, int period)
{
if (cacheTrendPredictability != null)
{
for (int idx = 0; idx < cacheTrendPredictability.Length; idx++)
{
if (cacheTrendPredictability[idx].MaxConsecutiveBars == maxConsecutiveBars && cacheTrendPredictability[idx].Period == period && cacheTrendPredictability[idx].EqualsInput(input))
{
return(cacheTrendPredictability[idx]);
}
}
}
lock (checkTrendPredictability)
{
checkTrendPredictability.MaxConsecutiveBars = maxConsecutiveBars;
maxConsecutiveBars = checkTrendPredictability.MaxConsecutiveBars;
checkTrendPredictability.Period = period;
period = checkTrendPredictability.Period;
if (cacheTrendPredictability != null)
{
for (int idx = 0; idx < cacheTrendPredictability.Length; idx++)
{
if (cacheTrendPredictability[idx].MaxConsecutiveBars == maxConsecutiveBars && cacheTrendPredictability[idx].Period == period && cacheTrendPredictability[idx].EqualsInput(input))
{
return(cacheTrendPredictability[idx]);
}
}
}
TrendPredictability indicator = new TrendPredictability();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.MaxConsecutiveBars = maxConsecutiveBars;
indicator.Period = period;
Indicators.Add(indicator);
indicator.SetUp();
TrendPredictability[] tmp = new TrendPredictability[cacheTrendPredictability == null ? 1 : cacheTrendPredictability.Length + 1];
if (cacheTrendPredictability != null)
{
cacheTrendPredictability.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheTrendPredictability = tmp;
return(indicator);
}
}
/// <summary>
/// Low Lag Moving Average
/// </summary>
/// <returns></returns>
public LLMA LLMA(Data.IDataSeries input, int length, double phase)
{
if (cacheLLMA != null)
{
for (int idx = 0; idx < cacheLLMA.Length; idx++)
{
if (cacheLLMA[idx].Length == length && Math.Abs(cacheLLMA[idx].Phase - phase) <= double.Epsilon && cacheLLMA[idx].EqualsInput(input))
{
return(cacheLLMA[idx]);
}
}
}
lock (checkLLMA)
{
checkLLMA.Length = length;
length = checkLLMA.Length;
checkLLMA.Phase = phase;
phase = checkLLMA.Phase;
if (cacheLLMA != null)
{
for (int idx = 0; idx < cacheLLMA.Length; idx++)
{
if (cacheLLMA[idx].Length == length && Math.Abs(cacheLLMA[idx].Phase - phase) <= double.Epsilon && cacheLLMA[idx].EqualsInput(input))
{
return(cacheLLMA[idx]);
}
}
}
LLMA indicator = new LLMA();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Length = length;
indicator.Phase = phase;
Indicators.Add(indicator);
indicator.SetUp();
LLMA[] tmp = new LLMA[cacheLLMA == null ? 1 : cacheLLMA.Length + 1];
if (cacheLLMA != null)
{
cacheLLMA.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheLLMA = tmp;
return(indicator);
}
}
/// <summary>
/// A signal on ACD return 1, if signal true
/// </summary>
/// <returns></returns>
public ZZACD00Asignal ZZACD00Asignal(Data.IDataSeries input, int numBarAsignal, int oRNumBars)
{
if (cacheZZACD00Asignal != null)
{
for (int idx = 0; idx < cacheZZACD00Asignal.Length; idx++)
{
if (cacheZZACD00Asignal[idx].NumBarAsignal == numBarAsignal && cacheZZACD00Asignal[idx].ORNumBars == oRNumBars && cacheZZACD00Asignal[idx].EqualsInput(input))
{
return(cacheZZACD00Asignal[idx]);
}
}
}
lock (checkZZACD00Asignal)
{
checkZZACD00Asignal.NumBarAsignal = numBarAsignal;
numBarAsignal = checkZZACD00Asignal.NumBarAsignal;
checkZZACD00Asignal.ORNumBars = oRNumBars;
oRNumBars = checkZZACD00Asignal.ORNumBars;
if (cacheZZACD00Asignal != null)
{
for (int idx = 0; idx < cacheZZACD00Asignal.Length; idx++)
{
if (cacheZZACD00Asignal[idx].NumBarAsignal == numBarAsignal && cacheZZACD00Asignal[idx].ORNumBars == oRNumBars && cacheZZACD00Asignal[idx].EqualsInput(input))
{
return(cacheZZACD00Asignal[idx]);
}
}
}
ZZACD00Asignal indicator = new ZZACD00Asignal();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.NumBarAsignal = numBarAsignal;
indicator.ORNumBars = oRNumBars;
Indicators.Add(indicator);
indicator.SetUp();
ZZACD00Asignal[] tmp = new ZZACD00Asignal[cacheZZACD00Asignal == null ? 1 : cacheZZACD00Asignal.Length + 1];
if (cacheZZACD00Asignal != null)
{
cacheZZACD00Asignal.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheZZACD00Asignal = tmp;
return(indicator);
}
}
/// <summary>
/// Alert on any pullback met requirment of AS
/// </summary>
/// <returns></returns>
public AlertPullbacks AlertPullbacks(Data.IDataSeries input, bool useMACD, bool useMomentum)
{
if (cacheAlertPullbacks != null)
{
for (int idx = 0; idx < cacheAlertPullbacks.Length; idx++)
{
if (cacheAlertPullbacks[idx].UseMACD == useMACD && cacheAlertPullbacks[idx].UseMomentum == useMomentum && cacheAlertPullbacks[idx].EqualsInput(input))
{
return(cacheAlertPullbacks[idx]);
}
}
}
lock (checkAlertPullbacks)
{
checkAlertPullbacks.UseMACD = useMACD;
useMACD = checkAlertPullbacks.UseMACD;
checkAlertPullbacks.UseMomentum = useMomentum;
useMomentum = checkAlertPullbacks.UseMomentum;
if (cacheAlertPullbacks != null)
{
for (int idx = 0; idx < cacheAlertPullbacks.Length; idx++)
{
if (cacheAlertPullbacks[idx].UseMACD == useMACD && cacheAlertPullbacks[idx].UseMomentum == useMomentum && cacheAlertPullbacks[idx].EqualsInput(input))
{
return(cacheAlertPullbacks[idx]);
}
}
}
AlertPullbacks indicator = new AlertPullbacks();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.UseMACD = useMACD;
indicator.UseMomentum = useMomentum;
Indicators.Add(indicator);
indicator.SetUp();
AlertPullbacks[] tmp = new AlertPullbacks[cacheAlertPullbacks == null ? 1 : cacheAlertPullbacks.Length + 1];
if (cacheAlertPullbacks != null)
{
cacheAlertPullbacks.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheAlertPullbacks = tmp;
return(indicator);
}
}
