public string ToString(IFormatProvider provider)
{
AverageType avgType = GetAverageInfo(provider).TypeOfAverage;
return(String.Format("( {0}: {1:G10} )", avgType,
Average(avgType)));
}
public bool ReadNoise(long frequency, long bandWidth, long span, long band, bool isManualSWP, double ManualSWP)
{
AverageType averageType = AverageType.Off;
if (Experiment.ExperimentSettings.AverageTypeForNoiseOff)
{
averageType = AverageType.Off;
}
if (Experiment.ExperimentSettings.AverageTypeForNoiseMinimum)
{
averageType = AverageType.Minimum;
}
if (Experiment.ExperimentSettings.AverageTypeForNoiseMiddle)
{
averageType = AverageType.Middle;
}
if (Experiment.ExperimentSettings.AverageTypeForNoiseMaximum)
{
averageType = AverageType.Maximum;
}
return(Read(frequency, bandWidth, span, band,
Experiment.ExperimentSettings.HardwareSettings.NoiseTraceDetector,
averageType,
Experiment.ExperimentSettings.HardwareSettings.PointsQuantity,
Experiment.ExperimentSettings.MeasurementCountForNoise,
Experiment.ExperimentSettings.HardwareSettings.NoiseTraceType,
Experiment.ExperimentSettings.HardwareSettings.NoiseAttenuation,
Experiment.ExperimentSettings.HardwareSettings.CountNoiseTraceMode,
isManualSWP,
ManualSWP));
}
public static void SetErRateAverageType(this IEnumerable <Player> players, AverageType type)
{
foreach (var player in players)
{
player.ErRateAverageType = type;
}
}
public bool ReadNoise(long frequency, long bandWidth, long span, long band)
{
AverageType averageType = AverageType.Off;
if (Experiment.ExperimentSettings.AverageTypeForNoiseOff)
{
averageType = AverageType.Off;
}
if (Experiment.ExperimentSettings.AverageTypeForNoiseMinimum)
{
averageType = AverageType.Minimum;
}
if (Experiment.ExperimentSettings.AverageTypeForNoiseMiddle)
{
averageType = AverageType.Middle;
}
if (Experiment.ExperimentSettings.AverageTypeForNoiseMaximum)
{
averageType = AverageType.Maximum;
}
return(Read(frequency, bandWidth, span, band,
Experiment.ExperimentSettings.HardwareSettings.TraceModeForNoise,
averageType,
Experiment.ExperimentSettings.HardwareSettings.PointsQuantity,
Experiment.ExperimentSettings.MeasurementCountForNoise));
}
/// <summary>
/// Used to filter whipsawed markets out. When noise line (blue) is above signal line (green) even trading ranges strategies will have poor performance - by Luis Guilherme Damiani.
/// </summary>
/// <returns></returns>
public Indicator.DamianiVolatmeter DamianiVolatmeter(Data.IDataSeries input, AverageType averageType, bool lagsupressor, int sedAtr, int sedStd, double thresholdLevel, int visAtr, int visStd)
{
if (InInitialize && input == null)
{
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");
}
return(_indicator.DamianiVolatmeter(input, averageType, lagsupressor, sedAtr, sedStd, thresholdLevel, visAtr, visStd));
}
public bool Read(long frequency, long bandWidth, long span, long band,
string traceDetector,
AverageType averageType,
int pointsQuantity,
int measurementCount)
{
Reader.HardwareSettings.Frequency = frequency;
Reader.HardwareSettings.BandWidth = bandWidth;
Reader.HardwareSettings.Span = span;
Reader.HardwareSettings.Band = band;
Reader.HardwareSettings.TraceDetector = traceDetector;
Reader.HardwareSettings.AverageType = averageType;
Reader.HardwareSettings.PointsQuantity = pointsQuantity;
Reader.HardwareSettings.MeasurementCount = measurementCount;
ResultsX = new double[Reader.HardwareSettings.PointsQuantity];
ResultsY = new double[Reader.HardwareSettings.PointsQuantity];
if (Emulation)
{
for (int counter = 0; counter < Reader.HardwareSettings.PointsQuantity; counter++)
{
ResultsX[counter] = counter;
ResultsY[counter] = Math.Sin(counter) * 30;
}
ResultsY[0] = 30;
ResultsY[10] = 35;
ResultsY[20] = 40;
ResultsY[40] = 45;
ResultsY[60] = 40;
ResultsY[70] = 35;
ResultsY[80] = 30;
NewData?.Invoke(ResultsX, ResultsY);
return(true);
}
else
if (Reader.GetDataPoints())
{
ResultsX = Reader.ResultsX.ToArray();
ResultsY = Reader.ResultsY.ToArray();
for (int counter = 0; counter < Reader.HardwareSettings.PointsQuantity; counter++)
{
if (ResultsY[counter] == 0)
{
ResultsY[counter] = 0.001;
}
}
NewData?.Invoke(ResultsX, ResultsY);
return(true);
}
return(false);
}
protected override string GetUrl(AverageType averageType)
{
if (averageType == AverageType.Week)
{
return(WeekUrl);
}
else
{
return(DayUrl);
}
}
// This method calculates the average of the object's elements.
protected double Average(AverageType avgType)
{
double SumProd;
if (data.Count == 0)
{
return(0.0);
}
switch (avgType)
{
case AverageType.GeometricMean:
SumProd = 1.0;
for (int Index = 0; Index < data.Count; Index++)
{
SumProd *= (double)data[Index];
}
// This calculation will not fail with negative
// elements.
return(Math.Sign(SumProd) * Math.Pow(
Math.Abs(SumProd), 1.0 / data.Count));
case AverageType.ArithmeticMean:
SumProd = 0.0;
for (int Index = 0; Index < data.Count; Index++)
{
SumProd += (double)data[Index];
}
return(SumProd / data.Count);
case AverageType.Median:
if (data.Count % 2 == 0)
{
return(((double)data[data.Count / 2] +
(double)data[data.Count / 2 - 1]) / 2.0);
}
else
{
return((double)data[data.Count / 2]);
}
default:
return(0.0);
}
}
public decimal Average(AverageType averageType, IEnumerable <decimal> values, int round, int lastToTake = 0)
{
var priceValues = values;
if (averageType == AverageType.WITHOUT_CURRENT && values.Count() > 1)
{
priceValues = values.SkipLast(1);
}
decimal result = lastToTake == 0
? priceValues.Average()
: priceValues.Count() > lastToTake?priceValues.TakeLast(lastToTake).Average() : priceValues.Average();
return(decimal.Round(result, round));
}
public double MyStdDev(IDataSeries price, int p, AverageType at)
{
double avg;
switch (at)
{
case AverageType.EMA: avg = EMA(price, p)[0]; break;
case AverageType.SMA: avg = SMA(price, p)[0]; break;
case AverageType.HMA: avg = HMA(price, p)[0]; break;
case AverageType.LinReg: avg = LinReg(price, p)[0]; break;
case AverageType.VOLMA: avg = VOLMA(price, p)[0]; break;
case AverageType.ATR: avg = 1000 * ATR(price, p)[0]; break;
case AverageType.StdDev: avg = 1000 * StdDev(price, p)[0]; break;
case AverageType.CCI: avg = CCI(price, p)[0]; break;
case AverageType.RSI: avg = RSI(price, p, 3)[0]; break;
case AverageType.ROC: avg = ROC(price, p)[0]; break;
default: avg = WMA(price, p)[0]; break;
}
double sum = 0;
for (int barsBack = Math.Min(CurrentBar, p - 1); barsBack >= 0; barsBack--)
{
sum += (price[barsBack] - avg) * (price[barsBack] - avg);
}
return(Math.Sqrt(sum / Math.Min(CurrentBar + 1, p)));
}
private static double Average(IEnumerable <double> c, AverageType atype)
{
List <double> g = new List <double>();
foreach (double f in c)
{
if (!double.IsNaN(f) && !double.IsInfinity(f))
{
g.Add(f);
}
}
if (g.Count == 0)
{
return(double.NaN);
}
switch (atype)
{
case AverageType.Mean:
return(ArrayUtils.Mean(g));
case AverageType.Maximum:
return(ArrayUtils.Max(g));
case AverageType.Median:
return(ArrayUtils.Median(g));
case AverageType.Minimum:
return(ArrayUtils.Min(g));
case AverageType.Sum:
return(ArrayUtils.Sum(g));
default:
throw new Exception("Never get here.");
}
}
public static float GetAverage(this List <float> list, AverageType averageType = AverageType.Mean)
{
return(list.GetAverage(num => num, averageType));
}
public static float GetAverage <T>(this T[] list, System.Func <T, float> property, AverageType averageType = AverageType.Mean)
{
List <T> listConverted = list.ToList <T>();
return(listConverted.GetAverage <T>(property, averageType));
}
public static float GetAverage <T>(this List <T> list, System.Func <T, float> property, AverageType averageType = AverageType.Mean)
{
if (averageType == AverageType.Least)
{
return(list.Min(property));
}
else if (averageType == AverageType.Greatest)
{
return(list.Max(property));
}
else if (averageType == AverageType.Mean)
{
return(list.Average(property));
}
else if (averageType == AverageType.Median)
{
list = list.OrderBy(property).ToList <T>();
if (RMath.Odd(list.Count))
{
//++++++++++++NEEDS TO BE FIXED
//USE System.Func on induvidual value to get property
return(property(list[(int)(Mathf.Ceil(list.Count / 2f) - 1)]));
}
else if (RMath.Even(list.Count))
{
return((
property(list[(list.Count / 2) - 1]) +
property(list[(list.Count / 2) + 1 - 1])
) / 2f);
}
}
else if (averageType == AverageType.Mode)
{
Dictionary <float, int> ocurrances = new Dictionary <float, int>();
foreach (T i in list)
{
if (ocurrances.ContainsKey(property(i)))
{
ocurrances[property(i)] = ocurrances[property(i)] + 1;
}
else
{
ocurrances[property(i)] = 1;
}
}
return(list.Max((f) => ocurrances[property(f)]));
}
else if (averageType == AverageType.Range)
{
return(list.Max(property) - list.Min(property));
}
else if (averageType == AverageType.MidRange)
{
return((list.Min(property) + list.Max(property)) / 2f);
}
return(1f);
}
/// <summary>
/// Used to filter whipsawed markets out. When noise line (blue) is above signal line (green) even trading ranges strategies will have poor performance - by Luis Guilherme Damiani.
/// </summary>
/// <returns></returns>
public Indicator.DamianiVolatmeter DamianiVolatmeter(Data.IDataSeries input, AverageType averageType, bool lagsupressor, int sedAtr, int sedStd, double thresholdLevel, int visAtr, int visStd)
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");
return _indicator.DamianiVolatmeter(input, averageType, lagsupressor, sedAtr, sedStd, thresholdLevel, visAtr, visStd);
}
public Indicator.DamianiVolatmeter DamianiVolatmeter(AverageType averageType, bool lagsupressor, int sedAtr, int sedStd, double thresholdLevel, int visAtr, int visStd)
{
return _indicator.DamianiVolatmeter(Input, averageType, lagsupressor, sedAtr, sedStd, thresholdLevel, visAtr, visStd);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
bool keepEmpty = param.GetParam <bool>("Keep rows without ID").Value;
AverageType atype = GetAverageType(param.GetParam <int>("Average type for expression columns").Value);
string[] ids2 = mdata.StringColumns[param.GetParam <int>("ID column").Value];
string[][] ids = SplitIds(ids2);
int[] present;
int[] absent;
GetPresentAbsentIndices(ids, out present, out absent);
ids = ArrayUtils.SubArray(ids, present);
int[][] rowInds = new int[present.Length][];
for (int i = 0; i < rowInds.Length; i++)
{
rowInds[i] = new[] { present[i] };
}
ClusterRows(ref rowInds, ref ids);
if (keepEmpty)
{
rowInds = ProlongRowInds(rowInds, absent);
}
int nrows = rowInds.Length;
int ncols = mdata.ColumnCount;
float[,] expVals = new float[nrows, ncols];
for (int j = 0; j < ncols; j++)
{
double[] c = ArrayUtils.ToDoubles(mdata.Values.GetColumn(j));
for (int i = 0; i < nrows; i++)
{
double[] d = ArrayUtils.SubArray(c, rowInds[i]);
expVals[i, j] = (float)Average(d, atype);
}
}
mdata.Values.Set(expVals);
for (int i = 0; i < mdata.NumericColumnCount; i++)
{
string name = mdata.NumericColumnNames[i];
AverageType atype1 = GetAverageType(param.GetParam <int>("Average type for " + name).Value);
double[] c = mdata.NumericColumns[i];
double[] newCol = new double[nrows];
for (int k = 0; k < nrows; k++)
{
double[] d = ArrayUtils.SubArray(c, rowInds[k]);
newCol[k] = Average(d, atype1);
}
mdata.NumericColumns[i] = newCol;
}
for (int i = 0; i < mdata.CategoryColumnCount; i++)
{
string[][] c = mdata.GetCategoryColumnAt(i);
string[][] newCol = new string[nrows][];
for (int k = 0; k < nrows; k++)
{
string[][] d = ArrayUtils.SubArray(c, rowInds[k]);
newCol[k] = Average(d);
}
mdata.SetCategoryColumnAt(newCol, i);
}
for (int i = 0; i < mdata.StringColumnCount; i++)
{
string[] c = mdata.StringColumns[i];
string[] newCol = new string[nrows];
for (int k = 0; k < nrows; k++)
{
string[] d = ArrayUtils.SubArray(c, rowInds[k]);
newCol[k] = Average(d);
}
mdata.StringColumns[i] = newCol;
}
for (int i = 0; i < mdata.MultiNumericColumnCount; i++)
{
double[][] c = mdata.MultiNumericColumns[i];
double[][] newCol = new double[nrows][];
for (int k = 0; k < nrows; k++)
{
double[][] d = ArrayUtils.SubArray(c, rowInds[k]);
newCol[k] = Average(d);
}
mdata.MultiNumericColumns[i] = newCol;
}
}
// Specify the type of averaging in the constructor.
public AverageInfo(AverageType avgType)
{
this.AvgType = avgType;
}
/// <summary> /// 產品指數來源網址 /// </summary> /// <returns></returns> protected abstract string GetUrl(AverageType averageType);
public StockPerf[] GetStockPerfData(string symbol, PerfScale scale, AverageType averageType, int length)
{
string url = String.Format(SINA_HISTORICAL_DATA_URL, symbol, (int)scale, (int)averageType, length);
return(this.SendRequest <StockPerf[]>(url, HttpMethod.GET, String.Empty));
}
public AverageTimeEventArgs(AverageType averageType)
{
Type = averageType;
}
public async Task <List <DataPoint> > ListProductIndexTaskAsync(string productName, AverageType averageType)
{
DateTime end = DateTime.Now;
DateTime start = end.AddYears(-5);
return(await ListProductIndexTaskAsync(productName, start, end, averageType));
}
public Indicator.DamianiVolatmeter DamianiVolatmeter(AverageType averageType, bool lagsupressor, int sedAtr, int sedStd, double thresholdLevel, int visAtr, int visStd)
{
return(_indicator.DamianiVolatmeter(Input, averageType, lagsupressor, sedAtr, sedStd, thresholdLevel, visAtr, visStd));
}
/// <summary>
/// Used to filter whipsawed markets out. When noise line (blue) is above signal line (green) even trading ranges strategies will have poor performance - by Luis Guilherme Damiani.
/// </summary>
/// <returns></returns>
public DamianiVolatmeter DamianiVolatmeter(Data.IDataSeries input, AverageType averageType, bool lagsupressor, int sedAtr, int sedStd, double thresholdLevel, int visAtr, int visStd)
{
if (cacheDamianiVolatmeter != null)
{
for (int idx = 0; idx < cacheDamianiVolatmeter.Length; idx++)
{
if (cacheDamianiVolatmeter[idx].AverageType == averageType && cacheDamianiVolatmeter[idx].Lagsupressor == lagsupressor && cacheDamianiVolatmeter[idx].SedAtr == sedAtr && cacheDamianiVolatmeter[idx].SedStd == sedStd && Math.Abs(cacheDamianiVolatmeter[idx].ThresholdLevel - thresholdLevel) <= double.Epsilon && cacheDamianiVolatmeter[idx].VisAtr == visAtr && cacheDamianiVolatmeter[idx].VisStd == visStd && cacheDamianiVolatmeter[idx].EqualsInput(input))
{
return(cacheDamianiVolatmeter[idx]);
}
}
}
lock (checkDamianiVolatmeter)
{
checkDamianiVolatmeter.AverageType = averageType;
averageType = checkDamianiVolatmeter.AverageType;
checkDamianiVolatmeter.Lagsupressor = lagsupressor;
lagsupressor = checkDamianiVolatmeter.Lagsupressor;
checkDamianiVolatmeter.SedAtr = sedAtr;
sedAtr = checkDamianiVolatmeter.SedAtr;
checkDamianiVolatmeter.SedStd = sedStd;
sedStd = checkDamianiVolatmeter.SedStd;
checkDamianiVolatmeter.ThresholdLevel = thresholdLevel;
thresholdLevel = checkDamianiVolatmeter.ThresholdLevel;
checkDamianiVolatmeter.VisAtr = visAtr;
visAtr = checkDamianiVolatmeter.VisAtr;
checkDamianiVolatmeter.VisStd = visStd;
visStd = checkDamianiVolatmeter.VisStd;
if (cacheDamianiVolatmeter != null)
{
for (int idx = 0; idx < cacheDamianiVolatmeter.Length; idx++)
{
if (cacheDamianiVolatmeter[idx].AverageType == averageType && cacheDamianiVolatmeter[idx].Lagsupressor == lagsupressor && cacheDamianiVolatmeter[idx].SedAtr == sedAtr && cacheDamianiVolatmeter[idx].SedStd == sedStd && Math.Abs(cacheDamianiVolatmeter[idx].ThresholdLevel - thresholdLevel) <= double.Epsilon && cacheDamianiVolatmeter[idx].VisAtr == visAtr && cacheDamianiVolatmeter[idx].VisStd == visStd && cacheDamianiVolatmeter[idx].EqualsInput(input))
{
return(cacheDamianiVolatmeter[idx]);
}
}
}
DamianiVolatmeter indicator = new DamianiVolatmeter();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.AverageType = averageType;
indicator.Lagsupressor = lagsupressor;
indicator.SedAtr = sedAtr;
indicator.SedStd = sedStd;
indicator.ThresholdLevel = thresholdLevel;
indicator.VisAtr = visAtr;
indicator.VisStd = visStd;
Indicators.Add(indicator);
indicator.SetUp();
DamianiVolatmeter[] tmp = new DamianiVolatmeter[cacheDamianiVolatmeter == null ? 1 : cacheDamianiVolatmeter.Length + 1];
if (cacheDamianiVolatmeter != null)
{
cacheDamianiVolatmeter.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheDamianiVolatmeter = tmp;
return(indicator);
}
}
private static float Average(IEnumerable<float> c, AverageType atype)
{
List<float> g = new List<float>();
foreach (float f in c){
if (!float.IsNaN(f) && !float.IsInfinity(f)){
g.Add(f);
}
}
if (g.Count == 0){
return float.NaN;
}
switch (atype){
case AverageType.Mean:
return (float) ArrayUtils.Mean(g);
case AverageType.Maximum:
return ArrayUtils.Max(g);
case AverageType.Median:
return ArrayUtils.Median(g);
case AverageType.Minimum:
return ArrayUtils.Min(g);
case AverageType.Sum:
return (float) ArrayUtils.Sum(g);
default:
throw new Exception("Never get here.");
}
}
public static float GetAverage(this float[] list, AverageType averageType = AverageType.Mean)
{
return(list.ToList().GetAverage(num => num, averageType));
}
public virtual async Task <List <DataPoint> > GetHistoricalReportTaskAsync(DateTime start, DateTime end, AverageType averageType = AverageType.Day)
{
string prodcutUrl = GetUrl(averageType);
string result = await RestApi.GetHtmlTaskAsync(GetUrl(averageType));
return(ProcessData(result));
}
public double MyStdDev(IDataSeries price, int p, AverageType at)
{
double avg;
switch (at)
{
case AverageType.EMA : avg = EMA(price, p)[0]; break;
case AverageType.SMA : avg = SMA(price, p)[0]; break;
case AverageType.HMA : avg = HMA(price, p)[0]; break;
case AverageType.LinReg : avg = LinReg(price, p)[0]; break;
case AverageType.VOLMA : avg = VOLMA(price, p)[0]; break;
case AverageType.ATR : avg = 1000 * ATR(price, p)[0]; break;
case AverageType.StdDev : avg = 1000 * StdDev(price, p)[0]; break;
case AverageType.CCI : avg = CCI(price, p)[0]; break;
case AverageType.RSI : avg = RSI(price, p, 3)[0]; break;
case AverageType.ROC : avg = ROC(price, p)[0]; break;
default : avg = WMA(price, p)[0]; break;
}
double sum = 0;
for (int barsBack = Math.Min(CurrentBar, p - 1); barsBack >= 0; barsBack--)
sum += (price[barsBack] - avg) * (price[barsBack] - avg);
return (Math.Sqrt(sum / Math.Min(CurrentBar + 1, p)));
}
public async Task <List <DataPoint> > ListProductIndexTaskAsync(string productName, DateTime start, DateTime end, AverageType averageType)
{
try
{
var productIndex = await ProductFactory.GetProductIndexTaskAsync(productName);
var resultIndexList = await productIndex.GetHistoricalReportTaskAsync(start, end, averageType);
return(resultIndexList);
}
catch (Exception e)
{
throw new Exception(string.Format(AppResources.Exception_QueryProductRepotError, productName, e.Message));
}
}
/// <summary>
/// Used to filter whipsawed markets out. When noise line (blue) is above signal line (green) even trading ranges strategies will have poor performance - by Luis Guilherme Damiani.
/// </summary>
/// <returns></returns>
public DamianiVolatmeter DamianiVolatmeter(Data.IDataSeries input, AverageType averageType, bool lagsupressor, int sedAtr, int sedStd, double thresholdLevel, int visAtr, int visStd)
{
if (cacheDamianiVolatmeter != null)
for (int idx = 0; idx < cacheDamianiVolatmeter.Length; idx++)
if (cacheDamianiVolatmeter[idx].AverageType == averageType && cacheDamianiVolatmeter[idx].Lagsupressor == lagsupressor && cacheDamianiVolatmeter[idx].SedAtr == sedAtr && cacheDamianiVolatmeter[idx].SedStd == sedStd && Math.Abs(cacheDamianiVolatmeter[idx].ThresholdLevel - thresholdLevel) <= double.Epsilon && cacheDamianiVolatmeter[idx].VisAtr == visAtr && cacheDamianiVolatmeter[idx].VisStd == visStd && cacheDamianiVolatmeter[idx].EqualsInput(input))
return cacheDamianiVolatmeter[idx];
lock (checkDamianiVolatmeter)
{
checkDamianiVolatmeter.AverageType = averageType;
averageType = checkDamianiVolatmeter.AverageType;
checkDamianiVolatmeter.Lagsupressor = lagsupressor;
lagsupressor = checkDamianiVolatmeter.Lagsupressor;
checkDamianiVolatmeter.SedAtr = sedAtr;
sedAtr = checkDamianiVolatmeter.SedAtr;
checkDamianiVolatmeter.SedStd = sedStd;
sedStd = checkDamianiVolatmeter.SedStd;
checkDamianiVolatmeter.ThresholdLevel = thresholdLevel;
thresholdLevel = checkDamianiVolatmeter.ThresholdLevel;
checkDamianiVolatmeter.VisAtr = visAtr;
visAtr = checkDamianiVolatmeter.VisAtr;
checkDamianiVolatmeter.VisStd = visStd;
visStd = checkDamianiVolatmeter.VisStd;
if (cacheDamianiVolatmeter != null)
for (int idx = 0; idx < cacheDamianiVolatmeter.Length; idx++)
if (cacheDamianiVolatmeter[idx].AverageType == averageType && cacheDamianiVolatmeter[idx].Lagsupressor == lagsupressor && cacheDamianiVolatmeter[idx].SedAtr == sedAtr && cacheDamianiVolatmeter[idx].SedStd == sedStd && Math.Abs(cacheDamianiVolatmeter[idx].ThresholdLevel - thresholdLevel) <= double.Epsilon && cacheDamianiVolatmeter[idx].VisAtr == visAtr && cacheDamianiVolatmeter[idx].VisStd == visStd && cacheDamianiVolatmeter[idx].EqualsInput(input))
return cacheDamianiVolatmeter[idx];
DamianiVolatmeter indicator = new DamianiVolatmeter();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.AverageType = averageType;
indicator.Lagsupressor = lagsupressor;
indicator.SedAtr = sedAtr;
indicator.SedStd = sedStd;
indicator.ThresholdLevel = thresholdLevel;
indicator.VisAtr = visAtr;
indicator.VisStd = visStd;
Indicators.Add(indicator);
indicator.SetUp();
DamianiVolatmeter[] tmp = new DamianiVolatmeter[cacheDamianiVolatmeter == null ? 1 : cacheDamianiVolatmeter.Length + 1];
if (cacheDamianiVolatmeter != null)
cacheDamianiVolatmeter.CopyTo(tmp, 0);
tmp[tmp.Length - 1] = indicator;
cacheDamianiVolatmeter = tmp;
return indicator;
}
}
