public void Tolerance()
{
// given
IList <double> list1 = new List <double>()
{
1, 2, 3, 3, 1, 2, 5, 5, 5, 2, 1, 3, 3, 2, 1
};
IList <double> list4 = new List <double>()
{
10, 100, 1000
};
IList <IList <double> > list5 = new List <IList <double> >()
{
list1, list4
};
double classifier1 = 2.0;
double classifier4 = 11.0;
double tolerance5 = 0.1;
MeansParameters params4 = new MeansParameters();
params4.Harmonic.Variant = StandardMeanVariants.Straight;
double expected1 = 3.0;
double expected2 = 1.0;
double expected3 = 2.0;
double expected4 = list4[1];
IList <double> expected5 = new List <double>()
{
list1.Max(), list4[1]
};
// when
double result1 = Averages.Tolerance(list1, classifier1, MeanType.Maximum).Value;
double result2 = Averages.Tolerance(list1, classifier1, MeanType.Minimum).Value;
double result3 = Averages.Tolerance(list1, classifier1, MeanType.Arithmetic).Value;
double result4 = Averages.Tolerance(list4, classifier4, MeanType.Harmonic, params4).Value;
IList <double> result5 = Averages.Tolerance(list5, tolerance5, MeanType.Maximum);
// then
Assert.AreEqual(expected1, result1, Assertions.IBM_FLOAT_SURROUNDING);
Assert.AreEqual(expected2, result2, Assertions.IBM_FLOAT_SURROUNDING);
Assert.AreEqual(expected3, result3, Assertions.IBM_FLOAT_SURROUNDING);
Assert.AreEqual(expected4, result4, Assertions.IBM_FLOAT_SURROUNDING);
Assertions.SameValues(expected5, result5);
}
public bool?TryMakeAverageCurve(MeanType method, int curvesNo)
{
if (curvesNo < 0)
{
return(null);
}
string signature = string.Empty;
IList <double> result = new List <double>();
try {
signature = MethodBase.GetCurrentMethod().Name + '(' + method + ',' + curvesNo + ')';
IList <IList <double> > orderedSetOfCurves = SeriesAssist.GetOrderedCopy(ModifiedCurves, curvesNo);
switch (method)
{
case MeanType.Median:
result = Averages.Median(orderedSetOfCurves);
break;
case MeanType.Maximum:
result = Averages.Maximum(orderedSetOfCurves);
break;
case MeanType.Minimum:
result = Averages.Minimum(orderedSetOfCurves);
break;
case MeanType.Arithmetic:
result = Averages.Arithmetic(orderedSetOfCurves);
break;
case MeanType.Geometric:
result = Averages.Geometric(orderedSetOfCurves, MeansParams.Geometric.Variant);
break;
case MeanType.AGM:
result = Averages.AGM(orderedSetOfCurves, MeansParams.AGM.Variant);
break;
case MeanType.Heronian:
result = Averages.Heronian(orderedSetOfCurves, MeansParams.Heronian.Variant);
break;
case MeanType.Harmonic:
result = Averages.Harmonic(orderedSetOfCurves, MeansParams.Harmonic.Variant);
break;
case MeanType.Generalized:
result = Averages.Generalized(orderedSetOfCurves, MeansParams.Generalized.Variant, MeansParams.Generalized.Rank);
break;
case MeanType.SMA:
result = Averages.SMA(orderedSetOfCurves);
break;
case MeanType.Tolerance:
result = Averages.Tolerance(orderedSetOfCurves, MeansParams.Tolerance.Tolerance, MeansParams.Tolerance.Finisher);
break;
case MeanType.Central:
result = Averages.Central(orderedSetOfCurves, MeansParams.Central.MassPercent);
break;
case MeanType.NN:
result = Smoothers.NearestNeighbors(orderedSetOfCurves, MeansParams.NN.Amount);
break;
case MeanType.NadarayaWatson:
result = Smoothers.NadarayaWatson(orderedSetOfCurves, MeansParams.NadarayaWatson.Variant, MeansParams.NadarayaWatson.KernelType, MeansParams.NadarayaWatson.KernelSize);
break;
}
}
catch (ArgumentOutOfRangeException ex) {
log.Error(signature, ex);
return(false);
}
catch (OverflowException ex) {
log.Error(signature, ex);
return(false);
}
catch (InvalidOperationException ex) {
log.Error(signature, ex);
return(false);
}
catch (Exception ex) {
log.Fatal(signature, ex);
return(false);
}
AverageCurve.Points.Clear();
SeriesAssist.CopyPoints(AverageCurve, IdealCurve, result);
return(SeriesAssist.IsChartAcceptable(AverageCurve));
}
