Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/30/11 18:04:03 (13 years ago)
Author:
gkronber
Message:

#1453: Added an ErrorState property to online evaluators to indicate if the result value is valid or if there has been an error in the calculation. Adapted all classes that use one of the online evaluators to check this property.

Location:
trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs

    r5809 r5894  
    8585      IEnumerable<double> originalTestClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
    8686
    87       double trainingAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTrainingClassValues, originalTrainingClassValues);
    88       double testAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTestClassValues, originalTestClassValues);
     87      OnlineEvaluatorError errorState;
     88      double trainingAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTrainingClassValues, originalTrainingClassValues, out errorState);
     89      if (errorState != OnlineEvaluatorError.None) trainingAccuracy = double.NaN;
     90      double testAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTestClassValues, originalTestClassValues, out errorState);
     91      if (errorState != OnlineEvaluatorError.None) testAccuracy = double.NaN;
    8992
    9093      TrainingAccuracy = trainingAccuracy;

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs

    r5889 r5894  
    105105      IEnumerable<double> originalTestValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
    106106
    107       double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
    108       double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
    109       double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
    110       double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues);
     107      OnlineEvaluatorError errorState;
     108      double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
     109      TrainingMeanSquaredError = errorState == OnlineEvaluatorError.None ? trainingMSE : double.NaN;
     110      double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
     111      TestMeanSquaredError = errorState == OnlineEvaluatorError.None ? testMSE : double.NaN;
    111112
    112       TrainingMeanSquaredError = trainingMSE;
    113       TestMeanSquaredError = testMSE;
    114       TrainingRSquared = trainingR2;
    115       TestRSquared = testR2;
     113      double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
     114      TrainingRSquared = errorState == OnlineEvaluatorError.None ? trainingR2 : double.NaN;
     115      double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
     116      TestRSquared = errorState == OnlineEvaluatorError.None ? testR2 : double.NaN;
    116117    }
    117118

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/NormalDistributionCutPointsThresholdCalculator.cs

    r5849 r5894  
    6464        double classValue = group.Key;
    6565        double mean, variance;
    66         OnlineMeanAndVarianceCalculator.Calculate(estimatedClassValues, out mean, out variance);
    67         classMean[classValue] = mean;
    68         classStdDev[classValue] = Math.Sqrt(variance);
     66        OnlineEvaluatorError meanErrorState, varianceErrorState;
     67        OnlineMeanAndVarianceCalculator.Calculate(estimatedClassValues, out mean, out variance, out meanErrorState, out varianceErrorState);
     68
     69        if (meanErrorState == OnlineEvaluatorError.None && varianceErrorState == OnlineEvaluatorError.None) {
     70          classMean[classValue] = mean;
     71          classStdDev[classValue] = Math.Sqrt(variance);
     72        }
    6973      }
    7074      double[] originalClasses = classMean.Keys.OrderBy(x => x).ToArray();

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs

    r5809 r5894  
    114114      IEnumerable<double> originalTestValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
    115115
    116       double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
    117       double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
    118       double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
    119       double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues);
    120       double trainingRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
    121       double testRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
     116      OnlineEvaluatorError errorState;
     117      double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
     118      TrainingMeanSquaredError = errorState == OnlineEvaluatorError.None ? trainingMSE : double.NaN;
     119      double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
     120      TestMeanSquaredError = errorState == OnlineEvaluatorError.None ? testMSE : double.NaN;
    122121
    123       TrainingMeanSquaredError = trainingMSE;
    124       TestMeanSquaredError = testMSE;
    125       TrainingRSquared = trainingR2;
    126       TestRSquared = testR2;
    127       TrainingRelativeError = trainingRelError;
    128       TestRelativeError = testRelError;
     122      double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
     123      TrainingRSquared = errorState == OnlineEvaluatorError.None ? trainingR2 : double.NaN;
     124      double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
     125      TestRSquared = errorState == OnlineEvaluatorError.None ? testR2 : double.NaN;
     126
     127      double trainingRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
     128      TrainingRelativeError = errorState == OnlineEvaluatorError.None ? trainingRelError : double.NaN;
     129      double testRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
     130      TestRelativeError = errorState == OnlineEvaluatorError.None ? testRelError : double.NaN;
    129131    }
    130132

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineEvaluator.cs

    r5809 r5894  
    2121
    2222
     23using System;
    2324namespace HeuristicLab.Problems.DataAnalysis {
     25  [Flags]
     26  public enum OnlineEvaluatorError {
     27    /// <summary>
     28    /// No error occurred
     29    /// </summary>
     30    None = 0,
     31    /// <summary>
     32    /// An invalid value has been added (often +/- Infinity and NaN are invalid values)
     33    /// </summary>
     34    InvalidValueAdded = 1,
     35    /// <summary>
     36    /// The number of elements added to the evaluator is not sufficient to calculate the result value
     37    /// </summary>
     38    InsufficientElementsAdded = 2
     39  }
    2440  public interface IOnlineEvaluator {
     41    OnlineEvaluatorError ErrorState { get; }
    2542    double Value { get; }
    2643    void Reset();

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineAccuracyEvaluator.cs

    r5809 r5894  
    3131    public double Accuracy {
    3232      get {
    33         if (n < 1)
    34           throw new InvalidOperationException("No elements");
    35         else
    36           return correctlyClassified / (double)n;
     33        return correctlyClassified / (double)n;
    3734      }
    3835    }
    … …  
    4340
    4441    #region IOnlineEvaluator Members
     42    private OnlineEvaluatorError errorState;
     43    public OnlineEvaluatorError ErrorState {
     44      get { return errorState; }
     45    }
    4546    public double Value {
    4647      get { return Accuracy; }
    … …  
    4950      n = 0;
    5051      correctlyClassified = 0;
     52      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    5153    }
    5254
    5355    public void Add(double original, double estimated) {
    54       if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    55           double.IsNaN(original) || double.IsInfinity(original)) {
    56         throw new ArgumentException("Accuracy is not defined for NaN or infinity elements");
    57       } else {
    58         if (original.IsAlmost(estimated)) correctlyClassified++;
     56      // ignore cases where original is NaN completly
     57      if (!double.IsNaN(original)) {
     58        // increment number of observed samples
    5959        n++;
     60        if (original.IsAlmost(estimated)) {
     61          // original = estimated = +Inf counts as correctly classified
     62          // original = estimated = -Inf counts as correctly classified
     63          correctlyClassified++;
     64        }
     65        errorState = OnlineEvaluatorError.None; // number of (non-NaN) samples >= 1
    6066      }
    6167    }
    6268    #endregion
    6369
    64     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     70    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6571      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6672      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7884        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    7985      } else {
     86        errorState = accuracyEvaluator.ErrorState;
    8087        return accuracyEvaluator.Accuracy;
    8188      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineCovarianceEvaluator.cs

    r5845 r5894  
    3939
    4040    #region IOnlineEvaluator Members
     41    private OnlineEvaluatorError errorState;
     42    public OnlineEvaluatorError ErrorState {
     43      get { return errorState; }
     44    }
    4145    public double Value {
    4246      get { return Covariance; }
    … …  
    4751      originalMean = 0.0;
    4852      estimatedMean = 0.0;
     53      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    4954    }
    5055
    5156    public void Add(double original, double estimated) {
    52       if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    53           double.IsNaN(original) || double.IsInfinity(original) ||
    54          double.IsNaN(Cn)) {
    55         Cn = double.NaN;
    56       } else {
     57      if (double.IsNaN(estimated) || double.IsInfinity(estimated) || double.IsNaN(original) || double.IsInfinity(original)) {
     58        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     59      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
    5760        n++;
     61        errorState = OnlineEvaluatorError.None;        // n >= 1
     62
    5863        // online calculation of tMean
    5964        originalMean = originalMean + (original - originalMean) / n;
    … …  
    6772    #endregion
    6873
    69     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     74    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    7075      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    7176      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    8388        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    8489      } else {
     90        errorState = covarianceEvaluator.ErrorState;
    8591        return covarianceEvaluator.Covariance;
    8692      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs

    r5818 r5894  
    3232    public double Alpha {
    3333      get {
    34         if (cnt < 2)
    35           return 0;
    36         else
    37           return targetMeanCalculator.Mean - Beta * originalMeanAndVarianceCalculator.Mean;
     34        return targetMeanCalculator.Mean - Beta * originalMeanAndVarianceCalculator.Mean;
    3835      }
    3936    }
    … …  
    4441    public double Beta {
    4542      get {
    46         if (cnt < 2)
    47           return 1;
    48         else if (originalMeanAndVarianceCalculator.PopulationVariance.IsAlmost(0.0))
     43        if (originalMeanAndVarianceCalculator.PopulationVariance.IsAlmost(0.0))
    4944          return 1;
    5045        else
    5146          return originalTargetCovarianceEvaluator.Covariance / originalMeanAndVarianceCalculator.PopulationVariance;
     47      }
     48    }
     49
     50    public OnlineEvaluatorError ErrorState {
     51      get {
     52        return targetMeanCalculator.MeanErrorState | originalMeanAndVarianceCalculator.MeanErrorState |
     53          originalMeanAndVarianceCalculator.PopulationVarianceErrorState | originalTargetCovarianceEvaluator.ErrorState;
    5254      }
    5355    }
    … …  
    9496    /// <param name="alpha">Additive constant for the linear scaling</param>
    9597    /// <param name="beta">Multiplicative factor for the linear scaling</param>
    96     public static void Calculate(IEnumerable<double> original, IEnumerable<double> target, out double alpha, out double beta) {
     98    /// <param name="errorState">Flag that indicates if errors occurred in the calculation of the linea scaling parameters.</param>
     99    public static void Calculate(IEnumerable<double> original, IEnumerable<double> target, out double alpha, out double beta, out OnlineEvaluatorError errorState) {
    97100      OnlineLinearScalingParameterCalculator calculator = new OnlineLinearScalingParameterCalculator();
    98101      IEnumerator<double> originalEnumerator = original.GetEnumerator();
    … …  
    110113        throw new ArgumentException("Number of elements in original and target enumeration do not match.");
    111114      } else {
     115        errorState = calculator.ErrorState;
    112116        alpha = calculator.Alpha;
    113117        beta = calculator.Beta;

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAbsolutePercentageErrorEvaluator.cs

    r5845 r5894  
    4040
    4141    #region IOnlineEvaluator Members
     42    private OnlineEvaluatorError errorState;
     43    public OnlineEvaluatorError ErrorState {
     44      get { return errorState; }
     45    }
    4246    public double Value {
    4347      get { return MeanAbsolutePercentageError; }
    … …  
    4650      n = 0;
    4751      sre = 0.0;
     52      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    4853    }
    4954
    … …  
    5156      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    5257          double.IsNaN(original) || double.IsInfinity(original) ||
    53         double.IsNaN(sre)) {
    54         sre = double.NaN;
    55       } else {
    56         if (!original.IsAlmost(0.0)) {
    57           sre += Math.Abs((estimated - original) / original);
    58           n++;
    59         }
     58        original.IsAlmost(0.0)) {
     59        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     60      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
     61        sre += Math.Abs((estimated - original) / original);
     62        n++;
     63        errorState = OnlineEvaluatorError.None; // n >= 1
    6064      }
    6165    }
    … …  
    6367    #endregion
    6468
    65     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     69    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6670      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6771      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7983        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    8084      } else {
     85        errorState = evaluator.ErrorState;
    8186        return evaluator.MeanAbsolutePercentageError;
    8287      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAndVarianceCalculator.cs

    r5845 r5894  
    2929    private int n;
    3030
     31    private OnlineEvaluatorError varianceErrorState;
     32    public OnlineEvaluatorError VarianceErrorState {
     33      get { return varianceErrorState; }
     34    }
     35
    3136    public double Variance {
    3237      get {
    … …  
    3540    }
    3641
     42    private OnlineEvaluatorError errorState;
     43    public OnlineEvaluatorError PopulationVarianceErrorState {
     44      get { return errorState; }
     45    }
    3746    public double PopulationVariance {
    3847      get {
    … …  
    4150    }
    4251
     52    public OnlineEvaluatorError MeanErrorState {
     53      get { return errorState; }
     54    }
    4355    public double Mean {
    4456      get {
    … …  
    5769    public void Reset() {
    5870      n = 0;
     71      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
     72      varianceErrorState = OnlineEvaluatorError.InsufficientElementsAdded;
    5973    }
    6074
    6175    public void Add(double x) {
    62       if (double.IsNaN(x) || double.IsInfinity(x) || double.IsNaN(m_newM)) {
    63         m_newM = double.NaN;
    64         m_newS = double.NaN;
    65       } else {
     76      if (double.IsNaN(x) || double.IsInfinity(x)) {
     77        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     78        varianceErrorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     79      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
    6680        n++;
    6781        // See Knuth TAOCP vol 2, 3rd edition, page 232
    … …  
    6983          m_oldM = m_newM = x;
    7084          m_oldS = 0.0;
     85          errorState = OnlineEvaluatorError.None; // n >= 1
    7186        } else {
     87          varianceErrorState = OnlineEvaluatorError.None; // n >= 1
    7288          m_newM = m_oldM + (x - m_oldM) / n;
    7389          m_newS = m_oldS + (x - m_oldM) * (x - m_newM);
    … …  
    8096    }
    8197
    82     public static void Calculate(IEnumerable<double> x, out double mean, out double variance) {
     98    public static void Calculate(IEnumerable<double> x, out double mean, out double variance, out OnlineEvaluatorError meanErrorState, out OnlineEvaluatorError varianceErrorState) {
    8399      OnlineMeanAndVarianceCalculator meanAndVarianceCalculator = new OnlineMeanAndVarianceCalculator();
    84100      foreach (double xi in x) {
    … …  
    87103      mean = meanAndVarianceCalculator.Mean;
    88104      variance = meanAndVarianceCalculator.Variance;
     105      meanErrorState = meanAndVarianceCalculator.MeanErrorState;
     106      varianceErrorState = meanAndVarianceCalculator.VarianceErrorState;
    89107    }
    90108  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanSquaredErrorEvaluator.cs

    r5845 r5894  
    3939
    4040    #region IOnlineEvaluator Members
     41    private OnlineEvaluatorError errorState;
     42    public OnlineEvaluatorError ErrorState {
     43      get { return errorState; }
     44    }
    4145    public double Value {
    4246      get { return MeanSquaredError; }
    … …  
    4549      n = 0;
    4650      sse = 0.0;
     51      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    4752    }
    4853
    4954    public void Add(double original, double estimated) {
    5055      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    51           double.IsNaN(original) || double.IsInfinity(original) ||
    52         double.IsNaN(sse)) {
    53         sse = double.NaN;
    54       } else {
     56          double.IsNaN(original) || double.IsInfinity(original)) {
     57        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     58      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
    5559        double error = estimated - original;
    5660        sse += error * error;
    5761        n++;
     62        errorState = OnlineEvaluatorError.None; // n >= 1
    5863      }
    5964    }
    6065    #endregion
    6166
    62     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     67    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6368      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6469      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7681        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    7782      } else {
     83        errorState = mseEvaluator.ErrorState;
    7884        return mseEvaluator.MeanSquaredError;
    7985      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineNormalizedMeanSquaredErrorEvaluator.cs

    r5809 r5894  
    4343
    4444    #region IOnlineEvaluator Members
     45    public OnlineEvaluatorError ErrorState {
     46      get { return meanSquaredErrorCalculator.MeanErrorState | originalVarianceCalculator.VarianceErrorState; }
     47    }
    4548    public double Value {
    4649      get { return NormalizedMeanSquaredError; }
    … …  
    6063    #endregion
    6164
    62     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     65    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6366      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6467      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7679        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    7780      } else {
     81        errorState = normalizedMSEEvaluator.ErrorState;
    7882        return normalizedMSEEvaluator.NormalizedMeanSquaredError;
    7983      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlinePearsonsRSquaredEvaluator.cs

    r5809 r5894  
    4646
    4747    #region IOnlineEvaluator Members
     48    public OnlineEvaluatorError ErrorState {
     49      get { return covEvaluator.ErrorState | sxEvaluator.PopulationVarianceErrorState | syEvaluator.PopulationVarianceErrorState; }
     50    }
    4851    public double Value {
    4952      get { return RSquared; }
    … …  
    6467    #endregion
    6568
    66     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     69    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6770      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6871      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    8083        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    8184      } else {
     85        errorState = rSquaredEvaluator.ErrorState;
    8286        return rSquaredEvaluator.RSquared;
    8387      }
Note: See TracChangeset for help on using the changeset viewer.