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; } }